2.4 Algorithms
2.4.1 Graphs
Let G = (V, E) be a graph on n vertices. For algorithms receiving G as input, it is always assumed thatV(G) = [n] and thatGis given by its adjacency lists. Note that then the number of vertices inGis also known. Consider an algorithm that receivesGand possibly some integers as input, for example an algorithm that computes anm-cut inG. The algorithm runs in linear time if its running time is bounded by a function that is linear in the input size, which is Θ(|V(G)|+|E(G)|) as each edge corresponds to exactly two entries in the adjacency lists. Therefore, the following definition is used.
Definition 2.18.
Thesizeof a graphG= (V, E) is defined askGk:=|V|+|E|.
Most of the algorithms presented here will compute a cut (B, W) in the input graphG. Usually, the cut (B, W) will be returned as a list of the vertices in the setB, which is not sorted and does not contain any repetitions. It is easy to order the vertices in the setB inO(n) time with the counting sort algorithm, which is presented in the next lemma.
Lemma 2.19 ([Cor+09]).
A list ofmitems in [n]can be sorted in O(n+m)time with the counting sort algorithm.
Basically, the idea is to put each item with valueiin theith place of an array of lengthn. Then, the ordered list of all m items can be obtained by traversing the array once. For details, see Chapter 8.2 in [Cor+09]. So, when an algorithm uses the counting sort algorithm to sort the vertices in the black set of a cut, then a list of the vertices in the white set can be read off the array as well, because a vertex lies in the white set if and only if its entry in the array is undefined.
Proposition 2.20.
Consider a graphG= (V, E)onnvertices withV = [n]and a cut(B, W)inG. When given an unordered list of the vertices in B, a list of the vertices inW can be determined inO(n)time.
LetGbe a graph on nvertices withV = [n]. The advantage of storing sets as unordered lists without repetitions is that computing the union of disjoint sets can be performed inO(1) time by concatenating the lists. Note that, when subsets of the vertices of a graph on nvertices are stored in binary arrays of lengthn, then it is necessary to traverse at least one of the arrays to compute the union of two sets.
However, this approach also works when the subsets are not disjoint. Here, we will mostly work with disjoint subsets and therefore sets are stored as unordered lists unless indicated otherwise.
Consider a graphG= (V, E) onnvertices. The assumptionV = [n] is natural for input graphs, see, for example, Chapter 4.1 in [SW11]. However, when considering an iterative procedure, where some algorithm is applied to the graph G and shall later be applied to a subgraph G0 ⊆ G on n0 vertices,
thenV0 :=V(G0) = [n0] is usually not satisfied. Still, the assumptionV = [n] cannot simply be ignored, as we will see in Section2.4.2, where some procedures that rely on arrays, which are indexed with the vertices ofG, are introduced. Weakening the assumption toV0⊆[n] might not be enough, as initializing an array of length n might take too long when n0 is much smaller than n. Therefore, whenever an algorithm is applied to a subgraphG0 and it relies on the assumption thatV0 = [n0], we will set up a bijection f betweenV0 and [n0]. The bijectionf is stored in two arrays F andF0 of lengthn andn0, respectively. For each vertexv ∈V0, the entryF[v] containsf(v) and, for each vertexv ∈V \V0, the entryF[v] may contain an arbitrary value. For each integers∈[n0], the entry F0[s] containsf−1(s), i. e., the vertexv∈V0 which is mapped tosbyf. When advancing fromG0 to a second subgraphG00⊆G0, the bijectionf is modified to be a bijection betweenV(G00) and [n00], wheren00 denotes the number of vertices ofG00. This is necessary, because applying too many bijections increases the running time of converting back the vertex names in the current subgraph to vertex names in the original graph. In particular, one has to be careful when the number of iterations is not bounded by a constant. The next lemma formalizes these ideas and also presents a method to check whether a vertexv∈V belongs toV0 in constant time. Note thatF0 contains a list of the vertices inV0 but, for a single vertexv∈V, it would take Ω(n0) time to check whetherv∈V0 by traversingF0.
Lemma 2.21.
Consider a graphG= (V, E) on nvertices with V = [n], a subgraphG0= (V0, E0)⊆Gon n0 vertices, and another subgraph G00= (V00, E00)⊆G0 onn00 vertices.
a) Given a list of the vertices in G0, a bijection between the vertex set of G0 and the set[n0], which is stored in two arrays of lengthn andn0, can be set up inO(n) time.
b) A bijection between the vertex subsetV0 and[n0]as ina)allows to convert each vertex name in V0 to the corresponding integer in[n0] in constant time and vice versa.
c) Given a bijection as ina), it is possible to check whether v∈V(G)belongs to the subgraph G0 in constant time.
d) Given a bijection between the vertices in G0 and the set[n0] as well as a list of the vertices inG00, the bijection can be updated to a bijection between the vertices in G00and the set [n00]inO(n00)time.
Proof. LetG= (V, E),G0= (V0, E0), andG00= (V00, E00) be as in the statement and denote by n,n0, andn00 their number of vertices, respectively.
a) First, the algorithm initializes two arraysF and F0 of length n andn0, respectively, with zeros.
Then it traverses the listL0 of vertices inV0. For thesth entryvin L0, the algorithm setsF[v] =s andF0[s] =v, which means that the bijection mapsv ∈V0 tos∈[n0]. All in all, this procedure takes O(n+n0) =O(n) time.
b) All necessary information is stored in the arrays of the bijection and accessing an entry of an array takes constant time.
c) Assume a bijection as ina)is stored in two arraysF andF0. Consider an arbitrary vertexv∈V. A vertexv∈V is inV0 if and only if there is an entry inF0 that containsv. Furthermore, for each vertexv∈V0, the entryF[v] is set to the indexswithF0[s] =v. So, for an arbitraryv ∈V, the algorithm does the following. First, it checks whether F[v] is an integer in [n0]. If not, thenv6∈V0. IfF[v] =s∈[n0], it checks whetherF0[s] =v. If so, thenv∈V0 and otherwisev6∈V0. Clearly, this procedure takes constant time.
d) Assume a bijection betweenV0 and [n0] is stored in two arraysF andF0 as ina), and a list L00 of the vertices in G00⊆G0 is given. First, the algorithm initializes a new arrayF00 of length n00 with zeros. Then it traverses the list L00 and does the same as the algorithm ina) to obtain a bijection betweenV00 and [n00] stored in the arraysF andF00. Note that this procedure works, as the algorithm does not read any information from the arrayF. Furthermore, the arrayF does not need to be initialized and, hence, the running time reduces toO(n00), compared toO(n+n00) time
for the procedure described ina). 2
In Partd), the arrayF0 is not overwritten for the following reason. When working with the subgraphG0, the assumptionV(G0) = [n0] will be used, which is feasible when a bijection as in Parta)has been set up.
However, then the subgraphG00⊆G0 will not be described with vertex names referring to the original vertex names inG, but with vertex names referring to the vertex set ofG0 after renaming the vertices ofG0 according to the bijection. Hence, it is natural to have a list of the vertices inG00, where each vertex is renamed according to the bijection between V(G0) and [n0]. Then, Partb) allows the algorithm to convert back to the corresponding vertex names of the original graphGby using the arrayF0.
Here, the assumptionV(G) = [n] is often needed when working with a tree decomposition as usually it is necessary to compute the union or the intersection of clusters. Therefore, whenever a tree decomposition is involved, we are careful and explicitly discuss how to rename the vertices such that V(G) = [n] is satisfied whenever a subroutine is called that receives a graphG, or maybe only a tree decomposition ofG, as input. When working with a tree or a forest, we are less careful, as the next lemma says that renaming the vertices is quick.
Lemma 2.22.
Let n0, n∈N be two integers with n≤n0 and let G= (V, E) be a forest on n vertices with V ⊆[n0].
In O(n)time, the vertices ofGcan be renamed such thatV(G) = [n]and an array F0 of lengthncan be set up such that, fors∈[n]the entry of F0[s] contains the vertex ofGthat was renamed to s.
Proof. Fixn0, n∈Nwithn≤n0 and consider a forestG= (V, E) onnvertices withV ⊆[n0] that is represented by its adjacency lists. For the following running time estimation, it is assumed that reserving and freeing any amount of space in memory takes constant time. First, the algorithm determines the number of vertices ofG, i. e., the number of adjacency lists, and the largest numbern00∈[n0] withn00∈V, which takes O(n) time by traversing the adjacency lists of G. Then, the algorithm creates an integer arrayF0 of length n and initializes it with zeros, which takesO(n) time. Moreover, it reserves space for an integer arrayF of length n00but does not initialize the arrayF. So, setting upF takes constant time. The algorithm traverses the set V and, for the sth vertex v∈V, it setsF[v] =sandF0[s] =v, which takes O(n) time. Observe that now, ifv ∈[n00] is a vertex ofG, thenF[v] contains a numbers such that F0[s] = v and, if v ∈[n0] is not a vertex of G, then either F[v] does not contain an index in [n] orF0[F[v]] is not v. To rename the vertices, the algorithm traverses the adjacency lists ofGand exchanges each entryv withF[v]. Finally the algorithm frees the space reserved for the arrayF. The arrayF0 contains all information needed to convert back the names of the vertices in the graphG. 2 Consider a treeT0 onn0 vertices and an algorithm that applies some procedure, which returns a vertex set and a subgraphT to which the same procedure is applied again and so on. As long as the procedure takesO(n) time for a treeT on nvertices, renaming the vertices of the current tree with Lemma2.22 does not increase the asymptotic running time. Indeed, setting up the bijection takes O(n) time and converting the vertex names of the computed set back to the original names takes constant time per vertex
and, hence, at mostO(n) time in total. Thus, to estimate the asymptotic running time of the algorithm, the time needed for renaming the vertices can be neglected.
Other than setting up and modifying a bijection in each iteration, one can also reuse the arrays of the first iteration: Then, after each iteration all arrays need to be cleaned up. For example, if an array of lengthninitialized with zeros is needed, then each entry needs to be set back to zero after the first iteration. This does not require to traverse the entire array when the algorithm keeps track of the modified entries and sets them back to zero, or as usually only entries referring to vertices of the current subgraph are modified, the algorithm can traverse all corresponding entries. This additional step of cleaning up arrays requires at most as much time as the iteration itself. Then, the next procedure does not need to initialize the arrays and the weakened assumptionV(G0)⊆[n] suffices.
Lemma2.21is also useful for computing induced subgraphs and subgraphs created by removing some set of vertices, as the following corollaries show.
Corollary 2.23.
Consider a graphG= (V, E)onnvertices with V = [n]and a vertex setV0⊆V. Letn0:=|V0|. There is an algorithm that computes the adjacency lists ofG0:=G[V0] inO(kGk)time, when given the adjacency lists of Gand a list of the vertices inV0. While doing so, it can set up a bijection or update an existing bijection betweenV(G0)and[n0]as in Lemma 2.21a).
Proof. Let G = (V, E), n, V0, and G0 be as in the statement. Using the list of vertices of G0, the algorithm sets up a bijection betweenV(G0) and [n0], which takesO(n) time by Lemma2.21a). This also provides a method to check whether a vertexv∈V is inV0 in constant time by Lemma2.21c). Then, the algorithm traverses the adjacency lists ofGand creates a copy that contains only the entries that are relevant for the subgraphG0. More precisely, when an adjacency list of a vertexv∈V is processed, then it is skipped ifv6∈V0. Otherwise,v∈V0 and the algorithm traverses all entrieswof the adjacency list ofv and keeps the ones withw∈V0. This procedure takesO(n+kGk) =O(kGk) time. 2 Corollary 2.24.
Consider a graph G= (V, E) on n vertices withV = [n] and a vertex set S ⊆V. Let n0 := n− |S|.
There is an algorithm that computes the adjacency lists ofG0 :=G−S inO(kGk)time, when given the adjacency lists ofGand a list of the vertices inS. While doing so, it can set up a bijection or update an existing bijection betweenV(G0)and[n0] as in Lemma2.21a).
Proof. LetG= (V, E),n,S, andG0 be as in the statement. A list of the vertices inG0 can be obtained in O(n) time by applying the same procedure as in Proposition 2.20. Then, the result follows from
Corollary2.23, asG0:=G−S=G[V \S]. 2
The following lemma about computing the components of a graph is a basic fact, see Chapter 4.1 in [SW11].
Lemma 2.25.
Let G= (V, E) be a graph. When traversingGwith a depth-first search, one can compute
• the number of components of G,
• for each componentG˜ of Gthe number of vertices inG, and˜
• for each componentG˜ of Ga list of the vertices in G˜ inO(kGk)time.
1
Figure 2.4:A plane graphG, its rotation systems, and the list of vertices on the boundary of each face, that is obtained when walking along the boundary. The red arrows indicate the circular ordering at each vertex.
Consider a graphG= (V, E) that is represented by its adjacency lists. Recall that each edge{v, w} ∈E corresponds to two entries in the adjacency lists ofG, namely the entryw in the adjacency list ofvand the entryv in the adjacency list ofw. For example, to delete the edge{v, w} quickly, it is useful to have some connection between these two entries in the adjacency list ofG. So, once one of the entries is found, the other one can be determined in constant time. This is achieved by adding pointers between the two entries representing one edge. More precisely, for the edge{v, w}, the entry win the adjacency list ofv contains additionally a pointer to the entryvin the adjacency list ofwand vice versa. If this is the case for every entry in the adjacency lists ofG, we say that the adjacency lists arelinked. Linked adjacency lists can be set up in linear time, by first creating a list of the edges, which can be read off the adjacency lists, deleting all entries in the adjacency lists, and inserting each edge in its linked way.
When working with a planar graph, it is sometimes necessary to store an embedding of the graph in the plane. Consider an embedding of a planar graphGin the plane. All information that is necessary to reconstruct the combinatorial structure of the embedding ofG, i. e., to retrieve the information which edges and vertices are on the boundary of which face, is the order in which the edges incident to each vertex need to be drawn. One simple way to store this information is to order the adjacency list of each vertexx∈V(G) accordingly. The circular ordering of a vertexx∈V(G) is the clockwise order of the edges incident toxin the considered embedding ofG. When the adjacency list ofxis ordered according to the circular ordering aroundx, it is called the rotation system ofx, see Chapter 3.2 in [MT01] for details and Figure2.4for an example. Furthermore, when an algorithm receives a plane graph as input, it is assumed that it is represented by its rotation systems. Note that the embedding is not necessarily completely determined by the rotation systems for graphs that are not connected. For example, consider the graph consisting of a 3×3 grid and an isolated vertexx, then the rotation systems do not determine the face of the 3×3 grid in which the vertexxis embedded. When given a connected plane graphG, i. e., each adjacency list ofGis a rotation system, then the combinatorial structure of the faces is uniquely determined and it can be obtained by walking along the boundary of each face. To do so, choose an arbitrary vertexv1 and an arbitrary edge that joinsv1 to one of its neighbors, sayv2. The next vertex in the walk is the entryv3 that followsv1in the rotation system ofv2 as the edge{v2, v3}is embedded after the edge{v2, v1}in the circular ordering of v2. The verticesv4,v5, and so on are determined analogously.
The procedure stops when the edge{v1, v2}is traversed again in the same direction as in the beginning. To
find all faces systematically, the algorithm marks the entries in the rotation systems that have been used already. More precisely, it marks the entryvi+1 in the adjacency list ofvi when using the edge{vi, vi+1}. Once all entries are marked, all faces are discovered. When the rotation systems arelinked, where linked has the same meaning as for adjacency lists, this procedure takesO(kGk) time as each edge is traversed twice and it is not necessary to search for the entry vi+1 in the rotation system of vi. If the rotation systems are not linked, butGis a bounded-degree graph, then the time to search for the entryvi+1 in the rotation system ofvi is constant and, hence, the running time is alsoO(kGk). Due to Corollary2.9, the running timeO(kGk) simplifies toO(n), wherendenotes the number of vertices ofG.
Lemma 2.26.
Given a connected plane graphGonn vertices with bounded degree as input, one can determine a list of the faces ofGas well as, for each face f of G, a list of the vertices on the boundary of f inO(n)time.
Consider a connected plane graphGand fix a vertexv∈V(G). If, for each facef ofG, a list of the vertices on the boundary off is known, then the algorithm can traverse all these lists to create a list of the faces ofGthat containxin their boundary. Since the lists containing the vertices on the boundary of each face can be computed inO(kGk) time, traversing them requiresO(kGk) time. As this procedure can be applied simultaneously for all vertices ofG, the following lemma is obtained.
Lemma 2.27.
Given a connected plane graphG= (V, E)onnvertices with bounded degree as input, one can compute, for each vertex v∈V, a list of the faces ofGthat contain v in their boundary in O(n)time.
There are algorithms that, when given an arbitrary planar graph G, compute a plane embedding of G. The fastest such algorithms run in linear time. The first such algorithm is due to Hopcroft and Tarjan [HT74]. A different method is described by Lempel, Even, and Cederbaum [LEC67]. Both methods heavily depend on the underlying data structure to store the part of the graph that is already examined, see also [CW90] for a comparison.
Theorem 2.28.
There is an algorithm that, when given a graph Gon n vertices, computes a plane embedding ofG or returns thatGis not planar in O(n)time.
2.4.2 Tree Decompositions
In addition to algorithms working with graphs, also algorithms working with tree decompositions are presented here. In general, determining the tree-width of a graph is NP-hard, see Theorem 1 in [Bod98]
and [ACP87]. For fixed t ∈ N, there is an algorithm that, when given a graphG with tw(G) ≤t as input, computes a tree decomposition of G of width at most t in linear time [Bod96]. However, the running time is already too long for practical purposes even if t is very small. Moreover, there is an algorithm that, when given a graphG onn vertices as input, computes a tree decomposition of Gof width O
tw(G)p
log(tw(G))
in time polynomial in n and tw(G), see Theorem 6.4 in [FHL08]. For planar graphsGonnvertices, there is an algorithm that approximates the tree-width ofGwithin a factor of 1.5 inO(n3) time [GT08], and relies on the relationship between branch-width and tree-width. It is open, whether computing a tree decomposition of minimum width of a planar graph is NP-hard.
Therefore, the algorithms presented here, that work with tree-like graphs, receive a tree decomposition of small width as input. The format is as follows. Consider a tree decomposition (T,X) withX = (Xi)i∈V(T)
and denote by nT the number of nodes of T. Similar to graphs, it is assumed that T is given by its
adjacency lists and that the node set ofT is [nT]. Furthermore, it is assumed that each cluster inX is given as an unordered list of (distinct) vertices and each nodei∈V(T) has a pointer pointing toXi. So, to store the tree decomposition (T,X), first, the treeT itself needs to be stored, which takeskTk=O(|V(T)|) space and, second, each non-empty cluster needs to be stored, which takesP
i∈V(T)|Xi| space. Taking into account that many clusters inX could be empty, it becomes clear that in the following definition
i∈V(T)|Xi| space. Taking into account that many clusters inX could be empty, it becomes clear that in the following definition