Chapter 18 first version

luku18.tex

@@ -1,31 +1,26 @@
 \chapter{Tree queries}
 
-\index{puukysely@puukysely}
+\index{tree query}
 
-Tässä luvussa tutustumme algoritmeihin,
+This chapter discusses techniques for
-joiden avulla voi toteuttaa tehokkaasti kyselyitä
+efficiently performing queries for a rooted tree.
-juurelliseen puuhun.
+The queries are related to subtrees and paths
-Kyselyt liittyvät puussa oleviin polkuihin
+in the tree.
-ja alipuihin.
+For example, possible queries are:
-Esimerkkejä kyselyistä ovat:
 
 \begin{itemize}
-\item mikä solmu on $k$ askelta ylempänä solmua $x$?
+\item what is the $k$th ancestor of node $x$?
-\item mikä on solmun $x$ alipuun arvojen summa?
+\item what is the sum of values in the subtree of node $x$?
-\item mikä on solmujen $a$ ja $b$ välisen polun arvojen summa?
+\item what is the sum of values in a path between nodes $a$ and $b$?
-\item mikä on solmujen $a$ ja $b$ alin yhteinen esivanhempi?
+\item what is the lowest common ancestor of nodes $a$ and $b$?
 \end{itemize}
 
-\section{Tehokas nouseminen}
+\section{Finding ancestors}
 
-Tehokas nouseminen puussa tarkoittaa,
+The $k$th ancestor of node $x$ in the tree is found
-että voimme selvittää nopeasti,
+when we ascend $k$ steps in the tree beginning at node $x$.
-mihin solmuun päätyy kulkemalla
+Let $f(x,k)$ denote the $k$th ancestor of node $x$.
-$k$ askelta ylöspäin solmusta $x$ alkaen.
+For example, in the following tree, $f(2,1)=1$ and $f(8,2)=4$.
-Merkitään $f(x,k)$ solmua,
-joka on $k$ askelta ylempänä solmua $x$.
-Esimerkiksi seuraavassa puussa
-$f(2,1)=1$ ja $f(8,2)=4$.
 
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
@@ -50,19 +45,20 @@ $f(2,1)=1$ ja $f(8,2)=4$.
 \end{tikzpicture}
 \end{center}
 
-Suoraviivainen tapa laskea funktion $f(x,k)$
+A straighforward way to calculate $f(x,k)$
-arvo on kulkea puussa $k$ askelta ylöspäin
+is to move $k$ steps upwards in the tree
-solmusta $x$ alkaen.
+beginning from node $x$.
-Tämän aikavaativuus on kuitenkin $O(n)$,
+However, the time complexity of this method
-koska on mahdollista, että puussa on
+is $O(n)$ because it is possible that the tree
-ketju, jossa on $O(n)$ solmua.
+contains a chain of $O(n)$ nodes.
 
-Kuten luvussa 16.3, funktion $f(x,k)$
+As in Chapter 16.3, any value of $f(x,k)$
-arvo on mahdollista laskea tehokkaasti ajassa
+can be efficiently calculated in $O(\log k)$
-$O(\log k)$ sopivan esikäsittelyn avulla.
+after preprocessing.
-Ideana on laskea etukäteen kaikki arvot
+The idea is to precalculate all values $f(x,k)$
-$f(x,k)$, joissa $k=1,2,4,8,\ldots$ eli 2:n potenssi.
+where $k$ is a power of two.
-Esimerkiksi yllä olevassa puussa muodostuu seuraava taulukko:
+For example, the values for the tree above
+are as follows:
 
 \begin{center}
 \begin{tabular}{r|rrrrrrrrr}
@@ -75,23 +71,23 @@ $\cdots$ \\
 \end{tabular}
 \end{center}
 
-Taulukossa arvo 0 tarkoittaa, että nousemalla $k$
+The value $0$ means that the $k$th ancestor
-askelta päätyy puun ulkopuolelle juurisolmun yläpuolelle.
+of a node doesn't exist.
 
-Esilaskenta vie aikaa $O(n \log n)$, koska jokaisesta
+The preprocessing takes $O(n \log n)$ time
-solmusta voi nousta korkeintaan $n$ askelta ylöspäin.
+because each node can have at most $n$ ancestors.
-Tämän jälkeen minkä tahansa funktion $f(x,k)$ arvon saa
+After this, any value $f(x,k)$ can be calculated
-laskettua ajassa $O(\log k)$ jakamalla nousun 2:n
+in $O(\log k)$ time by representing the value $k$
-potenssin osiin.
+as a sum where each term is a power of two.
 
-\section{Solmutaulukko}
+\section{Subtrees and paths}
 
-\index{solmutaulukko@solmutaulukko}
+\index{node array}
 
-\key{Solmutaulukko} sisältää juurellisen puun solmut siinä
+A \key{node array} contains the nodes of a rooted tree
-järjestyksessä kuin juuresta alkava syvyyshaku
+in the order in which a depth-first search
-vierailee solmuissa.
+from the root node visits them.
-Esimerkiksi puussa
+For example, in the tree
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
 \node[draw, circle] (1) at (0,3) {$1$};
@@ -114,7 +110,7 @@ Esimerkiksi puussa
 \path[draw,thick,-] (4) -- (9);
 \end{tikzpicture}
 \end{center}
-syvyyshaku etenee
+a depth-first search proceeds as follows:
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
 \node[draw, circle] (1) at (0,3) {$1$};
@@ -156,7 +152,7 @@ syvyyshaku etenee
 
 \end{tikzpicture}
 \end{center}
-ja solmutaulukoksi tulee:
+Hence, the corresponding node array is as follows:
 \begin{center}
 \begin{tikzpicture}[scale=0.7]
 \draw (0,0) grid (9,1);
@@ -184,13 +180,13 @@ ja solmutaulukoksi tulee:
 \end{tikzpicture}
 \end{center}
 
-\subsubsection{Alipuiden käsittely}
+\subsubsection{Subtree queries}
 
-Solmutaulukossa jokaisen alipuun kaikki solmut ovat peräkkäin
+Each subtree of a tree corresponds to a subarray
-niin, että ensin on alipuun juurisolmu ja sitten
+in the node array,
-kaikki muut alipuun solmut.
+where the first element is the root node.
-Esimerkiksi äskeisessä taulukossa solmun $4$
+For example, the following subarray contains the
-alipuuta vastaa seuraava taulukon osa:
+nodes in the subtree of node $4$:
 \begin{center}
 \begin{tikzpicture}[scale=0.7]
 \fill[color=lightgray] (4,0) rectangle (8,1);
@@ -218,19 +214,20 @@ alipuuta vastaa seuraava taulukon osa:
 \node at (8.5,1.4) {$9$};
 \end{tikzpicture}
 \end{center}
-Tämän ansiosta solmutaulukon avulla voi käsitellä tehokkaasti
+Using this fact, we can efficiently process queries
-puun alipuihin liittyviä kyselyitä.
+that are related to subtrees of the tree.
-Ratkaistaan esimerkkinä tehtävä,
+As an example, consider a problem where each node
-jossa kuhunkin puun solmuun liittyy
+is assigned a value, and our task is to support
-arvo ja toteutettavana on seuraavat kyselyt:
+the following queries:
 \begin{itemize}
-\item muuta solmun $x$ arvoa
+\item change the value of node $x$
-\item laske arvojen summa solmun $x$ alipuussa
+\item calculate the sum of values in the subtree of node $x$
 \end{itemize}
 
-Tarkastellaan seuraavaa puuta,
+Let us consider the following tree where blue numbers
-jossa siniset luvut ovat solmujen arvoja.
+are values of nodes.
-Esimerkiksi solmun $4$ alipuun arvojen summa on $3+4+3+1=11$.
+For example, the sum of values in the subtree of node $4$
+is $3+4+3+1=11$.
 
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
@@ -265,9 +262,10 @@ Esimerkiksi solmun $4$ alipuun arvojen summa on $3+4+3+1=11$.
 \end{tikzpicture}
 \end{center}
 
-Ideana on luoda solmutaulukko, joka sisältää jokaisesta solmusta
+The idea is to construct a node array that contains
-kolme tietoa: (1) solmun tunnus, (2) alipuun koko ja (3) solmun arvo.
+three values for each node: (1) identifier of the node,
-Esimerkiksi yllä olevasta puusta syntyy seuraava taulukko:
+(2) size of the subtree, and (3) value of the node.
+For example, the array for the above tree is as follows:
 
 \begin{center}
 \begin{tikzpicture}[scale=0.7]
@@ -316,9 +314,11 @@ Esimerkiksi yllä olevasta puusta syntyy seuraava taulukko:
 \end{tikzpicture}
 \end{center}
 
-Tästä taulukosta alipuun solmujen arvojen summa selviää
+Using this array, we can calculate the sum of nodes
-lukemalla ensin alipuun koko ja sitten sitä vastaavat solmut.
+in a subtree by first reading the size of the subtree
-Esimerkiksi solmun $4$ alipuun arvojen summa selviää näin:
+and then the values of the corresponding nodes.
+For example, the values in the subtree of node $4$
+can be found as follows:
 
 \begin{center}
 \begin{tikzpicture}[scale=0.7]
@@ -370,25 +370,26 @@ Esimerkiksi solmun $4$ alipuun arvojen summa selviää näin:
 \end{tikzpicture}
 \end{center}
 
-Viimeinen tarvittava askel on tallentaa solmujen arvot
+The remaining step is to store the values of the
-binääri-indeksi\-puuhun tai segmenttipuuhun.
+nodes in a binary indexed tree or segment tree.
-Tällöin sekä alipuun arvojen summan laskeminen
+After this, we can both calculate the sum
-että solmun arvon muuttaminen onnistuvat ajassa $O(\log n)$,
+of values and change a value in $O(\log n)$ time,
-eli pystymme vastaamaan kyselyihin tehokkaasti.
+so we can efficiently process the queries.
 
-\subsubsection{Polkujen käsittely}
+\subsubsection{Path queries}
 
-Solmutaulukon avulla voi myös käsitellä tehokkaasti
+Using a node array, we can also efficiently
-polkuja, jotka kulkevat juuresta tiettyyn solmuun puussa.
+process paths between the root node and any other
-Ratkaistaan seuraavaksi tehtävä,
+node in the tree.
-jossa toteutettavana on seuraavat kyselyt:
+Let us next consider a problem where our task
+is to support the following queries:
 \begin{itemize}
-\item muuta solmun $x$ arvoa
+\item change the value of node $x$
-\item laske arvojen summa juuresta solmuun $x$
+\item calculate the sum of values from the root to node $x$
 \end{itemize}
 
-Esimerkiksi seuraavassa puussa polulla solmusta 1
+For example, in the following tree, the sum of
-solmuun 8 arvojen summa on $4+5+3=12$.
+values from the root to node 8 is $4+5+3=12$.
 
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
@@ -423,15 +424,18 @@ solmuun 8 arvojen summa on $4+5+3=12$.
 \end{tikzpicture}
 \end{center}
 
-Ideana on muodostaa samanlainen taulukko kuin
+To solve this problem, we can use a similar
-alipuiden käsittelyssä mutta tallentaa
+technique as we used for subtree queries,
-solmujen arvot erikoisella tavalla:
+but the values of the nodes are stored
-kun taulukon kohdassa $k$ olevan solmun arvo on $a$,
+in a special way:
-kohdan $k$ arvoon lisätään $a$ ja kohdan $k+c$ arvosta
+if the value of a node at index $k$ 
-vähennetään $a$, missä $c$ on alipuun koko.
+increases by $a$,
+the value at index $k$ increases by $a$
+and the value at index $k+c$ decreases by $a$,
+where $c$ is the size of the subtree.
 
 \begin{samepage}
-Esimerkiksi yllä olevaa puuta vastaa seuraava taulukko:
+For example, the following array corresponds to the above tree:
 \begin{center}
 \begin{tikzpicture}[scale=0.7]
 \draw (0,1) grid (10,-2);
@@ -484,17 +488,19 @@ Esimerkiksi yllä olevaa puuta vastaa seuraava taulukko:
 \end{center}
 \end{samepage}
 
-Esimerkiksi solmun $3$ arvona on $-5$, koska
+For example, the value of node $3$ is $-5$,
-se on solmujen $2$ ja $6$ alipuiden jälkeinen solmu,
+because it is the next node after the subtrees
-mistä tulee arvoa $-5-3$, ja sen oma arvo on $3$.
+of nodes $2$ and $6$ and its own value is $3$.
-Yhteensä solmun 3 arvo on siis $-5-3+3=-5$.
+So the value decreases by $5+3$ and increases by $3$.
-Huomaa, että taulukossa on ylimääräinen kohta 10,
+Note that the array contains an extra index 10
-johon on tallennettu vain juuren arvon vastaluku.
+that only has the opposite number of the value
+of the root node.
 
-Nyt solmujen arvojen summa polulla juuresta alkaen
+Using this array, the sum of values in a path
-selviää laskemalla kaikkien taulukon arvojen summa
+from the root to node $x$ equals the sum
-taulukon alusta solmuun asti.
+of values in the array from the beginning to node $x$.
-Esimerkiksi summa solmusta $1$ solmuun $8$ selviää näin:
+For example, the sum from the root to node $8$
+can be calculated as follows:
 
 \begin{center}
 \begin{tikzpicture}[scale=0.7]
@@ -548,31 +554,31 @@ Esimerkiksi summa solmusta $1$ solmuun $8$ selviää näin:
 \node at (9.5,1.4) {$10$};
 \end{tikzpicture}
 \end{center}
-
+The sum is
-Summaksi tulee
 \[4+5+3-5+2+5-2=12,\]
-mikä vastaa polun summaa $4+5+3=12$.
+that equals the sum $4+5+3=12$.
-Tämä laskentatapa toimii, koska jokaisen solmun arvo
+This method works because the value of each node
-lisätään summaan, kun se tulee vastaan syvyyshaussa,
+is added to the sum when the depth-first search
-ja vähennetään summasta, kun sen käsittely päättyy.
+visits it for the first time, and correspondingly,
+the value is removed from the sum when the subtree of the
+node has been processed.
 
-Alipuiden käsittelyä vastaavasti voimme tallentaa
+Once again, we can store the values of the nodes
-arvot binääri-indeksi\-puuhun tai segmenttipuuhun ja
+in a binary indexed tree or a segment tree,
-sekä polun summan laskeminen että arvon muuttaminen
+so it is possible to both calculate the sum of values and
-onnistuvat ajassa $O(\log n)$.
+change a value efficiently in $O(\log n)$ time.
 
-\section{Alin yhteinen esivanhempi}
+\section{Lowest common ancestor}
 
-\index{alin yhteinen esivanhempi@alin yhteinen esivanhempi}
+\index{lowest common ancestor}
 
-Kahden puun solmun
+The \key{lowest common ancestor}
-\key{alin yhteinen esivanhempi}
+of two nodes is a the lowest node in the tree
-on mahdollisimman matalalla puussa oleva solmu,
+whose subtree contains both the nodes.
-jonka alipuuhun kumpikin solmu kuuluu.
+A typical problem is to efficiently process
-Tyypillinen tehtävä on vastata tehokkaasti
+queries where the task is to find the lowest
-joukkoon kyselyitä, jossa selvitettävänä on
+common ancestor of two nodes.
-kahden solmun alin yhteinen esivanhempi.
+For example, in the tree
-Esimerkiksi puussa
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
 \node[draw, circle] (1) at (0,3) {$1$};
@@ -592,25 +598,24 @@ Esimerkiksi puussa
 \path[draw,thick,-] (7) -- (8);
 \end{tikzpicture}
 \end{center}
-solmujen 5 ja 8 alin yhteinen esivanhempi on solmu 2
+the lowest common ancestor of nodes 5 and 8 is node 2,
-ja solmujen 3 ja 4 alin yhteinen esivanhempi on solmu 1.
+and the lowest common ancestor of nodes 3 and 4 is node 1.
 
-Tutustumme seuraavaksi kahteen tehokkaaseen menetelmään
+Next we will discuss two efficient techniques for
-alimman yhteisen esivanhemman selvittämiseen.
+finding the lowest common ancestor of two nodes.
 
-\subsubsection{Menetelmä 1}
+\subsubsection{Method 1}
 
-Yksi tapa ratkaista tehtävä on hyödyntää
+One way to solve the problem is use the fact
-tehokasta nousemista puussa.
+that we can efficiently find the $k$th
-Tällöin alimman yhteisen esivanhemman etsiminen
+ancestor of any node in the tree.
-muodostuu kahdesta vaiheesta.
+Using this idea, we can first ensure that
-Ensin noustaan alemmasta solmusta samalle tasolle
+both nodes are at the same level in the tree,
-ylemmän solmun kanssa,
+and then find the smallest value of $k$
-sitten noustaan rinnakkain kohti
+where the $k$th ancestor of both nodes is the same.
-alinta yhteistä esivanhempaa.
 
-Tarkastellaan esimerkkinä solmujen 5 ja 8
+As an example, let's find the lowest common
-alimman yhteisen esivanhemman etsimistä:
+ancestor of nodes $5$ and $8$ in the following tree:
 
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
@@ -632,10 +637,10 @@ alimman yhteisen esivanhemman etsimistä:
 \end{tikzpicture}
 \end{center}
 
-Solmu 5 on tasolla 3, kun taas solmu 8 on tasolla 4.
+Node $5$ is at level $3$, while node $8$ is at level $4$.
-Niinpä nousemme ensin solmusta 8 yhden tason ylemmäs solmuun 6.
+Thus, we first move one step upwards from node $8$ to node $6$.
-Tämän jälkeen nousemme rinnakkain solmuista 5 ja 6
+After this, it turns out that the parent of both node $5$
-lähtien yhden tason, jolloin päädymme solmuun 2:
+and node $6$ is node $2$, so we have found the lowest common ancestor.
 
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
@@ -661,16 +666,17 @@ lähtien yhden tason, jolloin päädymme solmuun 2:
 \end{tikzpicture}
 \end{center}
 
-Menetelmä vaatii $O(n \log n)$-aikaisen esikäsittelyn,
+Using this method, we can find the lowest common ancestor
-jonka jälkeen minkä tahansa kahden solmun alin yhteinen
+of any two nodes in $O(\log n)$ time after an $O(n \log n)$ time
-esivanhempi selviää ajassa $O(\log n)$,
+preprocessing, because both steps can be
-koska kumpikin vaihe nousussa vie aikaa $O(\log n)$.
+done in $O(\log n)$ time.
 
-\subsubsection{Menetelmä 2}
+\subsubsection{Method 2}
 
-Toinen tapa ratkaista tehtävä perustuu solmutaulukon
+Another way to solve the problem is based on
-käyttämiseen.
+a node array.
-Ideana on jälleen järjestää solmut syvyyshaun mukaan:
+Again, the idea is to traverse the nodes
+using a depth-first search:
 
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
@@ -707,16 +713,17 @@ Ideana on jälleen järjestää solmut syvyyshaun mukaan:
 \end{tikzpicture}
 \end{center}
 
-Erona aiempaan solmu lisätään kuitenkin solmutaulukkoon
+However, we add each node to the node array \emph{always}
-mukaan \textit{aina}, kun syvyyshaku käy solmussa,
+when the depth-first search visits the node,
-eikä vain ensimmäisellä kerralla.
+and not only at the first visit.
-Niinpä solmu esiintyy solmutaulukossa $k+1$ kertaa,
+Thus, a node that has $k$ children appears $k+1$ times
-missä $k$ on solmun lasten määrä,
+in the node array, and there are a total of $2n-1$
-ja solmutaulukossa on yhteensä $2n-1$ solmua.
+nodes in the array.
 
-Tallennamme solmutaulukkoon kaksi tietoa:
+We store two values in the array:
-(1) solmun tunnus ja (2) solmun taso puussa.
+(1) identifier of the node, and (2) the level of the 
-Esimerkkipuuta vastaavat taulukot ovat:
+node in the tree.
+The following array corresponds to the above tree:
 
 \begin{center}
 \begin{tikzpicture}[scale=0.7]
@@ -777,11 +784,11 @@ Esimerkkipuuta vastaavat taulukot ovat:
 \end{tikzpicture}
 \end{center}
 
-Tämän taulukon avulla solmujen $a$ ja $b$ alin yhteinen esivanhempi
+Using this array, we can find the lowest common ancestor
-selviää etsimällä taulukosta alimman tason solmu
+of nodes $a$ and $b$ by locating the node with lowest level
-solmujen $a$ ja $b$ välissä.
+between nodes $a$ and $b$ in the array.
-Esimerkiksi solmujen 5 ja 8 alin yhteinen esivanhempi
+For example, the lowest common ancestor of nodes $5$ and $8$
-löytyy seuraavasti:
+can be found as follows:
 
 \begin{center}
 \begin{tikzpicture}[scale=0.7]
@@ -845,36 +852,36 @@ löytyy seuraavasti:
 \end{tikzpicture}
 \end{center}
 
-Solmu 5 on taulukossa kohdassa 3,
+Node 5 is at index 3, node 8 is at index 6,
-solmu 8 on taulukossa kohdassa 6
+and the node with lowest level between
-ja alimman tason solmu välillä $3 \ldots 6$
+indices $3 \ldots 6$ is node 2 at index 4
-on kohdassa 4 oleva solmu 2,
+whose level is 2.
-jonka taso on 2.
+Thus, the lowest common ancestor of
-Niinpä solmujen 5 ja 8 alin yhteinen esivanhempi
+nodes 5 and 8 is node 2.
-on solmu 2.
 
-Alimman tason solmu välillä selviää
+Using a segment tree, we can find the lowest
-ajassa $O(\log n)$, kun taulukon sisältö on
+common ancestor in $O(\log n)$ time.
-tallennettu segmenttipuuhun.
+Since the array is static, the time complexity
-Myös aikavaativuus $O(1)$ on mahdollinen,
+$O(1)$ is also possible, but this is rarely needed.
-koska taulukko on staattinen, mutta tälle on harvoin tarvetta.
+In both cases, preprocessing takes $O(n \log n)$ time.
-Kummassakin tapauksessa esikäsittely vie aikaa $O(n \log n)$.
 
-\subsubsection{Solmujen etäisyydet}
+\subsubsection{Distances of nodes}
 
-Tarkastellaan lopuksi tehtävää,
+Finally, let's consider a problem where
-jossa kyselyissä tulee laskea tehokkaasti
+each query asks to find the distance between
-kahden solmun etäisyys eli solmujen välisen polun pituus puussa.
+two nodes in the tree, i.e., the length of the
-Osoittautuu, että tämä tehtävä
+path between them.
-palautuu alimman yhteisen esivanhemman etsimiseen.
+It turns out that this problem reduces to
+finding the lowest common ancestor.
 
-Valitaan ensin mikä tahansa
+First, we choose an arbitrary node for the
-solmu puun juureksi.
+root of the tree.
-Tämän jälkeen solmujen $a$ ja $b$
+After this, the distance between nodes $a$ and $b$
-etäisyys on $d(a)+d(b)-2 \cdot d(c)$,
+is $d(a)+d(b)-2 \cdot d(c)$,
-missä $c$ on solmujen alin yhteinen esivanhempi
+where $c$ is the lowest common ancestor,
-ja $d(s)$ on etäisyys puun juuresta solmuun $s$.
+and $d(s)$ is the distance from the root node
-Esimerkiksi puussa
+to node $s$.
+For example, in the tree
 
 \begin{center}
 \begin{tikzpicture}[scale=0.9]
@@ -899,14 +906,13 @@ Esimerkiksi puussa
 \path[draw=red,thick,-,line width=2pt] (6) -- node[font=\small] {} (3);
 \end{tikzpicture}
 \end{center}
-solmujen 5 ja 8 alin yhteinen esivanhempi on 2.
+the lowest common ancestor of nodes 5 and 8 is node 2.
-Polku solmusta 5 solmuun 8
+A path from node 5 to node 8
-kulkee ensin ylöspäin solmusta 5
+goes first upwards from node 5 to node 2,
-solmuun 2 ja sitten alaspäin
+and then downwards from node 2 to node 8.
-solmusta 2 solmuun 8.
+The distances of the nodes from the root are
-Solmujen etäisyydet juuresta ovat $d(5)=3$,
+$d(5)=3$, $d(8)=4$ and $d(2)=2$,
-$d(8)=4$ ja $d(2)=2$,
+so the distance between nodes 5 and 8 is
-joten solmujen 5 ja 8 etäisyys
+$3+4-2\cdot2=3$.
-on $3+4-2\cdot2=3$.