New file names [closes #1]
This commit is contained in:
Antti H S Laaksonen
parent
88010108d4
commit
0eb0397cd2
34 changed files with 0 additions and 0 deletions
712
chapter15.tex
Normal file
712
chapter15.tex
Normal file
|
|
@ -0,0 +1,712 @@
|
|||
\chapter{Spanning trees}
|
||||
|
||||
\index{spanning tree}
|
||||
|
||||
A \key{spanning tree} of a graph consists of
|
||||
the nodes of the graph and some of the
|
||||
edges of the graph so that there is a path
|
||||
between any two nodes.
|
||||
Like trees in general, spanning trees are
|
||||
connected and acyclic.
|
||||
Usually there are several ways to construct a spanning tree.
|
||||
|
||||
For example, consider the following graph:
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=below:5] {} (5);
|
||||
\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
\path[draw,thick,-] (6) -- node[font=\small,label=below:7] {} (4);
|
||||
\path[draw,thick,-] (2) -- node[font=\small,label=left:6] {} (5);
|
||||
\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
A possible spanning tree for the graph is as follows:
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
|
||||
The weight of a spanning tree is the sum of the edge weights.
|
||||
For example, the weight of the above spanning tree is
|
||||
$3+5+9+3+2=22$.
|
||||
|
||||
\index{minimum spanning tree}
|
||||
|
||||
A \key{minimum spanning tree}
|
||||
is a spanning tree whose weight is as small as possible.
|
||||
The weight of a minimum spanning tree for the example graph
|
||||
is 20, and such a tree can be constructed as follows:
|
||||
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=below:5] {} (5);
|
||||
\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
\path[draw,thick,-] (6) -- node[font=\small,label=below:7] {} (4);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=left:6] {} (5);
|
||||
\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
|
||||
\index{maximum spanning tree}
|
||||
|
||||
In a similar way, a \key{maximum spanning tree}
|
||||
is a spanning tree whose weight is as large as possible.
|
||||
The weight of a maximum spanning tree for the
|
||||
example graph is 32:
|
||||
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
%\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=below:5] {} (5);
|
||||
%\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
\path[draw,thick,-] (6) -- node[font=\small,label=below:7] {} (4);
|
||||
\path[draw,thick,-] (2) -- node[font=\small,label=left:6] {} (5);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
|
||||
Note that there may be several
|
||||
minimum and maximum spanning trees
|
||||
for a graph,
|
||||
so the trees are not unique.
|
||||
|
||||
This chapter discusses algorithms
|
||||
for constructing spanning trees.
|
||||
It turns out that it is easy to find
|
||||
minimum and maximum spanning trees,
|
||||
because many greedy methods produce optimals solutions.
|
||||
We will learn two algorithms that both process
|
||||
the edges of the graph ordered by their weights.
|
||||
We will focus on finding minimum spanning trees,
|
||||
but similar algorithms can be used for finding
|
||||
maximum spanning trees by processing the edges in reverse order.
|
||||
|
||||
\section{Kruskal's algorithm}
|
||||
|
||||
\index{Kruskal's algorithm}
|
||||
|
||||
In \key{Kruskal's algorithm} \cite{kru56}, the initial spanning tree
|
||||
only contains the nodes of the graph
|
||||
and does not contain any edges.
|
||||
Then the algorithm goes through the edges
|
||||
ordered by their weights, and always adds an edge
|
||||
to the tree if it does not create a cycle.
|
||||
|
||||
The algorithm maintains the components
|
||||
of the tree.
|
||||
Initially, each node of the graph
|
||||
belongs to a separate component.
|
||||
Always when an edge is added to the tree,
|
||||
two components are joined.
|
||||
Finally, all nodes belong to the same component,
|
||||
and a minimum spanning tree has been found.
|
||||
|
||||
\subsubsection{Example}
|
||||
|
||||
\begin{samepage}
|
||||
Let us consider how Kruskal's algorithm processes the
|
||||
following graph:
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=below:5] {} (5);
|
||||
\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
\path[draw,thick,-] (6) -- node[font=\small,label=below:7] {} (4);
|
||||
\path[draw,thick,-] (2) -- node[font=\small,label=left:6] {} (5);
|
||||
\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
\end{samepage}
|
||||
|
||||
\begin{samepage}
|
||||
The first step in the algorithm is to sort the
|
||||
edges in increasing order of their weights.
|
||||
The result is the following list:
|
||||
|
||||
\begin{tabular}{ll}
|
||||
\\
|
||||
edge & weight \\
|
||||
\hline
|
||||
5--6 & 2 \\
|
||||
1--2 & 3 \\
|
||||
3--6 & 3 \\
|
||||
1--5 & 5 \\
|
||||
2--3 & 5 \\
|
||||
2--5 & 6 \\
|
||||
4--6 & 7 \\
|
||||
3--4 & 9 \\
|
||||
\\
|
||||
\end{tabular}
|
||||
\end{samepage}
|
||||
|
||||
After this, the algorithm goes through the list
|
||||
and adds each edge to the tree if it joins
|
||||
two separate components.
|
||||
|
||||
Initially, each node is in its own component:
|
||||
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
%\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
%\path[draw,thick,-] (1) -- node[font=\small,label=below:5] {} (5);
|
||||
%\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
%\path[draw,thick,-] (6) -- node[font=\small,label=below:7] {} (4);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=left:6] {} (5);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
The first edge to be added to the tree is
|
||||
the edge 5--6 that creates the component $\{5,6\}$
|
||||
by joining the components $\{5\}$ and $\{6\}$:
|
||||
|
||||
\begin{center}
|
||||
\begin{tikzpicture}
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
|
||||
%\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
%\path[draw,thick,-] (1) -- node[font=\small,label=below:5] {} (5);
|
||||
\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
%\path[draw,thick,-] (6) -- node[font=\small,label=below:7] {} (4);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=left:6] {} (5);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
After this, the edges 1--2, 3--6 and 1--5 are added in a similar way:
|
||||
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=below:5] {} (5);
|
||||
\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
%\path[draw,thick,-] (6) -- node[font=\small,label=below:7] {} (4);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=left:6] {} (5);
|
||||
\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
|
||||
After those steps, most components have been joined
|
||||
and there are two components in the tree:
|
||||
$\{1,2,3,5,6\}$ and $\{4\}$.
|
||||
|
||||
The next edge in the list is the edge 2--3,
|
||||
but it will not be included in the tree, because
|
||||
nodes 2 and 3 are already in the same component.
|
||||
For the same reason, the edge 2--5 will not be included in the tree.
|
||||
|
||||
\begin{samepage}
|
||||
Finally, the edge 4--6 will be included in the tree:
|
||||
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=below:5] {} (5);
|
||||
\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
\path[draw,thick,-] (6) -- node[font=\small,label=below:7] {} (4);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=left:6] {} (5);
|
||||
\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
\end{samepage}
|
||||
|
||||
After this, the algorithm will not add any
|
||||
new edges, because the graph is connected
|
||||
and there is a path between any two nodes.
|
||||
The resulting graph is a minimum spanning tree
|
||||
with weight $2+3+3+5+7=20$.
|
||||
|
||||
\subsubsection{Why does this work?}
|
||||
|
||||
It is a good question why Kruskal's algorithm works.
|
||||
Why does the greedy strategy guarantee that we
|
||||
will find a minimum spanning tree?
|
||||
|
||||
Let us see what happens if the minimum weight edge of
|
||||
the graph is not included in the spanning tree.
|
||||
For example, suppose that a spanning tree
|
||||
for the previous graph would not contain the
|
||||
minimum weight edge 5--6.
|
||||
We do not know the exact structure of such a spanning tree,
|
||||
but in any case it has to contain some edges.
|
||||
Assume that the tree would be as follows:
|
||||
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
|
||||
\path[draw,thick,-,dashed] (1) -- (2);
|
||||
\path[draw,thick,-,dashed] (2) -- (5);
|
||||
\path[draw,thick,-,dashed] (2) -- (3);
|
||||
\path[draw,thick,-,dashed] (3) -- (4);
|
||||
\path[draw,thick,-,dashed] (4) -- (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
|
||||
However, it is not possible that the above tree
|
||||
would be a minimum spanning tree for the graph.
|
||||
The reason for this is that we can remove an edge
|
||||
from the tree and replace it with the minimum weight edge 5--6.
|
||||
This produces a spanning tree whose weight is
|
||||
\emph{smaller}:
|
||||
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
|
||||
\path[draw,thick,-,dashed] (1) -- (2);
|
||||
\path[draw,thick,-,dashed] (2) -- (5);
|
||||
\path[draw,thick,-,dashed] (3) -- (4);
|
||||
\path[draw,thick,-,dashed] (4) -- (6);
|
||||
\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
|
||||
For this reason, it is always optimal
|
||||
to include the minimum weight edge
|
||||
in the tree to produce a minimum spanning tree.
|
||||
Using a similar argument, we can show that it
|
||||
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.
|
||||
|
||||
\subsubsection{Implementation}
|
||||
|
||||
When implementing Kruskal's algorithm,
|
||||
the edge list representation of the graph
|
||||
is convenient.
|
||||
The first phase of the algorithm sorts the
|
||||
edges in the list in $O(m \log m)$ time.
|
||||
After this, the second phase of the algorithm
|
||||
builds the minimum spanning tree as follows:
|
||||
|
||||
\begin{lstlisting}
|
||||
for (...) {
|
||||
if (!same(a,b)) union(a,b);
|
||||
}
|
||||
\end{lstlisting}
|
||||
|
||||
The loop goes through the edges in the list
|
||||
and always processes an edge $a$--$b$
|
||||
where $a$ and $b$ are two nodes.
|
||||
Two functions are needed:
|
||||
the function \texttt{same} determines
|
||||
if the nodes are in the same component,
|
||||
and the function \texttt{union}
|
||||
joins the components that contain nodes $a$ and $b$.
|
||||
|
||||
The problem is how to efficiently implement
|
||||
the functions \texttt{same} and \texttt{union}.
|
||||
One possibility is to implement the function
|
||||
\texttt{same} as a graph traversal and check if
|
||||
we can get from node $a$ to node $b$.
|
||||
However, the time complexity of such a function
|
||||
would be $O(n+m)$
|
||||
and the resulting algorithm would be slow,
|
||||
because the function \texttt{same} will be called for each edge in the graph.
|
||||
|
||||
We will solve the problem using a union-find structure
|
||||
that implements both functions in $O(\log n)$ time.
|
||||
Thus, the time complexity of Kruskal's algorithm
|
||||
will be $O(m \log n)$ after sorting the edge list.
|
||||
|
||||
\section{Union-find structure}
|
||||
|
||||
\index{union-find structure}
|
||||
|
||||
A \key{union-find structure} maintains
|
||||
a collection of sets.
|
||||
The sets are disjoint, so no element
|
||||
belongs to more than one set.
|
||||
Two $O(\log n)$ time operations are supported:
|
||||
the \texttt{union} operation joins two sets,
|
||||
and the \texttt{find} operation finds the representative
|
||||
of the set that contains a given element.
|
||||
|
||||
\subsubsection{Structure}
|
||||
|
||||
In a union-find structure, one element in each set
|
||||
is the representative of the set,
|
||||
and there is a chain from any other element of the
|
||||
set to the representative.
|
||||
For example, assume that the sets are
|
||||
$\{1,4,7\}$, $\{5\}$ and $\{2,3,6,8\}$:
|
||||
\begin{center}
|
||||
\begin{tikzpicture}
|
||||
\node[draw, circle] (1) at (0,-1) {$1$};
|
||||
\node[draw, circle] (2) at (7,0) {$2$};
|
||||
\node[draw, circle] (3) at (7,-1.5) {$3$};
|
||||
\node[draw, circle] (4) at (1,0) {$4$};
|
||||
\node[draw, circle] (5) at (4,0) {$5$};
|
||||
\node[draw, circle] (6) at (6,-2.5) {$6$};
|
||||
\node[draw, circle] (7) at (2,-1) {$7$};
|
||||
\node[draw, circle] (8) at (8,-2.5) {$8$};
|
||||
|
||||
\path[draw,thick,->] (1) -- (4);
|
||||
\path[draw,thick,->] (7) -- (4);
|
||||
|
||||
\path[draw,thick,->] (3) -- (2);
|
||||
\path[draw,thick,->] (6) -- (3);
|
||||
\path[draw,thick,->] (8) -- (3);
|
||||
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
In this case the representatives
|
||||
of the sets are 4, 5 and 2.
|
||||
For each element, we can find its representative
|
||||
by following the chain that begins at the element.
|
||||
For example, the element 2 is the representative
|
||||
for the element 6, because
|
||||
we follow the chain $6 \rightarrow 3 \rightarrow 2$.
|
||||
Two elements belong to the same set exactly when
|
||||
their representatives are the same.
|
||||
|
||||
Two sets can be joined by connecting the
|
||||
representative of one set to the
|
||||
representative of another set.
|
||||
For example, the sets
|
||||
$\{1,4,7\}$ and $\{2,3,6,8\}$
|
||||
can be joined as follows:
|
||||
\begin{center}
|
||||
\begin{tikzpicture}
|
||||
\node[draw, circle] (1) at (2,-1) {$1$};
|
||||
\node[draw, circle] (2) at (7,0) {$2$};
|
||||
\node[draw, circle] (3) at (7,-1.5) {$3$};
|
||||
\node[draw, circle] (4) at (3,0) {$4$};
|
||||
\node[draw, circle] (6) at (6,-2.5) {$6$};
|
||||
\node[draw, circle] (7) at (4,-1) {$7$};
|
||||
\node[draw, circle] (8) at (8,-2.5) {$8$};
|
||||
|
||||
\path[draw,thick,->] (1) -- (4);
|
||||
\path[draw,thick,->] (7) -- (4);
|
||||
|
||||
\path[draw,thick,->] (3) -- (2);
|
||||
\path[draw,thick,->] (6) -- (3);
|
||||
\path[draw,thick,->] (8) -- (3);
|
||||
|
||||
\path[draw,thick,->] (4) -- (2);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
|
||||
The resulting set contains the elements
|
||||
$\{1,2,3,4,6,7,8\}$.
|
||||
From this on, the element 2 is the representative
|
||||
for the entire set and the old representative 4
|
||||
points to the element 2.
|
||||
|
||||
The efficiency of the union-find structure depends on
|
||||
how the sets are joined.
|
||||
It turns out that we can follow a simple strategy:
|
||||
always connect the representative of the
|
||||
smaller set to the representative of the larger set
|
||||
(or if the sets are of equal size,
|
||||
we can make an arbitrary choice).
|
||||
Using this strategy, the length of any chain
|
||||
will be $O(\log n)$, so we can
|
||||
find the representative of any element
|
||||
efficiently by following the corresponding chain.
|
||||
|
||||
\subsubsection{Implementation}
|
||||
|
||||
The union-find structure can be implemented
|
||||
using arrays.
|
||||
In the following implementation,
|
||||
the array \texttt{k} contains for each element
|
||||
the next element
|
||||
in the chain or the element itself if it is
|
||||
a representative,
|
||||
and the array \texttt{s} indicates for each representative
|
||||
the size of the corresponding set.
|
||||
|
||||
Initially, each element belongs to a separate set:
|
||||
\begin{lstlisting}
|
||||
for (int i = 1; i <= n; i++) k[i] = i;
|
||||
for (int i = 1; i <= n; i++) s[i] = 1;
|
||||
\end{lstlisting}
|
||||
|
||||
The function \texttt{find} returns
|
||||
the representative for an element $x$.
|
||||
The representative can be found by following
|
||||
the chain that begins at $x$.
|
||||
|
||||
\begin{lstlisting}
|
||||
int find(int x) {
|
||||
while (x != k[x]) x = k[x];
|
||||
return x;
|
||||
}
|
||||
\end{lstlisting}
|
||||
|
||||
The function \texttt{same} checks
|
||||
whether elements $a$ and $b$ belong to the same set.
|
||||
This can easily be done by using the
|
||||
function \texttt{find}:
|
||||
|
||||
\begin{lstlisting}
|
||||
bool same(int a, int b) {
|
||||
return find(a) == find(b);
|
||||
}
|
||||
\end{lstlisting}
|
||||
|
||||
\begin{samepage}
|
||||
The function \texttt{union} joins the sets
|
||||
that contain elements $a$ and $b$
|
||||
(the elements has to be in different sets).
|
||||
The function first finds the representatives
|
||||
of the sets and then connects the smaller
|
||||
set to the larger set.
|
||||
|
||||
\begin{lstlisting}
|
||||
void union(int a, int b) {
|
||||
a = find(a);
|
||||
b = find(b);
|
||||
if (s[a] < s[b]) swap(a,b);
|
||||
s[a] += s[b];
|
||||
k[b] = a;
|
||||
}
|
||||
\end{lstlisting}
|
||||
\end{samepage}
|
||||
|
||||
The time complexity of the function \texttt{find}
|
||||
is $O(\log n)$ assuming that the length of each
|
||||
chain is $O(\log n)$.
|
||||
In this case, the functions \texttt{same} and \texttt{union}
|
||||
also work in $O(\log n)$ time.
|
||||
The function \texttt{union} makes sure that the
|
||||
length of each chain is $O(\log n)$ by connecting
|
||||
the smaller set to the larger set.
|
||||
|
||||
\section{Prim's algorithm}
|
||||
|
||||
\index{Prim's algorithm}
|
||||
|
||||
\key{Prim's algorithm} \cite{pri57} is an alternative method
|
||||
for finding a minimum spanning tree.
|
||||
The algorithm first adds an arbitrary node
|
||||
to the tree.
|
||||
After this, the algorithm always chooses
|
||||
a minimum-weight edge that
|
||||
adds a new node to the tree.
|
||||
Finally, all nodes have been added to the tree
|
||||
and a minimum spanning tree has been found.
|
||||
|
||||
Prim's algorithm resembles Dijkstra's algorithm.
|
||||
The difference is that Dijkstra's algorithm always
|
||||
selects an edge whose distance from the starting
|
||||
node is minimum, but Prim's algorithm simply selects
|
||||
the minimum weight edge that adds a new node to the tree.
|
||||
|
||||
\subsubsection{Example}
|
||||
|
||||
Let us consider how Prim's algorithm works
|
||||
in the following graph:
|
||||
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=below:5] {} (5);
|
||||
\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
\path[draw,thick,-] (6) -- node[font=\small,label=below:7] {} (4);
|
||||
\path[draw,thick,-] (2) -- node[font=\small,label=left:6] {} (5);
|
||||
\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
|
||||
%\path[draw=red,thick,-,line width=2pt] (5) -- (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
Initially, there are no edges between the nodes:
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
%\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
%\path[draw,thick,-] (1) -- node[font=\small,label=below:5] {} (5);
|
||||
%\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
%\path[draw,thick,-] (6) -- node[font=\small,label=below:7] {} (4);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=left:6] {} (5);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
An arbitrary node can be the starting node,
|
||||
so let us choose node 1.
|
||||
First, we add node 2 that is connected by
|
||||
an edge of weight 3:
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
%\path[draw,thick,-] (1) -- node[font=\small,label=below:5] {} (5);
|
||||
%\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
%\path[draw,thick,-] (6) -- node[font=\small,label=below:7] {} (4);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=left:6] {} (5);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
|
||||
After this, there are two edges with weight 5,
|
||||
so we can add either node 3 or node 5 to the tree.
|
||||
Let us add node 3 first:
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
%\path[draw,thick,-] (1) -- node[font=\small,label=below:5] {} (5);
|
||||
%\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
%\path[draw,thick,-] (6) -- node[font=\small,label=below:7] {} (4);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=left:6] {} (5);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
|
||||
\begin{samepage}
|
||||
The process continues until all nodes have been included in the tree:
|
||||
\begin{center}
|
||||
\begin{tikzpicture}[scale=0.9]
|
||||
\node[draw, circle] (1) at (1.5,2) {$1$};
|
||||
\node[draw, circle] (2) at (3,3) {$2$};
|
||||
\node[draw, circle] (3) at (5,3) {$3$};
|
||||
\node[draw, circle] (4) at (6.5,2) {$4$};
|
||||
\node[draw, circle] (5) at (3,1) {$5$};
|
||||
\node[draw, circle] (6) at (5,1) {$6$};
|
||||
\path[draw,thick,-] (1) -- node[font=\small,label=above:3] {} (2);
|
||||
\path[draw,thick,-] (2) -- node[font=\small,label=above:5] {} (3);
|
||||
%\path[draw,thick,-] (3) -- node[font=\small,label=above:9] {} (4);
|
||||
%\path[draw,thick,-] (1) -- node[font=\small,label=below:5] {} (5);
|
||||
\path[draw,thick,-] (5) -- node[font=\small,label=below:2] {} (6);
|
||||
\path[draw,thick,-] (6) -- node[font=\small,label=below:7] {} (4);
|
||||
%\path[draw,thick,-] (2) -- node[font=\small,label=left:6] {} (5);
|
||||
\path[draw,thick,-] (3) -- node[font=\small,label=left:3] {} (6);
|
||||
\end{tikzpicture}
|
||||
\end{center}
|
||||
\end{samepage}
|
||||
|
||||
\subsubsection{Implementation}
|
||||
|
||||
Like Dijkstra's algorithm, Prim's algorithm can be
|
||||
efficiently implemented using a priority queue.
|
||||
The priority queue should contain all nodes
|
||||
that can be connected to the current component using
|
||||
a single edge, in increasing order of the weights
|
||||
of the corresponding edges.
|
||||
|
||||
The time complexity of Prim's algorithm is
|
||||
$O(n + m \log m)$ that equals the time complexity
|
||||
of Dijkstra's algorithm.
|
||||
In practice, Prim's and Kruskal's algorithms
|
||||
are both efficient, and the choice of the algorithm
|
||||
is a matter of taste.
|
||||
Still, most competitive programmers use Kruskal's algorithm.
|
||||
Loading…
Add table
Add a link
Reference in a new issue