Korektury.

diff --git a/macros.tex b/macros.tex
index b0df97eebb0f74ab57b7012ae430d13033d56753..bedae0c16f8539fd5fd1560e4ab0169ee92ece95 100644 (file)
--- a/macros.tex
+++ b/macros.tex
@@ -38,6 +38,7 @@
 \def\o#1{\accent23 #1}
 \def\mst{\mathop{\rm mst}}
 \def\deg{\mathop{\rm deg}}
 \def\o#1{\accent23 #1}
 \def\mst{\mathop{\rm mst}}
 \def\deg{\mathop{\rm deg}}

+\def\timesalpha{\mskip2mu\alpha}

 
 % Footnotes
 \newcount\footcnt
 
 % Footnotes
 \newcount\footcnt

diff --git a/mst.tex b/mst.tex
index 9a1ac00d36379acf57e70e7465e26f045cdad073..fe6c3e34546ac2d5291eee38cf1b205f40421cdc 100644 (file)
--- a/mst.tex
+++ b/mst.tex
@@ -300,7 +300,7 @@ lemma all other (red) edges are outside~$T_{min}$, so the blue edges are exactly
 \section{Classical algorithms}
 
 The three classical MST algorithms can be easily stated in terms of the Red-Blue meta-algorithm.
 \section{Classical algorithms}
 
 The three classical MST algorithms can be easily stated in terms of the Red-Blue meta-algorithm.

-For each of them, we first state the general version of the algorithm, then we prove that
+For each of them, we first show the general version of the algorithm, then we prove that

 it gives the correct result and finally we discuss the time complexity of various
 implementations.
 
 it gives the correct result and finally we discuss the time complexity of various
 implementations.
 


@@ -315,8 +315,19 @@ implementations.
 \algout Minimum spanning tree~$T$.
 \endalgo
 
 \algout Minimum spanning tree~$T$.
 \endalgo
 

+\lemma\id{boruvkadrop}%
+In each iteration of the algorithm, the number of trees in~$T$ drops at least twice.
+
+\proof
+Each tree gets merged with at least one of its neighbors, so each of the new trees
+contains two or more original trees.
+\qed
+
+\cor
+The algorithm stops in $\O(\log n)$ iterations.
+

 \lemma
 \lemma

-Bor\o{u}vka's algorithm returns the MST of the input graph.
+Bor\o{u}vka's algorithm outputs the MST of the input graph.

 
 \proof
 In every iteration of the algorithm, $T$ is a blue subgraph,
 
 \proof
 In every iteration of the algorithm, $T$ is a blue subgraph,


@@ -325,37 +336,26 @@ application of the Blue rule. We stop when the blue subgraph is connected, so
 we do not need the Red rule to explicitly exclude edges.
 
 It remains to show that adding the edges simultaneously does not
 we do not need the Red rule to explicitly exclude edges.
 
 It remains to show that adding the edges simultaneously does not

-produce a cycle. Consider the first iteration of the algorithm where $T$ contains some cycle~$C$. Without
+produce a cycle. Consider the first iteration of the algorithm where $T$ contains a~cycle~$C$. Without

 loss of generality we can assume that $C=T_1[u_1v_1]\,v_1u_2\,T_2[u_2v_2]\,v_2u_3\,T_3[u_3v_3]\, \ldots \,T_k[u_kv_k]\,v_ku_1$.
 Each component $T_i$ has chosen its lightest incident edge~$e_i$ as either the edge $v_iu_{i+1}$
 or $v_{i-1}u_i$ (indexing cyclically). Assume that $e_1=v_1u_2$ (otherwise we reverse the orientation
 loss of generality we can assume that $C=T_1[u_1v_1]\,v_1u_2\,T_2[u_2v_2]\,v_2u_3\,T_3[u_3v_3]\, \ldots \,T_k[u_kv_k]\,v_ku_1$.
 Each component $T_i$ has chosen its lightest incident edge~$e_i$ as either the edge $v_iu_{i+1}$
 or $v_{i-1}u_i$ (indexing cyclically). Assume that $e_1=v_1u_2$ (otherwise we reverse the orientation

-of the cycle). Then $e_2=v_2u_3$ and $w(e_2)<w(e_1)$ and so on, giving $w(e_1)>w(e_2)>\ldots>w(e_k)>w(e_1)$,
-which is a contradiction. (Note that distinctness of edge weights was crucial here.)
+of the cycle). Then $e_2=v_2u_3$ and $w(e_2)<w(e_1)$ and we can continue in the same way,
+getting $w(e_1)>w(e_2)>\ldots>w(e_k)>w(e_1)$, which is a contradiction.
+(Note that distinctness of edge weights was crucial here.)

 \qed
 
 \qed
 

-\lemma\id{boruvkadrop}%
-In each iteration of the algorithm, the number of trees in~$T$ drops at least twice.
-
-\proof
-Each tree gets merged with at least one neighboring trees, so each of the new trees
-consists of at least two original trees.
-\qed
-
-\cor
-The algorithm stops in $\O(\log n)$ iterations.
-

 \lemma\id{boruvkaiter}%
 Each iteration can be carried out in time $\O(m)$.
 
 \proof
 \lemma\id{boruvkaiter}%
 Each iteration can be carried out in time $\O(m)$.
 
 \proof

-Following \cite{mm:mst},
-we assign a label to each tree and we keep a mapping from vertices to the
+We assign a label to each tree and we keep a mapping from vertices to the

 labels of the trees they belong to. We scan all edges, map their endpoints
 to the particular trees and for each tree we maintain the lightest incident edge
 so far encountered. Instead of merging the trees one by one (which would be too
 labels of the trees they belong to. We scan all edges, map their endpoints
 to the particular trees and for each tree we maintain the lightest incident edge
 so far encountered. Instead of merging the trees one by one (which would be too

-slow), we build an auxilliary graph whose vertices are labels of the original
+slow), we build an auxilliary graph whose vertices are the labels of the original

 trees and edges correspond to the chosen lightest inter-tree edges. We find connected
 trees and edges correspond to the chosen lightest inter-tree edges. We find connected

-components of this graph, these determine how the original labels are translated
+components of this graph, these determine how are the original labels translated

 to the new labels.
 \qed
 
 to the new labels.
 \qed
 


@@ -369,7 +369,7 @@ Follows from the previous lemmata.
 \algn{Jarn\'\i{}k \cite{jarnik:ojistem}, Prim \cite{prim:mst}, Dijkstra \cite{dijkstra:mst}}
 \algo
 \algin A~graph~$G$ with an edge comparison oracle.
 \algn{Jarn\'\i{}k \cite{jarnik:ojistem}, Prim \cite{prim:mst}, Dijkstra \cite{dijkstra:mst}}
 \algo
 \algin A~graph~$G$ with an edge comparison oracle.

-\:$T\=$ a single-vertex tree containing any vertex of~$G$.
+\:$T\=$ a single-vertex tree containing an~arbitrary vertex of~$G$.

 \:While there are vertices outside $T$:
 \::Pick the lightest edge $uv$ such that $u\in V(T)$ and $v\not\in V(T)$.
 \::$T\=T+uv$.
 \:While there are vertices outside $T$:
 \::Pick the lightest edge $uv$ such that $u\in V(T)$ and $v\not\in V(T)$.
 \::$T\=T+uv$.


@@ -377,18 +377,19 @@ Follows from the previous lemmata.
 \endalgo
 
 \lemma
 \endalgo
 
 \lemma

-Jarn\'\i{}k's algorithm returns the MST of the input graph.
+Jarn\'\i{}k's algorithm computers the MST of the input graph.

 
 \proof
 
 \proof

-During the course of the algorithm, $T$ is always a blue tree. Step~4 corresponds to applying
-the Blue rule to a cut between~$T$ and the rest of the given graph. We need not care about
+If~$G$ is connected, the algorithm always stops. Let us prove that in every step of
+the algorithm, $T$ is always a blue tree. Step~4 corresponds to applying
+the Blue rule to the cut $\delta(T)$ separating~$T$ from the rest of the given graph. We need not care about

 the remaining edges, since for a connected graph the algorithm always stops with the right
 number of blue edges.
 \qed
 
 \impl
 The most important part of the algorithm is finding \em{neighboring edges,} i.e., edges
 the remaining edges, since for a connected graph the algorithm always stops with the right
 number of blue edges.
 \qed
 
 \impl
 The most important part of the algorithm is finding \em{neighboring edges,} i.e., edges

-going between $T$ and $V(G)\setminus T$. In the straightforward implementation,
+of the cut $\delta(T)$. In a~straightforward implementation,

 searching for the lightest neighboring edge takes $\Theta(m)$ time, so the whole
 algorithm runs in time $\Theta(mn)$.
 
 searching for the lightest neighboring edge takes $\Theta(m)$ time, so the whole
 algorithm runs in time $\Theta(mn)$.
 


@@ -402,7 +403,7 @@ at most one insertion and at most one deletion, so we spend $\O(m\log n)$ time i
 From this, we can conclude:
 
 \thm
 From this, we can conclude:
 
 \thm

-Jarn\'\i{}k's algorithm finds the MST of the graph in time $\O(m\log n)$.
+Jarn\'\i{}k's algorithm finds the MST of a~given graph in time $\O(m\log n)$.

 
 \rem
 We will show several faster implementations in section \ref{fibonacci}.
 
 \rem
 We will show several faster implementations in section \ref{fibonacci}.


@@ -423,21 +424,24 @@ Kruskal's algorithm returns the MST of the input graph.
 
 \proof
 In every step, $T$ is a forest of blue trees. Adding~$e$ to~$T$
 
 \proof
 In every step, $T$ is a forest of blue trees. Adding~$e$ to~$T$

-in step~4 applies the Blue rule on the cut separating two components of~$T$ ($e$ is the lightest,
+in step~4 applies the Blue rule on the cut separating some pair of components of~$T$ ($e$ is the lightest,

 because all other edges of the cut have not been considered yet). Dropping~$e$ in step~5 corresponds
 because all other edges of the cut have not been considered yet). Dropping~$e$ in step~5 corresponds

-to the red rule on the cycle found ($e$~must be the heaviest, since all other edges of the
-cycle have been already processed). At the end of the algorithm, all edges have been colored,
+to the Red rule on the cycle found ($e$~must be the heaviest, since all other edges of the
+cycle have been already processed). At the end of the algorithm, all edges are colored,

 so~$T$ must be the~MST.
 \qed
 
 \impl
 so~$T$ must be the~MST.
 \qed
 
 \impl

-Except for the initial sorting, which in general takes $\Theta(m\log n)$ time, the only
-other non-trivial operation is detection of cycles. What we need is a data structure
+Except for the initial sorting, which in general takes $\Theta(m\log m)$ time, the only
+other non-trivial operation is the detection of cycles. What we need is a data structure

 for maintaining connected components, which supports queries and edge insertion.
 for maintaining connected components, which supports queries and edge insertion.

-The following theorem shows that it can be done with a surprising efficiency.
+(This is also known under the name Disjoint Set Union problem, i.e., maintenance
+of an~equivalence relation on a~set with queries on whether two elements are equivalent
+and the operation of joining two equivalence classes into one.)
+The following theorem shows that it can be done with surprising efficiency.

 
 \thmn{Incremental connectivity}%
 
 \thmn{Incremental connectivity}%

-When only edge insertions and queries are allowed, connected components
+When only edge insertions and connectivity queries are allowed, connected components

 can be maintained in $\O(\alpha(n))$ time amortized per operation.
 
 \proof
 can be maintained in $\O(\alpha(n))$ time amortized per operation.
 
 \proof


@@ -455,7 +459,7 @@ corresponding components and always recolor the smaller of the two components.
 
 \thm
 Kruskal's algorithm finds the MST of a given graph in time $\O(m\log n)$
 
 \thm
 Kruskal's algorithm finds the MST of a given graph in time $\O(m\log n)$

-or $\O(m\alpha(n))$ if the edges are already sorted by their weights.
+or $\O(m\timesalpha(n))$ if the edges are already sorted by their weights.

 
 \proof
 Follows from the above analysis.
 
 \proof
 Follows from the above analysis.


@@ -477,11 +481,11 @@ a linear-time algorithm for MST in planar graphs.
 There are two definitions of edge contraction which differ when an edge of a
 triangle is contracted. Either we unify the other two edges to a single edge
 or we keep them as two parallel edges, leaving us with a~multigraph. We will
 There are two definitions of edge contraction which differ when an edge of a
 triangle is contracted. Either we unify the other two edges to a single edge
 or we keep them as two parallel edges, leaving us with a~multigraph. We will

-use the multigraph version and show that we can easily reduce the multigraph
+use the multigraph version and we will show that we can easily reduce the multigraph

 to a simple graph later. (See \ref{contract} for the exact definitions.)
 
 We only need to be able to map edges of the contracted graph to the original
 to a simple graph later. (See \ref{contract} for the exact definitions.)
 
 We only need to be able to map edges of the contracted graph to the original

-edges, so each edge will carry a unique label $\ell(e)$ which will be preserved by
+edges, so each edge will carry a unique label $\ell(e)$ that will be preserved by

 contractions.
 
 \lemman{Flattening a multigraph}\id{flattening}%
 contractions.
 
 \lemman{Flattening a multigraph}\id{flattening}%


@@ -490,17 +494,16 @@ removed and each bundle of parallel edges replaced by its lightest edge.
 Then $G'$~has the same MST as~$G$.
 
 \proof
 Then $G'$~has the same MST as~$G$.
 
 \proof

-Loops can be never used in a spanning tree. If there is a spanning tree~$T$
+Every spanning tree of~$G'$ is a spanning tree of~$G$. In the other direction:
+Loops can be never contained in a spanning tree. If there is a spanning tree~$T$

 containing a removed edge~$e$ parallel to an edge~$e'\in G'$, exchaning $e'$
 containing a removed edge~$e$ parallel to an edge~$e'\in G'$, exchaning $e'$

-for~$e$ in~$T$ makes it lighter. \qed
+for~$e$ makes~$T$ lighter. \qed

 
 \rem Removal of the heavier of a pair of parallel edges can be also viewed
 as an application of the Red rule on a two-edge cycle. And indeed it is, the
 Red-Blue procedure works on multigraphs as well as on simple graphs and all the
 
 \rem Removal of the heavier of a pair of parallel edges can be also viewed
 as an application of the Red rule on a two-edge cycle. And indeed it is, the
 Red-Blue procedure works on multigraphs as well as on simple graphs and all the

-classical algorithms also do. We only would have to be more careful in the
-formulations and proofs, which we preferred to avoid. We also note that most of
-the algorithms can be run on disconnected multigraphs with little or no
-modifications.
+classical algorithms also do. We would only have to be more careful in the
+formulations and proofs, which we preferred to avoid.

 
 \algn{Contractive version of Bor\o{u}vka's algorithm}\id{contbor}
 \algo
 
 \algn{Contractive version of Bor\o{u}vka's algorithm}\id{contbor}
 \algo


@@ -510,7 +513,7 @@ modifications.
 \:While $n(G)>1$:
 \::For each vertex $v_i$ of~$G$, let $e_i$ be the lightest edge incident to~$v_i$.
 \::$T\=T\cup \{ \ell(e_i) \}$. \cmt{Remember labels of all selected edges.}
 \:While $n(G)>1$:
 \::For each vertex $v_i$ of~$G$, let $e_i$ be the lightest edge incident to~$v_i$.
 \::$T\=T\cup \{ \ell(e_i) \}$. \cmt{Remember labels of all selected edges.}

-\::Contract $G$ along all edges $e_i$, inheriting labels and weights.
+\::Contract $G$ along all edges $e_i$, inheriting labels and weights.\foot{In other words, we ask the comparison oracle for the edge $\ell(e)$ instead of~$e$.}

 \::Flatten $G$, removing parallel edges and loops.
 \algout Minimum spanning tree~$T$.
 \endalgo
 \::Flatten $G$, removing parallel edges and loops.
 \algout Minimum spanning tree~$T$.
 \endalgo


@@ -520,7 +523,7 @@ Each iteration of the algorithm can be carried out in time~$\O(m)$.
 
 \proof
 The only non-trivial parts are steps 6 and~7. Contractions can be handled similarly
 
 \proof
 The only non-trivial parts are steps 6 and~7. Contractions can be handled similarly

-to the unions in the original Bor\o{u}vka's algorithm (see \ref{boruvkaiter}).
+to the unions in the original Bor\o{u}vka's algorithm (see \ref{boruvkaiter}):

 We build an auxillary graph containing only the selected edges~$e_i$, find
 connected components of this graph and renumber vertices in each component to
 the identifier of the component. This takes $\O(m)$ time.
 We build an auxillary graph containing only the selected edges~$e_i$, find
 connected components of this graph and renumber vertices in each component to
 the identifier of the component. This takes $\O(m)$ time.


@@ -535,7 +538,7 @@ $\O(n+m)=\O(m)$.
 The Contractive Bor\o{u}vka's algorithm finds the MST in time $\O(m\log n)$.
 
 \proof
 The Contractive Bor\o{u}vka's algorithm finds the MST in time $\O(m\log n)$.
 
 \proof

-As in the original Bor\o{u}vka's algorithm, the number of phases is $\O(\log n)$.
+As in the original Bor\o{u}vka's algorithm, the number of iterations is $\O(\log n)$.

 Then apply the previous lemma.
 \qed
 
 Then apply the previous lemma.
 \qed
 


@@ -548,31 +551,31 @@ Let us denote the graph considered by the algorithm at the beginning of the $i$-
 iteration by $G_i$ (starting with $G_0=G$) and its number of vertices and edges
 by $n_i$ and $m_i$ respectively. As we already know from the previous lemma,
 the $i$-th iteration takes $\O(m_i)$ time. We are going to prove that the
 iteration by $G_i$ (starting with $G_0=G$) and its number of vertices and edges
 by $n_i$ and $m_i$ respectively. As we already know from the previous lemma,
 the $i$-th iteration takes $\O(m_i)$ time. We are going to prove that the

-$m_i$'s are decreasing exponentially.
+$m_i$'s are decreasing geometrically.

 
 

-The number of trees in the non-contracting version of the algorithm decreases
-at least twice in each iteration (Lemma \ref{boruvkadrop}) and the
+The number of trees in the non-contracting version of the algorithm drops
+at least by a factor of two in each iteration (Lemma \ref{boruvkadrop}) and the

 same must hold for the number of vertices in the contracting version.
 Therefore $n_i\le n/2^i$.
 
 However, every $G_i$ is planar, because the class of planar graphs is closed
 under edge deletion and contraction. The~$G_i$ is also simple as we explicitly removed multiple edges and
 same must hold for the number of vertices in the contracting version.
 Therefore $n_i\le n/2^i$.
 
 However, every $G_i$ is planar, because the class of planar graphs is closed
 under edge deletion and contraction. The~$G_i$ is also simple as we explicitly removed multiple edges and

-loops at the end of the previous iteration. So we can use the standard theorem on
+loops at the end of the previous iteration. Hence we can use the standard theorem on

 the number of edges of planar simple graphs (see for example \cite{diestel:gt}) to get $m_i\le 3n_i \le 3n/2^i$.
 From this we get that the total time complexity is $\O(\sum_i m_i)=\O(\sum_i n/2^i)=\O(n)$.
 \qed
 
 \rem
 the number of edges of planar simple graphs (see for example \cite{diestel:gt}) to get $m_i\le 3n_i \le 3n/2^i$.
 From this we get that the total time complexity is $\O(\sum_i m_i)=\O(\sum_i n/2^i)=\O(n)$.
 \qed
 
 \rem

-There are other possibilities how to find the MST of a planar graph in linear time.
-Matsui \cite{matsui:planar} has described an algorithm based on simultaneously
-processing the graph and its dual. The advantage of our approach is that we do not
-need to construct the planar embedding first.
+There are several other possibilities how to find the MST of a planar graph in linear time.
+For example, Matsui \cite{matsui:planar} has described an algorithm based on simultaneously
+working on the graph and its topological dual. We will show one more linear algorithm soon. The advantage
+of our approach is that we do not need to construct the planar embedding explicitly.

 
 \rem
 To achieve the linear time complexity, the algorithm needs a very careful implementation.
 Specifically, when we represent the graph using adjacency lists, whose heads are stored
 in an array indexed by vertex identifiers, we must renumber the vertices in each iteration.
 
 \rem
 To achieve the linear time complexity, the algorithm needs a very careful implementation.
 Specifically, when we represent the graph using adjacency lists, whose heads are stored
 in an array indexed by vertex identifiers, we must renumber the vertices in each iteration.

-Otherwise, unused identifiers could end up taking most of space in the arrays and scans of these
+Otherwise, unused elements could end up taking most of the space in the arrays and the scans of these

 arrays would have super-linear cost with respect to the size of the current graph~$G_i$.
 
 \rem
 arrays would have super-linear cost with respect to the size of the current graph~$G_i$.
 
 \rem


@@ -582,7 +585,7 @@ but we need to handle the bucket sorting somehow. We can create a small data str
 for every vertex and use a pointer to this structure as a unique identifier of the vertex.
 We will also keep a list of all vertex structures. During the bucket sort, each vertex
 structure will contain a pointer to the corresponding bucket and the vertex list will
 for every vertex and use a pointer to this structure as a unique identifier of the vertex.
 We will also keep a list of all vertex structures. During the bucket sort, each vertex
 structure will contain a pointer to the corresponding bucket and the vertex list will

-define the order of vertices (which can be arbitrary, but has to be fixed).
+define the order of vertices (which can be arbitrary).

 
 Graph contractions are indeed a~very powerful tool and they can be used in other MST
 algorithms as well. The following lemma shows the gist:
 
 Graph contractions are indeed a~very powerful tool and they can be used in other MST
 algorithms as well. The following lemma shows the gist:


@@ -600,11 +603,11 @@ their counterparts in~$G/e$. Then: $$\mst(G) = \pi^{-1}[\mst(G/e)] + e.$$
 %in a MST.
 The right-hand side of the equality is a spanning tree of~$G$, let us denote it by~$T$ and
 the MST of $G/e$ by~$T'$. If $T$ were not minimum, there would exist a $T$-light edge~$f$ in~$G$
 %in a MST.
 The right-hand side of the equality is a spanning tree of~$G$, let us denote it by~$T$ and
 the MST of $G/e$ by~$T'$. If $T$ were not minimum, there would exist a $T$-light edge~$f$ in~$G$

-(according to Theorem \ref{mstthm}). If the path $T[f]$ covered by~$f$ does not contain~$e$,
+(by Theorem \ref{mstthm}). If the path $T[f]$ covered by~$f$ does not contain~$e$,

 then $\pi[T[f]]$ is a path covered by~$\pi(f)$ in~$T'$. Otherwise $\pi(T[f]-e)$ is such a path.
 In both cases, $f$ is $T'$-light, which contradicts the minimality of~$T'$. (We do not have
 then $\pi[T[f]]$ is a path covered by~$\pi(f)$ in~$T'$. Otherwise $\pi(T[f]-e)$ is such a path.
 In both cases, $f$ is $T'$-light, which contradicts the minimality of~$T'$. (We do not have

-a~multigraph version of the theorem, but this direction is a straightforward edge exchange,
-which of course works in multigraphs as well.)
+a~multigraph version of the theorem, but the side we need is a~straightforward edge exchange,
+which obviously works in multigraphs as well.)

 \qed
 
 \rem
 \qed
 
 \rem


@@ -638,7 +641,7 @@ exactly $D_{k-1}$ with all weights increased by~1, which does not change the rel
 \defn
 A~\df{hedgehog}~$H_{a,k}$ is a graph consisting of $a$~distractors $D_k^1,\ldots,D_k^a$ of order~$k$
 together with edges of a complete graph on the bases of the distractors. These additional edges
 \defn
 A~\df{hedgehog}~$H_{a,k}$ is a graph consisting of $a$~distractors $D_k^1,\ldots,D_k^a$ of order~$k$
 together with edges of a complete graph on the bases of the distractors. These additional edges

-have unique weights larger than~$k$, i.e., they are heavier than the edges of the distractors.
+have arbitrary weights, but heavier than the edges of all distractors.

 
 \figure{hedgehog.eps}{\epsfxsize}{A~hedgehog $H_{5,2}$ (quills bent to fit in the picture)}
 
 
 \figure{hedgehog.eps}{\epsfxsize}{A~hedgehog $H_{5,2}$ (quills bent to fit in the picture)}
 


@@ -654,7 +657,7 @@ This is monotonely isomorphic to $H_{a,k-1}$.
 
 \thmn{Lower bound for Contractive Bor\o{u}vka}%
 For each $n$ there exists a graph on $\Theta(n)$ vertices and $\Theta(n)$ edges
 
 \thmn{Lower bound for Contractive Bor\o{u}vka}%
 For each $n$ there exists a graph on $\Theta(n)$ vertices and $\Theta(n)$ edges

-such that the Contractive Bor\o{u}vka's algorithm spends time $\Omega(m\log n)$ on it.
+such that the Contractive Bor\o{u}vka's algorithm spends time $\Omega(n\log n)$ on it.

 
 \proof
 Consider the hedgehog $H_{a,k}$ for $a=\lceil\sqrt n\rceil$ and $k=\lceil\log_2 a\rceil$.
 
 \proof
 Consider the hedgehog $H_{a,k}$ for $a=\lceil\sqrt n\rceil$ and $k=\lceil\log_2 a\rceil$.


@@ -671,23 +674,23 @@ edges as every $H_{a,k}$ contains a complete graph on~$a$ vertices.
 
 The contracting algorithm given in the previous section has been found to perform
 well on planar graphs, but in the general case its time complexity was not linear.
 
 The contracting algorithm given in the previous section has been found to perform
 well on planar graphs, but in the general case its time complexity was not linear.

-Can we find some broader class of graphs where the algorithm is still efficient?
+Can we find any broader class of graphs where the algorithm is still efficient?

 The right context turns out to be the minor-closed graph classes, which are
 closed under contractions and have bounded density.
 
 \defn
 A~graph~$H$ is a \df{minor} of a~graph~$G$ iff it can be obtained
 The right context turns out to be the minor-closed graph classes, which are
 closed under contractions and have bounded density.
 
 \defn
 A~graph~$H$ is a \df{minor} of a~graph~$G$ iff it can be obtained

-from a subgraph of~$G$ by a sequence of graph contractions (see \ref{simpcont}).
+from a subgraph of~$G$ by a sequence of simple graph contractions (see \ref{simpcont}).

 
 \defn
 A~class~$\cal C$ of graphs is \df{minor-closed}, when for every $G\in\cal C$ and
 
 \defn
 A~class~$\cal C$ of graphs is \df{minor-closed}, when for every $G\in\cal C$ and

-its minor~$H$, the graph~$H$ lies in~$\cal C$ as well. A~class~$\cal C$ is called
+its every minor~$H$, the graph~$H$ lies in~$\cal C$ as well. A~class~$\cal C$ is called

 \df{non-trivial} if at least one graph lies in~$\cal C$ and at least one lies outside~$\cal C$.
 
 \example
 Non-trivial minor-closed classes include planar graphs and more generally graphs
 embeddable in any fixed surface. Many nice properties of planar graphs extend
 \df{non-trivial} if at least one graph lies in~$\cal C$ and at least one lies outside~$\cal C$.
 
 \example
 Non-trivial minor-closed classes include planar graphs and more generally graphs
 embeddable in any fixed surface. Many nice properties of planar graphs extend

-to these classes, too, most notable the linearity of the number of edges.
+to these classes, too, most notably the linearity of the number of edges.

 
 \defn\id{density}%
 Let $\cal C$ be a class of graphs. We define its \df{edge density} $\varrho(\cal C)$
 
 \defn\id{density}%
 Let $\cal C$ be a class of graphs. We define its \df{edge density} $\varrho(\cal C)$


@@ -704,7 +707,7 @@ See Theorem 6.1 in \cite{nesetril:minors}, which also lists some other equivalen
 
 \thmn{MST on minor-closed classes \cite{mm:mst}}\id{mstmcc}%
 For any fixed non-trivial minor-closed class~$\cal C$ of graphs, Algorithm \ref{contbor} finds
 
 \thmn{MST on minor-closed classes \cite{mm:mst}}\id{mstmcc}%
 For any fixed non-trivial minor-closed class~$\cal C$ of graphs, Algorithm \ref{contbor} finds

-the MST of any graph from this class in time $\O(n)$. (The constant hidden in the~$\O$
+the MST of any graph in this class in time $\O(n)$. (The constant hidden in the~$\O$

 depends on the class.)
 
 \proof
 depends on the class.)
 
 \proof


@@ -716,13 +719,13 @@ and $n_i \le n/2^i$, so it remains to show a linear bound for the $m_i$'s.
 Since each $G_i$ is produced from~$G_{i-1}$ by a sequence of edge contractions,
 all $G_i$'s are minors of~$G$.\foot{Technically, these are multigraph contractions,
 but followed by flattening, so they are equivalent to contractions on simple graphs.}
 Since each $G_i$ is produced from~$G_{i-1}$ by a sequence of edge contractions,
 all $G_i$'s are minors of~$G$.\foot{Technically, these are multigraph contractions,
 but followed by flattening, so they are equivalent to contractions on simple graphs.}

-So they also belong to~$\cal C$ and by the previous theorem $m_i\le \varrho({\cal C})n_i$.
+So they also belong to~$\cal C$ and by the previous theorem $m_i\le \varrho({\cal C})\cdot n_i$.

 \qed
 
 \rem\id{nobatch}%
 The contractive algorithm uses ``batch processing'' to perform many contractions
 in a single step. It is also possible to perform contractions one edge at a~time,
 \qed
 
 \rem\id{nobatch}%
 The contractive algorithm uses ``batch processing'' to perform many contractions
 in a single step. It is also possible to perform contractions one edge at a~time,

-batching only the flattenings. A~contraction of an edge~$uv$ can be performed
+batching only the flattenings. A~contraction of an edge~$uv$ can be done

 in time~$\O(\deg(u))$ by removing all edges incident with~$u$ and inserting them back
 with $u$ replaced by~$v$. Therefore we need to find a lot of vertices with small
 degrees. The following lemma shows that this is always the case in minor-closed
 in time~$\O(\deg(u))$ by removing all edges incident with~$u$ and inserting them back
 with $u$ replaced by~$v$. Therefore we need to find a lot of vertices with small
 degrees. The following lemma shows that this is always the case in minor-closed


@@ -733,7 +736,7 @@ Let $\cal C$ be a graph class with density~$\varrho$ and $G\in\cal C$ a~graph
 with $n$~vertices. Then at least $n/2$ vertices of~$G$ have degree at most~$4\varrho$.
 
 \proof
 with $n$~vertices. Then at least $n/2$ vertices of~$G$ have degree at most~$4\varrho$.
 
 \proof

-Assume the contrary: let there be at least $n/2$ vertices with degree
+Assume the contrary: Let there be at least $n/2$ vertices with degree

 greater than~$4\varrho$.  Then $\sum_v \deg(v) > n/2
 \cdot 4\varrho = 2\varrho n$, which is in contradiction with the number
 of edges being at most $\varrho n$.
 greater than~$4\varrho$.  Then $\sum_v \deg(v) > n/2
 \cdot 4\varrho = 2\varrho n$, which is in contradiction with the number
 of edges being at most $\varrho n$.


@@ -748,14 +751,14 @@ $\deg(v)\le 4\varrho$.
 
 \algn{Local Bor\o{u}vka's Algorithm \cite{mm:mst}}%
 \algo
 
 \algn{Local Bor\o{u}vka's Algorithm \cite{mm:mst}}%
 \algo

-\algin A~graph~$G$ with an edge comparison oracle and a~parameter~$t$.
+\algin A~graph~$G$ with an edge comparison oracle and a~parameter~$t\in{\bb N}$.

 \:$T\=\emptyset$.
 \:$\ell(e)\=e$ for all edges~$e$.
 \:While $n(G)>1$:
 \::While there exists a~vertex~$v$ such that $\deg(v)\le t$:
 \:::Select the lightest edge~$e$ incident with~$v$.
 \:::Contract~$G$ along~$e$.
 \:$T\=\emptyset$.
 \:$\ell(e)\=e$ for all edges~$e$.
 \:While $n(G)>1$:
 \::While there exists a~vertex~$v$ such that $\deg(v)\le t$:
 \:::Select the lightest edge~$e$ incident with~$v$.
 \:::Contract~$G$ along~$e$.

-\:::$T\=T\cup \{ \ell(e_i) \}$.
+\:::$T\=T + \ell(e)$.

 \::Flatten $G$, removing parallel edges and loops.
 \algout Minimum spanning tree~$T$.
 \endalgo
 \::Flatten $G$, removing parallel edges and loops.
 \algout Minimum spanning tree~$T$.
 \endalgo


@@ -764,7 +767,7 @@ $\deg(v)\le 4\varrho$.
 When $\cal C$ is a minor-closed class of graphs with density~$\varrho$, the
 Local Bor\o{u}vka's Algorithm with the parameter~$t$ set to~$4\varrho$ 
 finds the MST of any graph from this class in time $\O(n)$. (The constant
 When $\cal C$ is a minor-closed class of graphs with density~$\varrho$, the
 Local Bor\o{u}vka's Algorithm with the parameter~$t$ set to~$4\varrho$ 
 finds the MST of any graph from this class in time $\O(n)$. (The constant

-in the~$\O$ depends on~the class only.)
+in the~$\O$ depends on~the class.)

 
 \proof
 Let us denote by $G_i$, $n_i$ and $m_i$ the graph considered by the
 
 \proof
 Let us denote by $G_i$, $n_i$ and $m_i$ the graph considered by the


@@ -780,8 +783,8 @@ $n_i\le 3/4\cdot n_{i-1}$. Therefore $n_i\le n\cdot (3/4)^i$ and the algorithm t
 after $\O(\log n)$ iterations.
 
 Each selected edge belongs to $\mst(G)$, because it is the lightest edge of
 after $\O(\log n)$ iterations.
 
 Each selected edge belongs to $\mst(G)$, because it is the lightest edge of

-the trivial cut separating~$v$ from the rest of the graph (see the Blue
-Rule in \ref{rbma}). The steps 6 and~7 therefore correspond to the operation
+the trivial cut $\delta(v)$ (see the Blue Rule in \ref{rbma}).
+The steps 6 and~7 therefore correspond to the operation

 described by the Lemma on contraction of MST edges (\ref{contlemma}) and when
 the algorithm stops, $T$~is indeed the minimum spanning tree.
 
 described by the Lemma on contraction of MST edges (\ref{contlemma}) and when
 the algorithm stops, $T$~is indeed the minimum spanning tree.
 


@@ -798,8 +801,8 @@ The whole algorithm therefore runs in time $\O(\sum_i m_i) = \O(\sum_i n/2^i) =
 
 \rem
 For planar graphs, we can get a sharper version of the low-degree lemma,
 
 \rem
 For planar graphs, we can get a sharper version of the low-degree lemma,

-showing that the algorithm works with $t=8$ as well (we got $t=12$ from the
-general version). While this does not change the asymptotic time complexity
+showing that the algorithm works with $t=8$ as well (we had $t=12$ as
+$\varrho=3$). While this does not change the asymptotic time complexity

 of the algorithm, the constant-factor speedup can still delight the hearts of
 its practical users.
 
 of the algorithm, the constant-factor speedup can still delight the hearts of
 its practical users.
 


@@ -812,7 +815,7 @@ It suffices to show that the lemma holds for triangulations (if there
 are any edges missing, the situation can only get better) with at
 least 3 vertices. Since $G$ is planar, $\sum_v \deg(v) < 6n$.
 The numbers $d(v):=\deg(v)-3$ are non-negative and $\sum_v d(v) < 3n$,
 are any edges missing, the situation can only get better) with at
 least 3 vertices. Since $G$ is planar, $\sum_v \deg(v) < 6n$.
 The numbers $d(v):=\deg(v)-3$ are non-negative and $\sum_v d(v) < 3n$,

-hence by the same argument as in the proof of the general lemma, for at least $n/2$
+so by the same argument as in the proof of the general lemma, for at least $n/2$

 vertices~$v$ it holds that $d(v) < 6$, hence $\deg(v) \le 8$.
 \qed
 
 vertices~$v$ it holds that $d(v) < 6$, hence $\deg(v) \le 8$.
 \qed
 


@@ -824,11 +827,11 @@ vertices have degree exactly~6. Therefore the number of faces~$f$ is $6/3\cdot n
 ignoring terms of order $\O(k)$. All interior triangles can be properly colored with
 two colors, black and white. Now add a~new vertex inside each white face and connect
 it to all three vertices on the boundary of that face. This adds $f/2 \approx n$
 ignoring terms of order $\O(k)$. All interior triangles can be properly colored with
 two colors, black and white. Now add a~new vertex inside each white face and connect
 it to all three vertices on the boundary of that face. This adds $f/2 \approx n$

-vertices of degree~3 and increases degrees of the original $\approx n$ interior
+vertices of degree~3 and it increases the degrees of the original $\approx n$ interior

 vertices to~9, therefore about a half of the vertices of the new planar graph
 has degree~9.
 
 vertices to~9, therefore about a half of the vertices of the new planar graph
 has degree~9.
 

-\figure{hexangle.eps}{\epsfxsize}{The construction in Remark~\ref{hexa}}
+\figure{hexangle.eps}{\epsfxsize}{The construction from Remark~\ref{hexa}}

 
 
 \section{Using Fibonacci heaps}
 
 
 \section{Using Fibonacci heaps}


@@ -841,5 +844,7 @@ has degree~9.
 % \O(...) as a set?
 % impedance mismatch in terminology: contraction of G along e vs. contraction of e.
 % use \delta(X) notation
 % \O(...) as a set?
 % impedance mismatch in terminology: contraction of G along e vs. contraction of e.
 % use \delta(X) notation

+% mention disconnected graphs
+%%% fix off by 1 errors in the distractors

 
 \endpart
 
 \endpart

diff --git a/notation.tex b/notation.tex
index 304edb39df792c82a8f50455b16c38789d1a8aec..429e7dd4a2fc5663b762679f2d5c7a05d2670711 100644 (file)
--- a/notation.tex
+++ b/notation.tex
@@ -7,7 +7,9 @@
 {\obeylines\parskip=0pt
 \def\n#1#2{\>\hbox to 6em{#1 \dotfill} #2}
 \def\[#1]{[\ref{#1}]}
 {\obeylines\parskip=0pt
 \def\n#1#2{\>\hbox to 6em{#1 \dotfill} #2}
 \def\[#1]{[\ref{#1}]}

-\n{$T[x,y]$}{the path in a tree~$T$ joining $x$ and $y$ \[heavy]}
+\n{$\bb R$}{the set of all real numbers}
+\n{$\bb N$}{the set of all natural numbers, including 0}
+\n{$T[u,v]$}{the path in a tree~$T$ joining vertices $u$ and $v$ \[heavy]}

 \n{$T[e]$}{the path in a tree~$T$ joining the endpoints of an~edge~$e$ \[heavy]}
 \n{$A\symdiff B$}{symetric difference of sets: $(A\setminus B) \cup (B\setminus A)$}
 \n{$G-e$}{graph $G$ with edge $e$ removed}
 \n{$T[e]$}{the path in a tree~$T$ joining the endpoints of an~edge~$e$ \[heavy]}
 \n{$A\symdiff B$}{symetric difference of sets: $(A\setminus B) \cup (B\setminus A)$}
 \n{$G-e$}{graph $G$ with edge $e$ removed}


@@ -18,14 +20,17 @@
 \n{$n(G)$}{number of vertices of a graph~$G$, that is $\vert V(G)\vert$}
 \n{$m(G)$}{number of edges of a graph~$G$, that is $\vert E(G)\vert$}
 \n{$V,E,n,m$}{when used without $(G)$, they refer to the input of the current algorithm}
 \n{$n(G)$}{number of vertices of a graph~$G$, that is $\vert V(G)\vert$}
 \n{$m(G)$}{number of edges of a graph~$G$, that is $\vert E(G)\vert$}
 \n{$V,E,n,m$}{when used without $(G)$, they refer to the input of the current algorithm}

+\n{$\delta_G(U)$}{all edges connecting $U\subset V(G)$ with $V(G)\setminus U$; we usually omit the~$G$}
+\n{$\delta_G(v)$}{the edges of a one-vertex cut, i.e., $\delta_G(\{v\})$}

 \n{MST}{minimum spanning tree \[mstdef]}
 \n{MSF}{minimum spanning forest \[mstdef]}
 \n{$\mst(G)$}{the unique minimum spanning tree of a graph~$G$ \[mstnota]}
 \n{MST}{minimum spanning tree \[mstdef]}
 \n{MSF}{minimum spanning forest \[mstdef]}
 \n{$\mst(G)$}{the unique minimum spanning tree of a graph~$G$ \[mstnota]}

-\n{$X \choose k$}{a set of $k$-element subsets of a set~$X$}
+\n{$X \choose k$}{a set of all $k$-element subsets of a set~$X$}

 \n{$G/e$}{multigraph contraction \[contract]}
 \n{$G.e$}{simple graph contraction \[simpcont]}
 \n{$\alpha(n)$}{the inverse Ackermann's function}
 \n{$G/e$}{multigraph contraction \[contract]}
 \n{$G.e$}{simple graph contraction \[simpcont]}
 \n{$\alpha(n)$}{the inverse Ackermann's function}

-\n{$f[X]$}{function applied to a set: $f[X]:=\{ f(x) ; x\in X \}$.}
+\n{$f[X]$}{function applied to a set: $f[X]:=\{ f(x) ; x\in X \}$}
+\n{$f[e]$}{as edges are two-element sets, $f[e]$ maps both endpoints of an edge~$e$}

 \n{$\varrho({\cal C})$}{edge density of a graph class~$\cal C$ \[density]}
 \n{$\deg_G(v)$}{degree of vertex~$v$ in graph~$G$; we omit $G$ if it is clear from context}
 \n{${\bb E}X$}{expected value of a~random variable~$X$}
 \n{$\varrho({\cal C})$}{edge density of a graph class~$\cal C$ \[density]}
 \n{$\deg_G(v)$}{degree of vertex~$v$ in graph~$G$; we omit $G$ if it is clear from context}
 \n{${\bb E}X$}{expected value of a~random variable~$X$}