bibin
/
cphb
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Corrections

This commit is contained in:
Antti H S Laaksonen 2017-02-06 00:44:42 +02:00
parent 215ea748b6
commit 6bb73a5c3e
1 changed files with 145 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

288
luku15.tex
View File

@ -2,14 +2,15 @@
\index{spanning tree} \index{spanning tree}
A \key{spanning tree} is a set of edges of a graph A \key{spanning tree} of a graph consists of
such that there is a path between any two nodes the nodes of the graph and some of the
in the graph using only the edges in the spanning tree. edges of the graph so that there is a unique path
Like trees in general, a spanning tree is between any two nodes.
Like trees in general, spanning trees are
connected and acyclic. connected and acyclic.
Usually, there are many ways to construct a spanning tree. Usually there are several ways to construct a spanning tree.
For example, in the graph For example, consider the following graph:
\begin{center} \begin{center}
\begin{tikzpicture}[scale=0.9] \begin{tikzpicture}[scale=0.9]
\node[draw, circle] (1) at (1.5,2) {$1$}; \node[draw, circle] (1) at (1.5,2) {$1$};
@ -28,7 +29,7 @@ For example, in the graph
\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6); \path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
\end{tikzpicture} \end{tikzpicture}
\end{center} \end{center}
one possible spanning tree is as follows: A possible spanning tree for the graph is as follows:
\begin{center} \begin{center}
\begin{tikzpicture}[scale=0.9] \begin{tikzpicture}[scale=0.9]
\node[draw, circle] (1) at (1.5,2) {$1$}; \node[draw, circle] (1) at (1.5,2) {$1$};
@ -54,7 +55,7 @@ $3+5+9+3+2=22$.
A \key{minimum spanning tree} A \key{minimum spanning tree}
is a spanning tree whose weight is as small as possible. is a spanning tree whose weight is as small as possible.
The weight of a minimum spanning tree for the above graph The weight of a minimum spanning tree for the above graph
is 20, and a tree can be constructed as follows: is 20, and such a tree can be constructed as follows:
\begin{center} \begin{center}
\begin{tikzpicture}[scale=0.9] \begin{tikzpicture}[scale=0.9]
@ -78,7 +79,7 @@ is 20, and a tree can be constructed as follows:
\index{maximum spanning tree} \index{maximum spanning tree}
Correspondingly, a \key{maximum spanning tree} In a similar way, a \key{maximum spanning tree}
is a spanning tree whose weight is as large as possible. is a spanning tree whose weight is as large as possible.
The weight of a maximum spanning tree for the The weight of a maximum spanning tree for the
above graph is 32: above graph is 32:
@ -102,45 +103,46 @@ above graph is 32:
\end{tikzpicture} \end{tikzpicture}
\end{center} \end{center}
Note that there may be several different ways Note that there may be several
for constructing a minimum or maximum spanning tree, minimum and maximum spanning trees
for a graph,
so the trees are not unique. so the trees are not unique.
This chapter discusses algorithms that construct This chapter discusses algorithms
a minimum or maximum spanning tree for a graph. for constructing spanning trees.
It turns out that it is easy to find such spanning trees It turns out that it is easy to find
because many greedy methods produce an optimal solution. minimum and maximum spanning trees,
because many greedy methods produce optimals solutions.
We will learn two algorithms that both construct the We will learn two algorithms that both process
tree by choosing edges ordered by weights. the edges of the graph ordered by their weights.
We will focus on finding a minimum spanning tree, We will focus on finding minimum spanning trees,
but the same algorithms can be used for finding a but similar algorithms can be used for finding
maximum spanning tree by processing the edges in reverse order. maximum spanning trees by processing the edges in reverse order.
\section{Kruskal's algorithm} \section{Kruskal's algorithm}
\index{Kruskal's algorithm} \index{Kruskal's algorithm}
In \key{Kruskal's algorithm}, the initial spanning tree In \key{Kruskal's algorithm}, the initial spanning tree
is empty and doesn't contain any edges. only contains the nodes of the graph
Then the algorithm adds edges to the tree and does not contain any edges.
one at a time Then the algorithm goes through the edges
in increasing order of their weights. ordered by their weights, and always adds an edge
At each step, the algorithm includes an edge in the tree to the tree if it does not create a cycle.
if it doesn't create a cycle.
Kruskal's algorithm maintains the components The algorithm maintains the components
in the tree. of the tree.
Initially, each node of the graph Initially, each node of the graph
is in its own component, belongs to a separate component.
and each edge added to the tree joins two components. Always when an edge is added to the tree,
Finally, all nodes will be in the same component, two components are joined.
Finally, all nodes belong to the same component,
and a minimum spanning tree has been found. and a minimum spanning tree has been found.
\subsubsection{Example} \subsubsection{Example}
\begin{samepage} \begin{samepage}
Let's consider how Kruskal's algorithm processes the Let us consider how Kruskal's algorithm processes the
following graph: following graph:
\begin{center} \begin{center}
\begin{tikzpicture}[scale=0.9] \begin{tikzpicture}[scale=0.9]
@ -184,7 +186,7 @@ edge & weight \\
\end{samepage} \end{samepage}
After this, the algorithm goes through the list After this, the algorithm goes through the list
and adds an edge to the tree if it joins and adds each edge to the tree if it joins
two separate components. two separate components.
Initially, each node is in its own component: Initially, each node is in its own component:
@ -208,8 +210,8 @@ Initially, each node is in its own component:
\end{tikzpicture} \end{tikzpicture}
\end{center} \end{center}
The first edge to be added to the tree is The first edge to be added to the tree is
edge 5--6 that joins components the edge 5--6 that creates the component $\{5,6\}$
$\{5\}$ and $\{6\}$ into component $\{5,6\}$: by joining the components $\{5\}$ and $\{6\}$:
\begin{center} \begin{center}
\begin{tikzpicture} \begin{tikzpicture}
@ -230,7 +232,7 @@ $\{5\}$ and $\{6\}$ into component $\{5,6\}$:
%\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6); %\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
\end{tikzpicture} \end{tikzpicture}
\end{center} \end{center}
After this, edges 1--2, 3--6 and 1--5 are added in a similar way: After this, the edges 1--2, 3--6 and 1--5 are added in a similar way:
\begin{center} \begin{center}
\begin{tikzpicture}[scale=0.9] \begin{tikzpicture}[scale=0.9]
@ -252,18 +254,17 @@ After this, edges 1--2, 3--6 and 1--5 are added in a similar way:
\end{tikzpicture} \end{tikzpicture}
\end{center} \end{center}
After those steps, many components have been joined After those steps, most components have been joined
and there are two components in the tree: and there are two components in the tree:
$\{1,2,3,5,6\}$ and $\{4\}$. $\{1,2,3,5,6\}$ and $\{4\}$.
The next edge in the list is edge 2--3, The next edge in the list is the edge 2--3,
but it will not be included in the tree because but it will not be included in the tree, because
nodes 2 and 3 are already in the same component. nodes 2 and 3 are already in the same component.
For the same reason, edge 2--5 will not be added For the same reason, the edge 2--5 will not be included in the tree.
to the tree.
\begin{samepage} \begin{samepage}
Finally, edge 4--6 will be included in the tree: Finally, the edge 4--6 will be included in the tree:
\begin{center} \begin{center}
\begin{tikzpicture}[scale=0.9] \begin{tikzpicture}[scale=0.9]
@ -286,25 +287,25 @@ Finally, edge 4--6 will be included in the tree:
\end{center} \end{center}
\end{samepage} \end{samepage}
After this, the algorithm terminates because After this, the algorithm will not add any
there is a path between any two nodes and new edges, because the graph is connected
the graph is connected. and there is a path between any two nodes.
The resulting graph is a minimum spanning tree The resulting graph is a minimum spanning tree
with weight $2+3+3+5+7=20$. with weight $2+3+3+5+7=20$.
\subsubsection{Why does this work?} \subsubsection{Why does this work?}
It's a good question why Kruskal's algorithm works. It is a good question why Kruskal's algorithm works.
Why does the greedy strategy guarantee that we Why does the greedy strategy guarantee that we
will find a minimum spanning tree? will find a minimum spanning tree?
Let's see what happens if the lightest edge in Let us see what happens if the minimum weight edge of
the graph is not included in the minimum spanning tree. the graph is not included in the spanning tree.
For example, assume that a minimum spanning tree For example, suppose that a spanning tree
for the above graph would not contain the edge for the above graph would not contain the
between nodes 5 and 6 with weight 2. minimum weight edge 5--6.
We don't know exactly how the new minimum spanning tree We do not know the exact structure of such a spanning tree,
would look like, but still it has to contain some edges. but in any case it has to contain some edges.
Assume that the tree would be as follows: Assume that the tree would be as follows:
\begin{center} \begin{center}
@ -324,10 +325,10 @@ Assume that the tree would be as follows:
\end{tikzpicture} \end{tikzpicture}
\end{center} \end{center}
However, it's not possible that the above tree However, it is not possible that the above tree
would be a real minimum spanning tree for the graph. would be a minimum spanning tree for the graph.
The reason for this is that we can remove an edge The reason for this is that we can remove an edge
from it and replace it with the edge with weight 2. from the tree and replace it with the minimum weight edge 5--6.
This produces a spanning tree whose weight is This produces a spanning tree whose weight is
\emph{smaller}: \emph{smaller}:
@ -348,23 +349,24 @@ This produces a spanning tree whose weight is
\end{tikzpicture} \end{tikzpicture}
\end{center} \end{center}
For this reason, it is always optimal to include the lightest edge For this reason, it is always optimal
in the minimum spanning tree. to include the minimum weight edge
Using a similar argument, we can show that we in the tree to produce a minimum spanning tree.
can also add the second lightest edge to the tree, and so on. Using a similar argument, we can show that it
Thus, Kruskal's algorithm works correctly and is also optimal to add the next edge in weight order
to the tree, and so on.
Hence, Kruskal's algorithm works correctly and
always produces a minimum spanning tree. always produces a minimum spanning tree.
\subsubsection{Implementation} \subsubsection{Implementation}
Kruskal's algorithm can be conveniently When implementing Kruskal's algorithm,
implemented using an edge list. the edge list representation of the graph
is convenient.
The first phase of the algorithm sorts the The first phase of the algorithm sorts the
edges in $O(m \log m)$ time. edges in the list in $O(m \log m)$ time.
After this, the second phase of the algorithm After this, the second phase of the algorithm
builds the minimum spanning tree. builds the minimum spanning tree as follows:
The second phase of the algorithm looks as follows:
\begin{lstlisting} \begin{lstlisting}
for (...) { for (...) {
@ -378,21 +380,21 @@ where $a$ and $b$ are two nodes.
The code uses two functions: The code uses two functions:
the function \texttt{same} determines the function \texttt{same} determines
if the nodes are in the same component, if the nodes are in the same component,
and the function \texttt{unite} and the function \texttt{union}
joins two components into a single component. joins the components that contain nodes $a$ and $b$.
The problem is how to efficiently implement The problem is how to efficiently implement
the functions \texttt{same} and \texttt{unite}. the functions \texttt{same} and \texttt{union}.
One possibility is to maintain the graph One possibility is to implement the function
in a usual way and implement the function \texttt{same} as graph traversal and check if
\texttt{same} as graph traversal. we can reach node $b$ from node $a$.
However, using this technique, However, the time complexity of such a function
the running time of the function \texttt{same} would be $O(n+m)$, would be $O(n+m)$,
and this would be slow because the function will be and the resulting algorithm would be slow,
called for each edge in the graph. because the function \texttt{same} will be called for each edge in the graph.
We will solve the problem using a union-find structure We will solve the problem using a union-find structure
that implements both the functions in $O(\log n)$ time. that implements both functions in $O(\log n)$ time.
Thus, the time complexity of Kruskal's algorithm Thus, the time complexity of Kruskal's algorithm
will be $O(m \log n)$ after sorting the edge list. will be $O(m \log n)$ after sorting the edge list.
@ -400,23 +402,23 @@ will be $O(m \log n)$ after sorting the edge list.
\index{union-find structure} \index{union-find structure}
The \key{union-find structure} maintains A \key{union-find structure} maintains
a collection of sets. a collection of sets.
The sets are disjoint, so no element The sets are disjoint, so no element
belongs to more than one set. belongs to more than one set.
Two $O(\log n)$ time operations are supported. Two $O(\log n)$ time operations are supported:
The first operation checks if two elements the \texttt{union} operation joins two sets,
belong to the same set, and the \texttt{find} operation finds the representative
and the second operation joins two sets into a single set. of the set that contains a given element.
\subsubsection{Structure} \subsubsection{Structure}
In the union-find structure, one element in each set In a union-find structure, one element in each set
is the representative of the set. is the representative of the set,
All other elements in the set point to the and there is a chain from any other element in the
representative directly or through other elements in the set. set to the representative.
For example, in the following picture there are three sets: For example, assume that the sets are
$\{1,4,7\}$, $\{5\}$ and $\{2,3,6,8\}$. $\{1,4,7\}$, $\{5\}$ and $\{2,3,6,8\}$:
\begin{center} \begin{center}
\begin{tikzpicture} \begin{tikzpicture}
\node[draw, circle] (1) at (0,-1) {$1$}; \node[draw, circle] (1) at (0,-1) {$1$};
@ -437,23 +439,22 @@ $\{1,4,7\}$, $\{5\}$ and $\{2,3,6,8\}$.
\end{tikzpicture} \end{tikzpicture}
\end{center} \end{center}
In this case the representatives In this example the representatives
of the sets are 4, 5 and 2. of the sets are 4, 5 and 2.
For each element, we can find the representative For each element, we can find its representative
for the corresponding set by following the by following the chain that begins at the element.
path that begins at the element. For example, the element 2 is the representative
For example, element 2 is the representative for the set for the element 6, because
that contains element 6 because there is a chain $6 \rightarrow 3 \rightarrow 2$.
the path is $6 \rightarrow 3 \rightarrow 2$. Two elements belong to the same set exactly when
Thus, two elements belong to the same set exactly when their representatives are the same.
they point to the same representative.
Two sets can be combined by connecting the Two sets can be joined by connecting the
representative of one set to the representative of one set to the
representative of another set. representative of another set.
For example, sets For example, the sets
$\{1,4,7\}$ and $\{2,3,6,8\}$ $\{1,4,7\}$ and $\{2,3,6,8\}$
can be combined as follows into set $\{1,2,3,4,6,7,8\}$: can be joined as follows:
\begin{center} \begin{center}
\begin{tikzpicture} \begin{tikzpicture}
\node[draw, circle] (1) at (2,-1) {$1$}; \node[draw, circle] (1) at (2,-1) {$1$};
@ -475,44 +476,45 @@ can be combined as follows into set $\{1,2,3,4,6,7,8\}$:
\end{tikzpicture} \end{tikzpicture}
\end{center} \end{center}
In this case, element 2 becomes the representative The resulting set contains the elements
for the whole set and the old representative 4 $\{1,2,3,4,6,7,8\}$.
points to it. From this on, the element 2 will be the representative
for the entire set and the old representative 4
will point to the element 2.
The efficiency of the operations depends on The efficiency of the structure depends on
the way the sets are combined. the way the sets are joined.
It turns out that we can follow a simple strategy It turns out that we can follow a simple strategy:
and always connect the representative of the always connect the representative of the
smaller set to the representative of the larger set smaller set to the representative of the larger set
(or, if the sets are of the same size, (or if the sets are of equal size,
both choices are fine). we can make an arbitrary choice).
Using this strategy, the length of a path from Using this strategy, the length of any chain
a element in a set to a representative is will be $O(\log n)$, so we can always efficiently
always $O(\log n)$ because each step forward find the representative of any element by following the chain.
in the path doubles the size of the corresponding set.
\subsubsection{Implementation} \subsubsection{Implementation}
We can implement the union-find structure The union-find structure can be implemented
using arrays. using arrays.
In the following implementation, In the following implementation,
array \texttt{k} contains for each element the array \texttt{k} contains for each element
the next element the next element
in the path, or the element itself if it is in the chain or the element itself if it is
a representative, a representative,
and array \texttt{s} indicates for each representative and the array \texttt{s} indicates for each representative
the size of the corresponding set. the size of the corresponding set.
Initially, each element has an own set with size 1: Initially, each element belongs to a separate set:
\begin{lstlisting} \begin{lstlisting}
for (int i = 1; i <= n; i++) k[i] = i; for (int i = 1; i <= n; i++) k[i] = i;
for (int i = 1; i <= n; i++) s[i] = 1; for (int i = 1; i <= n; i++) s[i] = 1;
\end{lstlisting} \end{lstlisting}
The function \texttt{find} returns The function \texttt{find} returns
the representative for element $x$. the representative for an element $x$.
The representative can be found by following The representative can be found by following
the path that begins at element $x$. the chain that begins at $x$.
\begin{lstlisting} \begin{lstlisting}
int find(int x) { int find(int x) {
@ -521,10 +523,10 @@ int find(int x) {
} }
\end{lstlisting} \end{lstlisting}
The function \texttt{same} finds out The function \texttt{same} checks
whether elements $a$ and $b$ belong to the same set. whether elements $a$ and $b$ belong to the same set.
This can easily be done by using the This can easily be done by using the
function \texttt{find}. function \texttt{find}:
\begin{lstlisting} \begin{lstlisting}
bool same(int a, int b) { bool same(int a, int b) {
@ -533,9 +535,9 @@ bool same(int a, int b) {
\end{lstlisting} \end{lstlisting}
\begin{samepage} \begin{samepage}
The function \texttt{union} combines the sets The function \texttt{union} joins the sets
that contain elements $a$ and $b$ that contain elements $a$ and $b$
into a single set. (the elements has to be in different sets).
The function first finds the representatives The function first finds the representatives
of the sets and then connects the smaller of the sets and then connects the smaller
set to the larger set. set to the larger set.
@ -544,7 +546,7 @@ set to the larger set.
void union(int a, int b) { void union(int a, int b) {
a = find(a); a = find(a);
b = find(b); b = find(b);
if (s[b] > s[a]) swap(a,b); if (s[a] < s[b]) swap(a,b);
s[a] += s[b]; s[a] += s[b];
k[b] = a; k[b] = a;
} }
@ -552,12 +554,12 @@ void union(int a, int b) {
\end{samepage} \end{samepage}
The time complexity of the function \texttt{find} The time complexity of the function \texttt{find}
is $O(\log n)$ assuming that the length of the is $O(\log n)$ assuming that the length of each
path is $O(\log n)$. chain is $O(\log n)$.
Thus, the functions \texttt{same} and \texttt{union} In this case, the functions \texttt{same} and \texttt{union}
also work in $O(\log n)$ time. also work in $O(\log n)$ time.
The function \texttt{union} ensures that the The function \texttt{union} makes sure that the
length of each path is $O(\log n)$ by connecting length of each chain is $O(\log n)$ by connecting
the smaller set to the larger set. the smaller set to the larger set.
\section{Prim's algorithm} \section{Prim's algorithm}
@ -567,7 +569,8 @@ the smaller set to the larger set.
\key{Prim's algorithm} is an alternative method \key{Prim's algorithm} is an alternative method
for finding a minimum spanning tree. for finding a minimum spanning tree.
The algorithm first adds an arbitrary node The algorithm first adds an arbitrary node
to the tree, and then always selects an edge to the tree.
After this, the algorithm always selects an edge
whose weight is as small as possible and whose weight is as small as possible and
that adds a new node to the tree. that adds a new node to the tree.
Finally, all nodes have been added to the tree Finally, all nodes have been added to the tree
@ -575,14 +578,13 @@ and a minimum spanning tree has been found.
Prim's algorithm resembles Dijkstra's algorithm. Prim's algorithm resembles Dijkstra's algorithm.
The difference is that Dijkstra's algorithm always The difference is that Dijkstra's algorithm always
selects an edge that creates a shortest path selects an edge whose distance from the starting
from the starting node to another node, node is minimum, but Prim's algorithm simply selects
but Prim's algorithm simply selects the lightest the minimum weight edge that adds a new node to the tree.
edge that adds a new node to the tree.
\subsubsection{Example} \subsubsection{Example}
Let's consider how Prim's algorithm works Let us consider how Prim's algorithm works
in the following graph: in the following graph:
\begin{center} \begin{center}
@ -624,8 +626,8 @@ Initially, there are no edges between the nodes:
%\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6); %\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
\end{tikzpicture} \end{tikzpicture}
\end{center} \end{center}
We can select an arbitrary node as a starting node, An arbitrary node can be the starting node,
so let's select node 1. so let us select node 1.
First, an edge with weight 3 connects nodes 1 and 2: First, an edge with weight 3 connects nodes 1 and 2:
\begin{center} \begin{center}
\begin{tikzpicture}[scale=0.9] \begin{tikzpicture}[scale=0.9]
@ -648,7 +650,7 @@ First, an edge with weight 3 connects nodes 1 and 2:
After this, there are two edges with weight 5, After this, there are two edges with weight 5,
so we can add either node 3 or node 5 to the tree. so we can add either node 3 or node 5 to the tree.
Let's add node 3 first: Let us add node 3 first:
\begin{center} \begin{center}
\begin{tikzpicture}[scale=0.9] \begin{tikzpicture}[scale=0.9]
\node[draw, circle] (1) at (1.5,2) {$1$}; \node[draw, circle] (1) at (1.5,2) {$1$};
@ -694,7 +696,7 @@ The process continues until all nodes have been included in the tree:
Like Dijkstra's algorithm, Prim's algorithm can be Like Dijkstra's algorithm, Prim's algorithm can be
efficiently implemented using a priority queue. efficiently implemented using a priority queue.
In this case, the priority queue contains all nodes The priority queue should contain all nodes
that can be connected to the current component using that can be connected to the current component using
a single edge, in increasing order of the weights a single edge, in increasing order of the weights
of the corresponding edges. of the corresponding edges.
@ -702,7 +704,7 @@ of the corresponding edges.
The time complexity of Prim's algorithm is The time complexity of Prim's algorithm is
$O(n + m \log m)$ that equals the time complexity $O(n + m \log m)$ that equals the time complexity
of Dijkstra's algorithm. of Dijkstra's algorithm.
In practice, Prim's algorithm and Kruskal's algorithm In practice, Prim's and Kruskal's algorithms
are both efficient, and the choice of the algorithm are both efficient, and the choice of the algorithm
is a matter of taste. is a matter of taste.
Still, most competitive programmers use Kruskal's algorithm. Still, most competitive programmers use Kruskal's algorithm.