\section{Dynamic graph algorithms}
-In many applications, we often need to solve a~certain graph problem for a~sequence
-of graphs that differ only a~little, so recomputing the solution from scratch for
-every graph would be a~waste of time. In such cases, we usually turn our attention
-to \df{dynamic graph algorithms.} A~dynamic algorithm is in fact a~data structure
-that remembers a~graph and offers operations that modify the structure of the graph
-and also operations that query the result of the problem for the current state
-of the graph. A~typical example of a~problem of this kind is dynamic
-maintenance of connected components:
+In many applications, we often need to solve a~certain graph problem for a~sequence of graphs that
+differ only a~little, so recomputing the solution for every graph from scratch would be a~waste of
+time. In such cases, we usually turn our attention to \df{dynamic graph algorithms.} A~dynamic
+algorithm is in fact a~data structure that remembers a~graph. It offers operations that modify the
+structure of the graph and also operations that query the result of the problem for the current
+state of the graph. A~typical example of a~problem of this kind is dynamic maintenance of connected
+components:
\problemn{Dynamic connectivity}
Maintain an~undirected graph under a~sequence of the following operations:
\:$\<Insert>(G,u,v)$ --- Insert an~edge $uv$ to~$G$ and return its unique
identifier. This assumes that the edge did not exist yet.
\:$\<Delete>(G,e)$ --- Delete an~edge specified by its identifier from~$G$.
-\:$\<Connected>(G,u,v)$ --- Test if $u$ and~$v$ are in the same connected component of~$G$.
+\:$\<Connected>(G,u,v)$ --- Test if vertices $u$ and~$v$ are in the same connected component of~$G$.
\endlist
\para
any edges from the graph, which makes the problem substantially easier. This special
case is customarily called an~\df{incremental} or \df{semidynamic} graph algorithm.
We mentioned the Disjoint Set Union data structure of Tarjan and van Leeuwen (Theorem \ref{dfu})
-which can be used for that: Connected components are represented as an~equivalence classes.
+which can be used for that: Connected components are represented by equivalence classes.
Queries on connectedness translate to \<Find>, edge insertions to \<Find>
followed by \<Union> if the new edge joins two different components. This way,
a~sequence of $m$~operations starting with an~empty graph on $n$~vertices is
bound in the cell-probe model which is stronger than RAM with $\O(\log n)$-bit
words.
-The edges that have triggered the \<Union>s form a~spanning forest of the current graph.
-So far, all known algorithms for dynamic connectivity maintain some sort of a~spanning
-tree. This suggests that a~dynamic MST algorithm could be obtained by modifying the
-dynamic connectivity algorithms. This will indeed turn out to be true. Incremental MST
-is easy to achieve even in the few pages of this section, but making it fully dynamic will require
-more effort, so we will review some of the required building blocks before going into that.
+In this chapter, we will focus on the dynamic version of the minimum spanning forest.
+This problem seems to be intimately related to the dynamic connectivity. Indeed, all known
+algorithms for dynamic connectivity maintain some sort of a~spanning forest. For example, in the
+incremental algorithm we have just mentioned, this forest is formed by the edges that have
+triggered the \<Union>s. This suggests that a~dynamic MSF algorithm could be obtained by modifying
+the mechanism to keep the forest minimum. This will indeed turn out to be true, although we cannot
+be sure that it will lead to the most efficient solution possible --- as of now, the known lower
+bounds are very far.
+
+Incremental MST will be easy to achieve even in the few pages of this section, but making it fully
+dynamic will require more effort, so we will review some of the required building blocks before
+going into that.
We however have to answer one important question first: What should be the output of
our MSF data structure? Adding an~operation that would return the MSF of the current
and we have to modify~$F$ by exchanging the heaviest edge~$f$ of the path $F[e]$ with~$e$.
Correctness of the former case follows immediately from the Theorem on Minimality by order
-(\ref{mstthm}), because all $F'$-light would be also $F$-light, which is impossible as $F$~was
+(\ref{mstthm}), because any $F'$-light would be also $F$-light, which is impossible as $F$~was
minimum. In the latter case, the edge~$f$ is not contained in~$F'$ because it is the heaviest
on the cycle $F[e]+e$ (by the Red lemma, \ref{redlemma}). We can now use the Blue lemma
(\ref{bluelemma}) to prove that it should be replaced with~$e$. Consider the tree~$T$
of~$F$ that contains both endpoints of the edge~$e$. When we remove~$f$ from~$F$, this tree falls
-apart to two components $T_1$ and~$T_2$. The edge~$f$ was the lightest edge of the cut~$\delta_G(T_1)$
+apart to two components $T_1$ and~$T_2$. The edge~$f$ was the lightest in the cut~$\delta_G(T_1)$
and $e$~is lighter than~$f$, so $e$~is the lightest in~$\delta_{G'}(T_1)$ and hence $e\in F'$.
A~\<Delete> of an~edge that is not contained in~$F$ does not change~$F$. When we delete
There is a~data structure that represents a~forest of rooted trees on~$n$ vertices.
Each edge of the forest has a~weight drawn from a~totally ordered set. The structure
supports the following operations in time $\O(\log n)$ amortized:\foot{%
-The Link-Cut trees offer many other operations, but we do not mention them
+The Link-Cut trees can offer a~plethora of other operations, but we do not mention them
as they are not needed in our application.}
\itemize\ibull
\:$\<Parent>(v)$ --- Return the parent of~$v$ in its tree or \<null> if $v$~is a~root.
If more edges have the maximum weight, break the tie arbitrarily.
If there is no such edge ($v$~is the root itself), return \<null>.
\:$\<Link>(u,v,x)$ --- Connect the trees containing $u$ and~$v$ by an~edge $(u,v)$ of
- weight~$x$. Assumes that $u~$is a tree root and $v$~lies in a~different tree.
+ weight~$x$. Assumes that $v~$is a tree root and $u$~lies in a~different tree.
\:$\<Cut>(v)$ --- Split the tree containing the non-root vertex $v$ to two trees by
removing the edge $(\<Parent>(v),v)$. Returns the weight of this edge.
-\:$\<Evert>(v)$ --- Modify the orientations of the edges in the tree containing~$v$
- to make~$v$ the tree's root.
+\:$\<Evert>(v)$ --- Modify the orientations of edges to make~$v$ the root of its tree.
\endlist
%% \>Additionally, all edges on the path from~$v$ to $\<Root>(v)$ can be enumerated in
with weight~$w$ to be inserted.
\:$\<Evert>(u)$. \cmt{$u$~is now the root of its tree.}
\:If $\<Root>(v) \ne u$: \cmt{$u$~and~$v$ lie in different trees.}
-\::$\<Link>(u,v,w)$. \cmt{Connect the trees.}
+\::$\<Link>(v,u,w)$. \cmt{Connect the trees.}
\::Return ``$uv$ added''.
\:Otherwise: \cmt{both are in the same tree}
\::$y\=\<PathMax>(v)$.
\::$x\=\<Parent>(y)$. \cmt{Edge~$xy$ is the heaviest on $F[uv]$.}
\::If $\<Weight>(y) > w$: \cmt{We have to exchange~$xy$ with~$uv$.}
-\:::$\<Cut>(y)$, $\<Evert>(v)$, $\<Link>(v,y,w)$.
+\:::$\<Cut>(y)$, $\<Evert>(v)$, $\<Link>(u,v,w)$.
\:::Return ``$uv$~added, $xy$~removed''.
\::Otherwise return ``no changes''.
\algout The list of changes in~$F$.
Deletion of edges that do not belong to the MSF is trivial (we do not
need to change anything) and so is deletion of bridges (we just remove the bridge
from the Link-Cut tree, knowing that there is no edge to replace it). The hard part
-is the search for replacement edges after an~edge of the MSF is deleted.
+is the search for replacement edges after an~edge belonging to the MSF is deleted.
This very problem also has to be solved by algorithms for fully dynamic connectivity,
we will take a~look on them first.
An~important stop on the road to fully dynamic algorithms has the name \df{Eulerian Tour trees} or
simply \df{ET-trees}. It is a~representation of forests introduced by Henzinger and King
-\cite{henzinger:randdyn} in their randomized dynamic algorithms. It is similar to the one by Sleator
-and Tarjan, but it is much simpler and instead of path operations it offers efficient operations on
+\cite{henzinger:randdyn} in their randomized dynamic algorithms. It is similar to the Link-Cut
+trees, but it is much simpler and instead of path operations it offers efficient operations on
subtrees. It is also possible to attach auxiliary data to vertices and edges of the original tree.
\defn\id{eulseq}%
projects / saga.git / commitdiff