Chapter 17 Graph Contraction and Connectivity In earlier chapters, we have mostly covered techniques for solving problems on graphs that were developed in the context of sequential algorithms. Some of them are easy to parallelize while others are not. For example, we saw that BFS has some parallelism since each level can be explored in parallel, but there was no parallelism in DFS. There was limited parallelism in Dijkstra’s algorithm, but there was plenty of parallelism in the Bellman-Ford algorithm. In this chapter we cover a technique called “graph contraction” that was specifically designed to be used in parallel algorithms and that allows obtaining poly-logarithmic span for certain graph problems. Let’s start with a definition of graph partition. Recall that a partition of a set A is a set P of non-empty subsets of A such that each element of A is in exactly one subset B ∈ P ; each susbet B ∈ P is called a part or block. Definition 17.1. Given a graph G, a graph partition of G is a collection of graphs H0 = (V0 , E0 ), . . . , Hk−1 = (Vk1 , Ek−1 ) such that {V0 , . . . , Vk−1 } is a set partition of V and H0 , . . . , Hk−1 are vertex-induced subgraphs of G with respect to V0 , . . . , Vk−1 . Each subgraph Hi is called a part of G. In other words, a graph partition is a collection of graphs induced by vertex-induced graphs of a set partition of its vertices. In a graph partition, we can distinguish between two kinds of edges: internal edges and cut edges. We call an edge {v1 , v2 } an internal edge, if v1 Vi and v2 ∈ Vi , and by construction {v1 , v2 } ∈ Ei . We call an edge {v1 , v2 } a cut edge, if v1 Vi and v2 ∈ Vj and i 6= j. One way to partition a graph is to make each connected component a block. In such a partition, there are no cut edges between the partitions. Sometimes it is useful to give a name or a label to each part in a graph partition. A graph partition can then be described as a set of labels for the parts and partition map that maps each vertex to the label of its part. The labels can be chosen arbitrarily but 291

292

CHAPTER 17. GRAPH CONTRACTION AND CONNECTIVITY

sometimes it is conceptually and computationally easier to use a vertex inside a part as a name (representative) for that part.

Example 17.2. The partition {{a, b, c} , {d} , {e, f}} of the {a, b, c, d, e, f}, defines three parts as vertex-induced subgraphs. b

abc

b

e ef

a

d c

vertices

f d

e a c

d

f

The edges {a, b}, {a, c}, and {e, f} are internal edges, and the edges {c, d}, {b, d}, {b, e} and {d, f} are cut edges. By labeling the parts “abc”, “d” and “ef”, we can specify the graph partition with following partition map: ({abc, d, ef} , {a 7→ abc, b 7→ abc, c 7→ abc, d 7→ d, e 7→ ef, f 7→ ef}). Instead of assigning a fresh label to each part, we can choose a representative vertex. For example, by picking a, d, and c as representatives, we can represent the partition above using the following partition map ({a, d, e} , {a 7→ a, b 7→ a, c 7→ a, d 7→ d, e 7→ e, f 7→ e}).

17.1

Graph Contraction

Graph contraction is a technique for computing properties of graphs in parallel. As a contraction technique, it is used to solve a problem instance by reducing it to a smaller instance of the same problem. Graph contraction is important, since divideand-conquer can be difficult to apply in graph problems efficiently. This is because divide and conquer usually requires partitioning graphs into smaller graphs in a balanced fashion such that the number of cut edges is minimized. Since graphs can be highly irregular, however, they can be difficult to partition. In fact, graph partitioning problems are typically NP-hard. The rest of this section describes the graphcontraction design technique and two approaches to graph-contraction: edge contraction and star contraction. The key idea behind graph contraction is to contract the input graph to a smaller quotient graph, solve the problem on the quotient graph, and then use that solution to construct the solution for the input graph. We can specify this technique as an inductive algorithm-design technique (Design Technique 17.3) as follows. February 27, 2017 (DRAFT, PPAP)

17.1. GRAPH CONTRACTION

293

Algorithm-Design Technique 17.3. [Graph Contraction] Base case: If the graph is small (e.g., it has no edges), then compute the desired result. Inductive case: • Contract the graph into a smaller quotient graph. – – – –

Partition the graph into parts. Contract each part to a single super-vertex. Drop internal edges. Reroute cut edges to corresponding super-vertices.

• Recursively solve the problem for the quotient graph. • Using the result for the quotient graph, compute the result for the input graph.

The key step of graph contraction is the construction of the quotient. To this end, we partition the graph and construct a quotient graph, where each part in the partition is represented by a vertex in the quotient graph. We can construct the quotient graph by creating a super-vertex for each partition We then consider each edge (u, v) in the graph. If the edge is an internal edge, then we skip it. Otherwise, we create a new edge between the super-vertices representing the parts containing u and v. Since there can be many cut edges between two parts, we may create multiple edges between two super-vertices. We can remove such edges or leave them in the graph, in which case we would be working with multigraphs. In this chapter, we shall remove duplicate edges, because this is simpler for our purposes. The process of identifying a partition and updating the edges is called a round of graph contraction. In a graph contraction, rounds are repeated until there are no edges left. An important property of graph contraction is that it is guided by a graph partition. Since parts in a graph partition are disjoint, each vertex in the graph is mapped to one unique vertex in the quotient graph. February 27, 2017 (DRAFT, PPAP)

294

CHAPTER 17. GRAPH CONTRACTION AND CONNECTIVITY

Example 17.4. One round of graph contraction: b a

a

e

d c

e a

a

e

f

e

d

d Partition

d Delete duplicate edges

Contract

Contracting a graph down to a single vertex in three rounds: b

a

a

e e

a

d c

f

e e

a d

d Round 0

Round 1 a

a

a

Round 3

e Round 2

As described, the graph-contraction technique is generic in the kind of graph partition used for constructing the quotient graph. In the rest of this chapter, we will consider two techniques, edge partitioning and star partitioning, and the resulting graphcontraction algorithms.

17.1.1

Edge Partition and Edge Contraction

Edge partitioning is a graph-partitioning technique. In an edge partition, each part is either a single vertex or two vertices connected by an edge. We use the term edge contraction to refer to a graph contraction performed by using edge partitions. February 27, 2017 (DRAFT, PPAP)

17.1. GRAPH CONTRACTION

295

Example 17.5. An example edge partition in which every part consists of two vertices and an edge between them. Contracting the graph based on this partition yields a quotient graph with half as many vertices and edges. a

b

f

e e

a c

Contract

a

e

d c

c

Note that in general, parts cannot be just pairs of vertices, because the graph might not have an even number of vertices, but even if it does (no pun intended), it is likely that it cannot be partitioned into a set of pairs joined by edges.

We can construct an edge partition by selecting an independent edge set, or vertex matching, where no two edges share a vertex, and placing all the remaining vertices that are nod incident an a selected edges into singleton sets. The problem of finding a vertex matching is called the vertex-matching problem.

Definition 17.6. A vertex matching for an undirected graph G = (V, E) is a subset of edges M ⊆ E such that no two edges in M share a vertex.

Example 17.7. A vertex matching for our favorite graph (highlighted edges) and the corresponding parts.

b a

e d

c

f

b

e

a d

f

c

The vertex matching defines four parts (circled), two of them defined by the edges in the matching, {a, b} and {d, f}, and two of them are the unmatched vertices c and e. February 27, 2017 (DRAFT, PPAP)

296

CHAPTER 17. GRAPH CONTRACTION AND CONNECTIVITY

The problem of finding the largest vertex matching for a graph is called the maximum vertex matching problem. Many algorithms for this well-studied problem have p been proposed, including one that can solve the problem in O( |V ||E|) work. For graph contraction, we do not need a maximum matching but one that it is sufficiently large. For example, we can use a greedy algorithm to construct a vertex matching by going through the edges one by one maintaining an initially empty set M and for each edge, if no edge in M is already incident on its endpoints then add it to M , otherwise toss it. The problem with this approach is that it is sequential since each decision depends on previous decisions. To find the vertex matching in parallel, we will need to make local decisions at each vertex. One possibility is for each vertex to select one of its neighbors to match with. Such a selection can be done in parallel but there is one problem: multiple vertices might select the same vertex to match with. We therefore need a way to break the symmetry that arises when two vertices try to match with the same vertex. We can use randomization to break the symmetry. For example, we can flip a coin for each edge (u, v) in parallel and select the edge, effectively matching u and v, if the coin for the edge comes up heads and all the edges incident on u and v flip tails. This guarantees that a vertex is matched with at most one other vertex.

Example 17.8. [Edge contraction] An example edge contraction illustrated.

H a

b

T e T

T

d T c

T H

f

a H c

Round 0

e

T

H

d T Round 1

H a Round 3

a

d Round 2

Let us analyze how effective this approach is in selecting a reasonably large matching. We first consider cycle graphs, consisting of a single cycle and no other edges. In such a graph every vertex has exactly two neighbors. February 27, 2017 (DRAFT, PPAP)

17.1. GRAPH CONTRACTION

297

Example 17.9. A graph consisting of a single cycle. b a

f

T H T T c

H

T

e

d

Each edge flips a coin that comes up either heads (H) or tails (T ). We select7 an edge if it turns up heads and all other edges incident on its endpoints are tails. In the example the edges {c, d} and {b, f} are selected. We want to determine the probability that an edge is selected in such a graph. Since the coins are flipped independently at random, and each vertex has degree two, the probability that an edge picks heads and its two adjacent edges pick tails is 21 · 21 · 12 = 18 . To analyze the number of edges selected in expectation, let Re be an indicator random variable denoting whether e is selected or not, that is Re = 1 if e is selected and 0 otherwise. Recall that the expectation of indicator random variables is the same as the probability it has value 1 (true). Therefore we have E[Re ] = 1/8. Thus summing over all edges, we conclude that expected number of edges deleted is m8 (note, m = n in a cycle graph). In the chapter on randomized algorithms Section ?? we argued that if each round of an algorithm reduces the size by a constant fraction in expectation, and if the random choices in the rounds are independent, then the algorithm will finish in O(log n) rounds with high probability. Recall that all we needed to do is multiply the expected fraction that remain across rounds and then use Markov’s inequality to show that after some k log n rounds the probability that the problem size is a least 1 is very small. For a cycle graph, this technique leads to an algorithm for graph contraction with linear work and O(log2 n) span—left as an exercise. There are several ways to improve the number of deleted edges. One way is for each vertex to pick one of its neighbors and to select an edge (u, v) if it was picked by both u and v. In the case of a circle, this increases the expected number of deleted edges to m4 . Another way is let each edge pick a random number in some range and then select and edge if it is the local maximum, i.e., it picked the highest number among all the edges incident on its end points. This increases the expected number of edges contracted in a circle to m3 . Although edge contraction works quite well with cycle graphs, or sequentially with the appropriate data structures, it does not work well for arbitrary graphs. The problem is in edge contraction, only one edge incident on a vertex can be contracted in each February 27, 2017 (DRAFT, PPAP)

298

CHAPTER 17. GRAPH CONTRACTION AND CONNECTIVITY

round. Therefore vertices with high degrees, will have to contract their neighbors one at a time. The example below illustrates a particularly difficult graph, called a star graph, for edge contraction. Example 17.10. A star graph with center v and eight satellites.

v

More precisely, we can define a star graph as follows. Definition 17.11. [Star Graph] A star graph G = (V, E) is an undirected graph with a center vertex v ∈ V , and a set of edges E that attach v directly to the rest of the vertices, called satellites, i.e. E = {{v, u} : u ∈ V \ {v}}. Note that a single vertex and a single edge are both star graphs. It is not difficult to convince ourselves that on a star graph with n vertices—1 center and n − 1 satellites—any edge partitioning algorithm will take Ω(n) rounds. To fix this problem we need to be able to form parts that consist of more than just edges. Remark 17.12. An abstract data type called disjoint sets is often used to contract graphs sequentially. Disjoint sets supply two functions: union, which joins two components, and find, which finds what component a vertex is in. In our framework, the union operation is simply edge contraction across a single edge, and the find is just a lookup in the partition map. Semantically for a partition map P we can define union as: union(P, u, v) = {u0 7→ if (v 0 = u) then v else v 0 : (u0 7→ v 0 ) ∈ P } where here we have made v the new representative of the super-vertex {u, v}, and have updated all vertices that used to point to u to now point to v. Implementing the union this way, however, is inefficient since it can require updating a lot of vertices. It turns out that the operations can be can be implemented much more efficiently. Indeed one can implement a data structure that only requires amortized O(α(n)) work per operation, where α(n) (the inverse Ackermann function) is a function that is very close ot O(1), and n is the number of operations. February 27, 2017 (DRAFT, PPAP)

17.1. GRAPH CONTRACTION

17.1.2

299

Star Partition and Star Contraction

In an edge partition, if there is an edge incident on a vertex v is selected as a part, then none of the other edges incident on v can be their own part. This limits the effectiveness of edge partitioning, because it is unable to contract significantly graphs with highdegree vertices. In this section, we describe an alternative technique: star partition. In star partitioning, we partition a graph G by selecting parts of G to correspond to subgraphs of G that are stars. For example in Example 17.10, the whole graph can be selected as a single partition. We refer to a graph contraction where parts are selected by star partitioning a star contraction.

Example 17.13. In the graph shown below on the left, we first find two disjoint stars. We then partition the graph into two parts, each defined as the vertexinduced subgraphs of the two stars.

A graph

Its two stars. Centers highlighed.

The corresponding star partition. Solid edges are cut edges. Dashed edges are internal edges.

As with edge partitions, it is possible to construct star partitions sequentially. One approach proceeds by adding start incrementally: start with an arbitrary vertex v and make v the center of a star; then, attach as satellites all the unattached neighbors of v; remove now v and its satellites from the graph, and recursively repeat the same process with the remaining graph. Note that a vertex is the simplest form of a star. So if we have isolated vertices remaining, each will form a singleton star consisting of a single vertex. We can also construct star partitions in parallel by making local independent decisions at each vertex. As in edge partitioning, we can use randomization to break symmetry. One approach proceeds as follows. Flip a coin for each vertex. If a vertex flips heads, then it becomes the center of a star. If a vertex flips tails, then it attempts to become a satellite by finding a neighbor that is a center. If no such neighbor exists (all neighbors have flipped tails or the vertex is isolated), then the vertex becomes a center. If a vertex has multiple centers as neighbors, it can pick one arbitrarily. This approach might not be optimal in the sense that it might not create the smallest number of stars February 27, 2017 (DRAFT, PPAP)

300

CHAPTER 17. GRAPH CONTRACTION AND CONNECTIVITY

but, as we shall see, this is acceptable for our purposes, because we only need to reduce the size of the graph by a constant factor.

Example 17.14. An example star partition. Vertices a and b, which flip heads, become centers. Vertices c and e, which flipped tails, attempt to become satellites by finding a center among their neighbors, breaking ties arbitrarily. If a vertex does not have a neighbor that flipped heads, then it becomes a singleton star (e.g., vertex d). We end up with three stars: the star with center a (with no satellites), the star with center b (with two satellites), and the singleton star d. The star partition thus yields three parts, which consists of the subgraphs induced by each star.

Tc

a

dT

H Hb

Tc a

eT

coin flips

dT

H Hb

c

d

b

e

a eT

choose stars

resulting partitions

To specify the star-partition algorithm, we need a source of randomness. For this, we assume that each vertex is given a (potentially infinite) sequence of random and independent coin flips. The ith element of the sequence can be accessed via the function heads(v, i) : V × Z → B, which returns true if the ith flip on vertex v is heads and false otherwise. Since most machines don’t have true sources of randomness, in practice this can be implemented with a pseudorandom number generator or even with a good hash function. Algorithm 17.15 illustrates the code for star partitioning. The function starPartition takes as argument a graph and a round number, and returns graph partition specified by a set of centers and a partition map from all vertices to centers. The algorithm starts by flipping a coin for each vertex and selecting the directed edges that point from tails to heads—this gives the set of edges TH . In this set of edges, there can be multiple edges from the same non-center. Since we want to choose one center for each satellite, we remove duplicates in Line 6, by creating a set of singleton tables and merging them. More specifically, the union is shorthand for the code Set.reduce (Table.union (λ (x,y) => x)) ∅ {{u 7→ v} : (u, v) ∈ TH }.

February 27, 2017 (DRAFT, PPAP)

17.1. GRAPH CONTRACTION

301

Algorithm 17.15. [Star Partition] 1 starPartition (G = (V, E), i) = 2 let 3 (* Find the arcs from satellites to centers *) 4 TH = {(u, v) ∈ E | ¬heads(u, i) ∧ heads(v, i)} 5 6

(* Partition map from satellites to centers *) S P = (u,v)∈TH {u 7→ v}

7 8

(* Super vertices are centers and unmatched ones *) V 0 = V \ domain(P )

9 10

(* Map super-vertices to themselves *) P 0 = {u → 7 u : u ∈ V 0}

11 in (V 0 , P 0 ∪ P ) end

This completes the selection of satellites and their centers. The algorithm next determines the set of super vertices, which can become the vertices of the quotient graph in contraction, as all the vertices minus the satellites. To complete the process, the algorithm determines each super vertex and matches it with itself (Line 10). This effectively promotes unmatched non-centers to centers, forming singleton stars, and matches all centers with themselves. Finally, the algorithm constructs the partition map by uniting the mapping for the satellites and the centers. February 27, 2017 (DRAFT, PPAP)

302

CHAPTER 17. GRAPH CONTRACTION AND CONNECTIVITY Example 17.16. The star-partition algorithm proceeds on the graph in Example 17.14 as follows. First, it computes TH = {(c, a), (c, b), (e, b)} , as the edges from satellites to centers. Now, it converts each edge into a singleton table, and merges all the tables into the table, which is going to become part of the partition map: P = {c 7→ b, e 7→ b} . Note that the edge (c, a) has been removed since when uniting the tables, we selects only one element for each key in the domain. Now for all remaining vertices V 0 = V \ domain(P ) = {a, b, d} we map them to themselves, giving: P 0 = {a 7→ a, b 7→ b, d 7→ d} . The vertices in P 0 are the centers. Finally we merge P and P 0 to give to construct the partition map P 0 ∪ P = {a 7→ a, b 7→ b, c 7→ b, d 7→ d, e 7→ b} .

Analysis of Star Partitioning. By examining the algorithm, we can conclude the following work and span bounds for the star partitioning algorithm. Theorem 17.17 (Star Partitioning). Based on the array-based cost specification for sequences and single-threaded sequences, the cost of starPartition is O(n + m) work and O(log n) span for a graph with n vertices and m edges. Let’s also bound the number of satellites found by starPartition. Note first that there is a one-to-one mapping between the satellites and the set P computed by the algorithm. The following lemma shows that on a graph with n• non-isolated vertices, the size of P and thus the number of satellites is at least n• /4 in expectation.

Lemma 17.18. For a graph G with n• non-isolated vertices, the expected number of satellites in a call to starPartition (G, r) with any r is at least n• /4. Proof. For any vertex v, let Hv be the event that a vertex v comes up heads, Tv that it comes up tails, and Rv that v ∈ domain(P ) (i.e, it is a satellite). Consider any nonisolated vertex v ∈ V (G). By definition, we know that a non-isolated vertex v has at least one neighbor u. So, we know that Tv ∧ Hu implies Rv , since if v is a tail and u is a February 27, 2017 (DRAFT, PPAP)

17.1. GRAPH CONTRACTION

303

head v must either join u’s star or some other star. Therefore, Pr [Rv ] ≥ Pr [Tv ] Pr [Hu ] = 1/4. By the linearity of expectation, the expected number of satellites is " # X X E I {Rv } = E [I {Rv }] v:v non-isolated

v:v non-isolated

≥ n• /4. The final inequality follows because we have n• non-isolated vertices and because the expectation of an indicator random variable is equal to the probability that it takes the value 1. Analysis of Graph Contraction with Star Partitioning. For the analysis of star contraction, i.e., graph contraction with star partitioning, let n• be the number of nonisolated vertices. In star contraction, once a vertex becomes isolated, it remains isolated until the final round, since contraction only removes edges. Let n0• denote the number of non-isolated vertices after one round of star contraction. We can write the following recurrence for the span of star contraction.  n• > 0 S(n0• ) + O(log n) if S(n• ) = 1 otherwise. Observe that n0• = n• − X, where X is the number of satellites (as defined earlier in the lemma about starPartition), which are removed at a step of contraction. Since E [X] = n• /4, E [n0• ] = 3n/4. This is a familiar recurrence, which we know solves to O(log2 n• ), and thus O(log2 n), in expectation. As for work, ideally, we would like to show that the overall work is linear, because we might hope that the graph size is reduced by a constant fraction on each round. Unfortunately, this is not the case. Although we have shown that one can remove a constant fraction of the non-isolated vertices on one round of star contraction, we have not shown anything about how many edges we remove. Since removing a satellite also removes the edge that attaches it to its star’s center, each round removes at least as many edges an vertices. But this does not help us bound the number of edges removed. Consider, for example, following sequence of rounds. round vertices edges 1 2 3 4

n n/2 n/4 n/8

m m − n/2 m − 3n/4 m − 7n/8

In this example, it is clear that the number of edges does not drop below m − n, so if there are m > 2n edges to start with, the overall work will be O(m log n). Indeed, this is the best bound we can show asymptotically. February 27, 2017 (DRAFT, PPAP)

304

CHAPTER 17. GRAPH CONTRACTION AND CONNECTIVITY

To bound the work, we will consider non-isolated and isolated vertices separately. Let n0• denote the number of non-isolated vertices after one round of star contraction. For the non-isolated vertices, we have the following work recurrence:  W (n• , m) ≤

W (n0• , m) + O(n• + m) if n• > 1 1 otherwise.

This recursion solves to E [W (n• , m)] = O(n• + m log n• ) = O(n + m log n). To bound the work on isolated vertices, we note that there at most n of them at each round and thus, the additional work is O(n log n). This analysis gives us the following theorem. Theorem 17.19. For a graph G = (V, E), we can contract the graph into a number of isolated vertices in O(|V | + |E| log |V |) work and O(log2 |V |) span.

17.2

Connectivity via Graph Contraction

The (graph) connectivity problem requires determining the connected components of a graph.

Problem 17.20. [The Graph Connectivity (GC) Problem] Given an undirected graph G = (V, E) return all of its connected components (maximal connected subgraphs). A graph connectivity algorithm could return the connected components of a graph, by, for example, specifying the set of vertices in each component. The graph connectivity problem can be solved by using graph search as follows. Start at any vertex and find, using DFS or BFS, all vertices reachable from that vertex. This creates the first component. Move onto the next vertex, and if it has not already been searched, then search from that vertex to create the second component. Repeat until all the vertices are considered. Using graph search leads to perfectly sensible sequential algorithms for graph connectivity, but they are not good parallel algorithms. When the diameter of a graph is small, we may use BFS to perform each graph search, but we still have to iterate over the components one by one. Thus the span in the worst case can be linear in the number of components, which can be large. We would like to find a parallel algorithm for connectivity that has a small span an all graphs. To this end, we use the graph-contraction technique with star partitioning. To specify the algorithm, we use an edge-set representation for graphs, where every edge is represented as a pair of vertices, in both orders. This is effectively equivalent to a directed graph representation of undirected graphs with two arcs per edge. February 27, 2017 (DRAFT, PPAP)

17.2. CONNECTIVITY VIA GRAPH CONTRACTION

305

Algorithm 17.22. [Counting Components using Graph Contraction] 1 countComponents (G = (V, E)) = 2 if |E| = 0 then |V | 3 else 4 let 5 (V 0 , P ) = starPartition (V, E) 6 E 0 = {(P [u], P [v]) : (u, v) ∈ E | P [u] 6= P [v]} 7 in 8 countComponents (V 0 , E 0 ) 9 end

Example 17.21. The representation of an undirected graph as a set of ordered pairs, with each edge appearing in both directions.

b a

e d

f

c V = {a, b, c, d, e, f} E = {(a, b), (b, a), (b, d), (b, e), (e, b), (d, b), (d, f), (a, c), (c, a), (c, d), (d, c), (d, f), (f, d), (e, f), (f, e)}

Algorithm 17.22 illustrates a graph-contraction algorithm for determining the number of connected components in a graph. Each contraction on Line 5 returns the set of (centers) super-vertices V 0 and a table P mapping every v ∈ V to a v 0 ∈ V 0 . The set V 0 defines the super-vertices of the quotient graph. Line 6 completes the computation of the quotient graph. • it computes the edges of the quotient graph by routing the end points of each edge to the corresponding super-vertices in V 0 , which is specified by the table P ; • it removes all self edges via the filter P [u] 6= P [v]. Having computed the quotient graph, the algorithm recursively solves the problem on it. Recursion bottoms out when the graph contains no edges, in which case, each component has been contracted down to a singleton vertex, and thus the number of February 27, 2017 (DRAFT, PPAP)

306

CHAPTER 17. GRAPH CONTRACTION AND CONNECTIVITY Algorithm 17.24. [Contraction-based graph connectivity] 1 connectedComponents (G = (V, E)) = 2 if |E| = 0 then 3 (V, {v 7→ v : v ∈ V }) 4 else 5 let 6 (V 0 , P ) = starPartition (V, E) 7 E 0 = {(P [u], P [v]) : (u, v) ∈ E | P [u] 6= P [v]} 8 (V 00 , C) = connectedComponents (V 0 , E 0 ) 9 in 10 (V 00 , {v 7→ C[s] : (v → 7 s) ∈ P }) 11 end

vertices in the contracted graph is equal to the number of components in the input graph.

Example 17.23. The values of V 0 , P , and E 0 after each round of the contraction shown in Example 17.4. V 0 = {a, d, ef} round 1 P 0 = {a 7→ a, b 7→ a, c 7→ a, d 7→ d, e 7→ e, f 7→ e} E 0 = {(a, e), (e, a), (a, d), (d, a), (d, e), (e, d)} V 0 = {a, e} round 2 P 0 = {a 7→ a, d 7→ abcd, e 7→ e} E 0 = {(a, e), (e, a)} V 0 = {a} round 3 P 0 = {a 7→ a, e 7→ a} E 0 = {}

Our previous algorithm just counted the number of components. We can modify the algorithm slightly to compute the components themselves instead of returning their count. To this end, we are going to construct the mapping from vertices to their components recursively. This is possible because we can obtain the mapping by composing the mapping from vertices to their super-vertices and the mapping from supervertices to their components, which we obtain recursively. Algorithm 17.24 shows the algorithm. February 27, 2017 (DRAFT, PPAP)

17.2. CONNECTIVITY VIA GRAPH CONTRACTION

307

Example 17.25. 



 b   connectedComponents  a 

e

d

    f

c

might return: ({a} , {a 7→ a, b 7→ a, c 7→ a, d 7→ a, e 7→ a, f 7→ a}) since there is a single component and all vertices will map to that component label. In this case a was picked as the representative, but any of the initial vertices is a valid representative, in which case all vertices would map to it.

The only differences from countComponents are a modification to the base case, and the extra line (Line 10) after the recursive call. In the base case instead of returning the size of V returns all vertices in V along with a mapping from each one to itself. This is a valid answer since if there are no edges each vertex is its own component. In the inductive case, when returning from the recursion, Line 10 updates the mapping P from vertices to super-vertices by looking up the component that the super-vertex belongs to, which is given by C. This simply involves the look up C[s] for every (v 7→ s) ∈ P . Note that if you view a mapping as a function, then this is equivalent to function composition, i.e., C ◦ P . February 27, 2017 (DRAFT, PPAP)

308

CHAPTER 17. GRAPH CONTRACTION AND CONNECTIVITY Example 17.26. Consider our example graph (Example 17.25), and assume that starPartition returns: V 0 = {a, d, e} P = {a 7→ a, b 7→ a, c 7→ a, d 7→ d, e 7→ e, f 7→ e} . This pairing corresponds to the case where a, d and e are chosen an centers. Since the graph is connected, the recursive call to connectedComponents(V 0 , E 0 ) will map all vertices in V 0 to the same vertex. Lets say this vertex is a giving: V 00 = {a} P 0 = {a 7→ a, d 7→ a, e 7→ a} . Now {v 7→ P 0 [s] : (v 7→ s) ∈ P } will for each vertex-super-vertex pair in P , look up what that super-vertex got mapped to in the recursive call. For example, vertex f maps to vertex e in P so we look up e in P 0 , which gives us a so we know that f is in the component a. Overall the result is: {a 7→ a, b 7→ a, c 7→ a, d 7→ a, e 7→ a, f 7→ a} .

Cost of connected-components algorithms. February 27, 2017 (DRAFT, PPAP)

17.3. FOREST CONTRACTION AND TREE CONTRACTION

309

Remark 17.27. In general the graph contraction techniques does not specify how to partition the graph. In this chapter, we covered two techniques for graph partitioning. Depending on the problem, other techniques can be used. For graph contraction to be applicable to a problem, however, it is important that the quotient graph satisfy certain properties. For example, when solving graph connectivity with the algorithms described here, we have to be careful that the graph partition maintains connectivity: a subgraph should be connected in the quotient graph, if and only if it was connected in the input graph. To ensure this, we will need to use a graph-partition algorithm that ensures that each part is connected in the input graph. For example, the pictures below illustrate two graph partitions. The first graph partition maintains connectivity, the second one does not.

b a

a

e

d c

b

e

f d

a

a

e

d c

f d

The partitioning on the left is appropriate for graph contraction since each partition is connected. The partition on the right is not since d is not connected to e and f.

17.3

Forest Contraction and Tree Contraction

Suppose that we want to contract a forest of trees instead of a general graph as we considered thus far. Since forests are graphs, we can use the same starPartition algorithm to contract the forest. Since a forest of n vertices has at most n − 1 edges, we obtain a better work bound, because the number of edges decrease geometrically (in expectation) in each round, as do the number of vertices. The overall expected work is therefore a geometric sum of the form: E [W (n, m)] =

∞  i X 3 i=0

4

kn = O(n),

instead of O(m log n) for general graphs. The span is not affected. The same bound applies if the forest is connected, and thus is a tree. For a graph G = (V, E) consider a subset of edges F ⊂ E that forms a forest (i.e., has no cycles). Such a set of edges partitions the graph G, where parts are defined as the subgraphs induced by the trees in F . We can thus contract a graph by identifying February 27, 2017 (DRAFT, PPAP)

310

CHAPTER 17. GRAPH CONTRACTION AND CONNECTIVITY

a forest F , and then use connectedComponents (V, T ), which does linear work as explained above, instead of our starPartition routine. This corresponds to tree partitioning instead of star or edge partitioning, which are special kinds of trees. We will use this idea in an algorithm for Minimum Spanning Trees described in Chapter 18. Example 17.28. A graph and a subset of the edges F (highligted) consisting of three disjoint trees illustrated in the middle diagram. Each tree induces a part in the original graph (red blobs).

b d

a

b

e f g

c h

d

a i j

e g

a

f i

c h

j

g i

If we run connectedComponents on F , then are left with the desired partitioning with super-vertices {a, g, i} and the mapping: {a 7→ a, b 7→ a, c 7→ a, d 7→ a, e 7→ a, f 7→ a, g 7→ g, h 7→ i, i 7→ u, j 7→ i} . Using this partition, we can compute a quotient graph in the usual way by re-routing edges to the super-vertices. The resulting quotient graph is illustrated on the right.

17.4

Problems

17-1 There are 18 subgraphs for a triangle consisting of three vertices and three edges connecting them, including the empty graph and the graph itself. List them all. 17-2 In star contraction, what is the probability that a vertex with degree d is removed. 17-3 Find an example graph, where star-based graph contraction removes a small number of edges on each round. February 27, 2017 (DRAFT, PPAP)

17.4. PROBLEMS

311

17-4 Describe how to construct a graph that exhibits the worst-case behavior for Theorem 17.19. 17-5 Is the star contraction algorithm work-optimal for a dense graph with Ω(n2 ) edges? Prove or disprove.

February 27, 2017 (DRAFT, PPAP)

312

CHAPTER 17. GRAPH CONTRACTION AND CONNECTIVITY

.

February 27, 2017 (DRAFT, PPAP)

graph-contraction.pdf

... loading more pages. Retrying... graph-contraction.pdf. graph-contraction.pdf. Open. Extract. Open with. Sign In. Main menu. Displaying graph-contraction.pdf.

385KB Sizes 0 Downloads 92 Views

Recommend Documents

No documents