Added mention of red and blue rules to the intro of opt.

diff --git a/adv.tex b/adv.tex
index cda98f9b61d8ce8977d93d25758667f5498599c1..dc4e70fcbdadab8e14a3dd0bebe5d2105a69a144 100644 (file)
--- a/adv.tex
+++ b/adv.tex
@@ -1228,14 +1228,14 @@ then $\sum_r n_r + m_r \le \sum_v 3n_v = \O(n)$. After adding the exceptional pa
 from the root, we get $\O(m+n)=\O(m)$.
 \qed
 
-\rem
+\paran{High probability}%
 There is also a~high-probability version of the above theorem. According to
 Karger, Klein and Tarjan \cite{karger:randomized}, the time complexity
 of the algorithm is $\O(m)$ with probability $1-\exp(-\Omega(m))$. The proof
 again follows the recursion tree and it involves applying the Chernoff bound
 \cite{chernoff} to bound the tail probabilities.
 
-\rem
+\paran{Different sampling}%
 We could also use a~slightly different formulation of the sampling lemma
 suggested by Chan \cite{chan:backward}. It changes the selection of the subgraph~$H$
 to choosing an~$mp$-edge subset of~$E(G)$ uniformly at random. The proof is then
@@ -1243,7 +1243,7 @@ a~straightforward application of the backward analysis method. We however prefer
 the Karger's original version, because generating a~random subset of a~given size
 requires an~unbounded number of random bits in the worst case.
 
-\rem
+\paran{On the Pointer Machine}%
 The only place where we needed the power of the RAM is finding the heavy edges,
 so we can employ the pointer-machine verification algorithm mentioned in \ref{pmverify}
 to bring the results of this section to the~PM.

diff --git a/biblio.bib b/biblio.bib
index cb317ab12287e5d38c5e3293f66006c8b59d0355..3e75568065f9fbd34d5642534001832b093c43da 100644 (file)
--- a/biblio.bib
+++ b/biblio.bib
@@ -1494,3 +1494,17 @@
   number = {2},
   pages = {247--255},
 }
+
+@article{375847,
+  author = {Ka Wong Chong and Yijie Han and Tak Wah Lam},
+  title = {Concurrent threads and optimal parallel minimum spanning trees algorithm},
+  journal = {Journal of the ACM},
+  volume = {48},
+  number = {2},
+  year = {2001},
+  issn = {0004-5411},
+  pages = {297--323},
+  doi = {http://doi.acm.org/10.1145/375827.375847},
+  publisher = {ACM},
+  address = {New York, NY, USA},
+}

diff --git a/opt.tex b/opt.tex
index bb07164cf7a0b3b2a6f172e3532ff474aa26d9f7..bfcfdcffac394eb811ec464d035908b8c62b2b82 100644 (file)
--- a/opt.tex
+++ b/opt.tex
@@ -6,10 +6,21 @@
 
 \section{Soft heaps}
 
+A~vast majority of MST algorithms that we have encountered so far is based on
+the Tarjan's Blue rule (Lemma \ref{bluelemma}). The rule serves to identify
+edges that belong to the MST, while all other edges are left in the process. This
+unfortunately means that the later stages of computation spend most of
+their time on these useless edges. A~notable exception is the randomized
+algorithm of Karger, Klein and Tarjan. It adds an~important ingredient: it uses
+Red rule (Lemma \ref{redlemma}) to filter out edges that are guaranteed to stay
+outside the MST, so that the graphs with which the algorithm works get smaller
+with time.
+
 Recently, Chazelle \cite{chazelle:ackermann} and Pettie \cite{pettie:ackermann}
-have presented algorithms for the MST with worst-case time complexity
+have presented new deterministic algorithms for the MST which are also based
+on the combination of both rules. They have reached worst-case time complexity
 $\O(m\timesalpha(m,n))$ on the Pointer Machine. We will devote this chapter to their results
-and especially to another algorithm by Pettie and Ramachandran \cite{pettie:optimal},
+and especially to another algorithm by Pettie and Ramachandran \cite{pettie:optimal}
 which is provably optimal.
 
 At the very heart of all these algorithms lies the \df{soft heap} discovered by