Solution for Homework set 3

Transcription

1 TTIC 300 and CMSC Algorithms Winter 07 Solution for Homework set 3 Question (0 points) We are given a directed graph G = (V, E), with two special vertices s and t, and non-negative integral capacities c(e) on edges e E. Assume that s has no incoming edges and t has no outgoing edges. a. Show an efficient algorithm that finds a maximum s-t flow f in G, such that f is integral and acyclic (a flow f is acyclic, if G contains no cycles, where every edge carries positive flow; it is integral iff f(e) is an integer for all e E). Analyze the algorithm s running time; there is no need to prove its correctness. solution: We start with an initial integral maximum flow f which can be computed efficiently, e.g via the Edmonds-Karp algorithm. Then it is sufficient to show an efficient algorithm that given any feasible integral flow f, returns a feasible flow f of the same value that is integral and acyclic. The algorithm iterates through each vertex v V and uses depth-first search starting from v, where it traverses an edge e = (x, y) E from the current vertex x to y iff f(e) > 0. If v is encountered again while traversing an edge in the forward direction, then the current path in the depth-first search is a cycle C containing v. Let e = arg min {f(e ) e C} be an edge carrying minimum amount of flow in C. We modify f such that f(e) is set to f(e) f(e ) for every e C, and restart the depth-first search from v with the updated f. If no cycle is found, we move to the next vertex. The algorithm terminates when it has iterated through every vertex in V and returns the current flow f as f. running time. Each iteration of the depth-first search can be implemented in O(n + m) time. There are n starting vertices from which we run a depth-first search. Note that whenever the flow value is updated along a cycle C, at least one of the edges in the cycle gets assigned a flow value of 0. Since a flow value on any edge never increases, at most m updates of the flow, and hence m additional runs of the depth-first search, happen throughout the algorithm. Therefore, the depth-first search is run at most n + m times, for a total of O((n + m) ) running time. The update of f along a cycle C can be done in O(m) time, and thus a total of O(m ) time is spent updating the flow paths throughout the algorithm. The Edmonds-Karp algorithm can be implemented in O(m n) time, which dominates the runtime of the algorithm. b. A collection P of paths connecting s to t, together with values f (P ) 0 for each P P is called a valid flow-paths solution, iff for every edge e E, P :P:e P f (P ) c(e). The value of the flow-paths solution is v(p, f ) = P P f (P ). Assume that we are given a valid acyclic s-t flow f : E Z 0 in G, such that f is integral. Show an efficient algorithm that finds a valid flow-paths solution (P, f ), with P E, such that for each edge e E, f (P ) = f(e), P P:e P all values f (P ) are integral, and v(p, f ) = v(f), where v(f) is the value of the flow f. Prove the algorithm s correctness and analyze its running time.

2 solution: The algorithm is iterative and uses depth-first search starting at s in each iteration, where it traverses an edge e = (x, y) E from the current vertex x to y iff f(e) > 0. Whenever t is reached, the current path in the depth-first search is an s-t path P. Let e = arg min {f(e ) e P } be an edge carrying minimum amount of flow in P. We add P to P with f (P ) = f(e ), and update f(e) to be f(e) f(e ) for every e P. The algorithm terminates when no positive s-t flow path exists. correctness. We first show that if f is acyclic, f(e) = 0 must hold for all e E at termination. Assume for contradiction that some e E has f(e) > 0. If e out(s), then by flow conservation, we can traverse edges carrying positive flow starting from e in a depth-first search manner and eventually reach t, a contradiction to the termination condition that no positive s-t flow path exists. So assume all edges in out(s) carry 0 flow. If e / out(s) has f(e) > 0, we can traverse edges carrying positive flow in the reverse direction in a depth-first search manner, and by flow conservation it must eventually create a cycle, as out(s) carries no flow and t has no outgoing edges. Since f is modified such that the flow values on the edges do not increase, a flow cycle at termination would imply a flow cycle for the original flow f, a contradiction. We now verify that (P, f ) is a valid flow-paths solution satisfying the properties of the problem. The algorithm terminates in m iterations, since at each iteration at least one edge in P is updated to have flow value 0, and the flow value on an edge never increases throughout the algorithm. Thus, P E holds, as one path is added per iteration. Since f is initially integral, and f (P ) = f(e ) is integral at each iteration, the updated flow where f(e) is set to f(e) f (e ) for each e P is also integral. Therefore, {f (P )} P P are all integral. At each iteration of the algorithm, the flow value on each edge e P is decreased by exactly the amount f (P ) for P that is added to P. Therefore, P P:e P f (P ) = f(e) must hold, since f(e) = 0 for all e E at termination. Since f was a feasible flow solution originally, note that P P:e P f (P ) = f(e) c(e) holds for all e E and (P, f ) is a valid flow-paths solution. {P P:e P } f (P ) holds since every path P P is Lastly, v(p, f ) = P P f (P ) = e out(s) an s-t path that contains an edge in out(s). Since {P P:e P } f (P ) = f(e) for every edge, we have v(p, f ) = e out(s) f(e) = v(f). running time. Each iteration of depth-first search can be done in O(n + m) time. Since we have at most m iterations, the total time spent on finding positive s-t flow paths is O(m(n + m)). We update the flow and add paths to P at most m times, and the flow on the path can be updated in O(m) time. Thus, the total time spent updating f and building (P, f ) is O(m ). Thus, the algorithm runs in O(m ) time. Question (5 points) In this question we prove the observation that was omitted in class from the analysis of the Edmonds-Karp algorithm for Maximum Flow. Suppose we are given a flow network G, and a valid flow f in that network. Let G f be the corresponding residual graph, P a shortest s-t path in G f, and f a new flow obtained from f after performing a single iteration of the algorithm, with P as the augmenting path. Prove each one of the statements below. a. If e G f but e / G f, then e P. solution. Assume e = (u, v) is a forward edge in G f so c(e) f(e) > 0 must hold. If e / G f, then c(e) = f (e), and hence f (e) > f(e). Clearly, this can happen iff the flow on e increases via the augmenting path P, which implies e P. Now assume e = (u, v) is a backward edge in G f so that if e = (v, u), then f(e ) > 0 must hold. If e / G f, this means that f (e ) = 0, which can

3 only happen if the flow on e = (v, u) was decreased via the augmenting path P. This implies that e = (u, v) P. b. At least one edge of P does not belong to G f. solution. Let e G f be an edge in P with minimum residual capacity c f (e) in G f. If e is a forward edge, then f (e) = c(e) after the iteration, since c f (e) = c(e) f(e) amount of flow is increased on e. This implies that e / G f. If e is a backward edge, then f (e) = 0 after the iteration, since c f (e) = f(e) amount of flow is decreased on e. This implies that e / G f. c. If e = (u, v) G f but e / G f, then edge (v, u) belongs to path P. solution. Assume e = (u, v) is a forward edge in G f so c(e) f (e) > 0 must hold. If e / G f, then c(e) = f(e), meaning that flow value was decreased via the augmenting path P. This can happen only if (v, u) P. Assume e is a backward edge in G f so f (e) > 0 must hold. If e / G f, then f(e) = 0, meaning that flow value was increased via the augmenting path P on e. This can happen only if (v, u) P. Question 3 (5 points) We are given a flow network G = (V, E), with positive integral capacities c(e) on edges e E, a source s and a sink t. Recall that an s-t cut in G is a partition (A, B) of the vertices of V, such that s A and t B. An s-t cut (A, B) is a minimum cut iff the value C(A, B) = e E(A,B) c(e) is minimal among all s-t cuts. Notice that it is possible for a graph to contain several minimum s-t cuts. a. Show an example of a flow network that contains Ω(n) minimum s-t cuts, where n = V. solution. Consider a graph G on n 3 vertices. We fix a pair s, t of vertices, and we connect both of them to all the remaining vertices V (G)\ {s, t} via bi-directional edges of unit capacity. The capacity of any cut (S, T ) such that s S, t T, is ( T + S ) = n, and hence each such cut is a minimum cut. Since there are an exponential number of ways to divide n vertices into two groups S and T, the number of minimum s-t cuts is also exponential. b. Show an example of a flow network that contains a unique minimum s-t cut (that is, the number of minimum s-t cuts in the flow network is ). solution. Consider the following graph G on n vertices. We fix a pair s, t of vertices, and we connect s to all other vertices V (G)\ {s} via bi-directional edges of unit capacity. The capacity of any s-t cut (S, T ) is exactly T. Thus, the unique minimum s-t cut is (V (G)\{t}, {t}) of capacity. c. Show an efficient algorithm to determine whether G contains a unique minimum s-t cut, or the number of such cuts is greater than. Prove the algorithm s correctness. solution. For any graph H, let ϕ(h) denote the value of minimum-cut in the graph H. For each vertex v V \ {s, t}, let G s v be the graph obtained by adding an edge (s, v) of infinite capacity in G. Similarly, let G t v be the graph obtained by adding an edge (v, t) of infinite capacity in G. The algorithm reports multiple minimum cuts iff v V such that ϕ(g s v) = ϕ(g t v) = ϕ(g). 3

4 correctness. Note that in any minimum cut (S s v, T s v ) of G s v, v S s v and similarly, v T t v in any minimum cut (S t v, T t v) of G t v. Since we are modifying G by adding an edge, any cut (S, T ) in the modified graph also induces the same cut (S, T ) of no larger capacity. Thus, if for a vertex v V \ {s, t}, ϕ(g s v) = ϕ(g t v) = ϕ(g) holds, we have found a pair of cuts in the original graph G with the same capacity. Now, assume that there are two minimum s-t cuts: (S, T ) and (S, T ). Since both of them are bi-partition of the vertices, there exists a vertex v S T. Thus, there exists a cut induced by (S, T ) in G s v of the capacity same as ϕ(g). Or in other words, ϕ(g s v) = ϕ(g). Similarly, we can show that ϕ(g t v) = ϕ(g). Since we are computing minimum cuts for only O(n) number of graphs, our algorithm runs in polynomial time. d. An s-t cut (A, B) in G is called the best minimum s-t cut iff it minimizes E(A, B) among all minimum s-t cuts. Show an efficient algorithm to compute the best minimum s-t cut in G. There is no need to analyze the algorithm. solution. Let m be the number of edges in the graph G. We multiplicity the capacities of the edges in G by m and then add an extra unit capacity. The algorithm simply reports the minimum cut in the modified graph. Question 4 (0 points) Recall that, given a graph G, a matching is a subset E of the edges of G, such that no pair of edges in E shares an endpoint. The matching is called perfect iff every vertex of G serves as an endpoint of an edge in E. In this question we assume that we are given a randomized algorithm to test whether there is a perfect matching in a given graph. Given as input an n-vertex graph G, the algorithm runs in time O(n c ) for some constant c ; if G contains a perfect matching, it always returns the answer YES, and otherwise, it returns the answer NO with probability at least /. a. Design a randomized algorithm, that finds a perfect matching in the input graph G, if it exists. The running time of the algorithm should be polynomial in n, and it should compute the perfect matching (if it exists) with probability at least ( /n 4 ). Analyze the algorithm s correctness and running time. solution. Let A be the randomized algorithm given in the problem definition. Consider a randomized algorithm A which runs A for 7 log n times, and returns NO if at least one trial resulted in NO, and YES otherwise. Then A outputs the wrong answer with probability at most /n 7. Indeed, A outputs wrong answer iff A reported YES for 7 log n times, even though the correct answer was NO, which happens with probability at most (/) 7 log n = /n 7. Using A as a black-box, we construct a randomized algorithm B to compute perfect matching. The algorithm B reports no perfect matching if A determines there is no perfect matching. It reports trivial perfect matching if the input graph is empty. In all other cases, for the input graph G, it finds an edge e = (u, v) such that the algorithm A returns YES for G[V \ {u, v}] as input. It then outputs the edge e along with recursively computed matching for G[V \ {u, v}]. If no such edge is found, the algorithm fails. correctness. Assume for now that the algorithm A correctly outputs the correct answer every time. We prove that under this assumption, B correctly outputs a perfect matching if it exists. The proof is by induction on n. 4

5 The base case is when n = 0, where the output is trivially correct. Assume now that the algorithm B reports correct answer for all n < n, and consider the case in which input graph has n vertices. Suppose there is no perfect matching, then A reports so, and the output is again trivially correct. If is there perfect matching, let e = (u, v) be any of its edges. Thus, G[V \ {u, v}] will contain perfect matching, and by our induction hypothesis, B will return the correct answer. It remains to show that with probability at least ( /4), A returns correct answer throughout the algorithm. Note that A is queried at most mn n 3 times. In any one of such queries, the probability that A fails is at most /n 7. Thus, by union bound, the probability that A fails on at least one query out of n 3 potential queries, is bounded by /n 4. Thus, our algorithm B reports correct answer with probability at least /n 4. b. Assume now that our input is some n-vertex graph G, and we would like to find the largest cardinality matching in G. Design a randomized algorithm for doing so. The algorithm should run in time poly(n), and return the largest matching with probability at least ( /n). Analyze the algorithm s correctness and running time. solution. We define the cardinality of matching as the number of vertices participating in it. For each i = 0,..., n, let G i be the graph obtained by adding i extra vertices to G, then connecting each of the extra vertices to all of the vertices of the original graph. Let M i be the perfect matching (if exists) computed by the algorithm B in the graph G i. We return the matching M i E with minimum index i. correctness. Assume for now that the algorithm B correctly outputs answer every time. We prove that under this assumption, our algorithm correctly outputs largest cardinality matching. We prove so by showing that there is a matching of cardinality n i in G iff there is a perfect matching in G i. Suppose, G has a matching M of cardinality n i. Since i extra vertices are connected to all vertices of G, we can append to M a matching between the extra vertices and the unmatched vertices: V \V (M), to get a perfect matching in G i. On the other hand, suppose that G i has perfect matching M i. Then M i E induces a matching of cardinality n i by removing the vertices of G connected to the extra vertices. It remains to show that with probability at least ( /n), B returns correct answer throughout the algorithm. Note that B is queried at most n times. In any one of such queries, the probability that B fails is at most /n 4. Thus, by union bound, the probability that B fails on at least one query out of n potential queries, is bounded by /n 3. Thus, our algorithm reports correct answer with probability at least /n 3 /n. Question 5 (0 points) In this question, we study variations of Karger s algorithm for global minimum cut. We assume that we are given an undirected connected graph G = (V, E). The graph is simple, so there are no parallel edges. Let C denote the value of the global minimum cut in G. a. Let (X, Y ) be the second-smallest minimum cut: that is, if (A, B) is a minimum cut in G, then (X, Y ) is a cut in G of minimum value, such that (X, Y ) (A, B) and (X, Y ) (B, A). Note that E(X, Y ) may be equal to C, but it may also be much larger than C. Prove that the probability that Karger s algorithm returns the cut (X, Y ) is at least Ω(/n 3 ). Can you modify the algorithm to improve the probability to Ω(/n ), without increasing its asymptotic running time? 5

6 solution. Let k be the size of the second-smallest minimum cut. Fix a second-smallest cut, and denote the edges by K. Note that there is at most one vertex with degree less than k, which implies the total number of edges k(n ) E. For the first step, let p n denote the probability that no edge in K is chosen, and we have p n = k E n. Similarly, define p i to be the minimum probability, ranging over all possible contractions such that no edges in K had been contracted before, that no edge in K is chosen at this iteration, when there are i vertices remaining. Note that after any sequence of contractions, there is at most one vertex with degree less than k. For p i, where i = n, n,..., 4, we have p i = k k(i ) i. Let E i denote the event that no edges in K are contracted when there are i vertices remaining, where i = n, n,..., 4. We have Pr[no edges in K are contracted] = Pr[E n ] Pr[E n E n ] Pr[E n E n E n ] Pr[E 4 E n E n E 5 ] p n p n p 4 n 3 n n 4 n n 5 n 3 ( ) 3 Ω n. For the last step, when 3 vertices are remaining, the number of edges is at least k +, assuming C 0. Therefore, the probability that no edges in K are chosen is bounded by k = Ω ( n). Putting them together, we conclude the probability that Karger s algorithm returns the cut is Ω ( ) n. 3 In order to improve the algorithm, for the last step, when 3 vertices are remaining, we choose two vertices uniformly at random to contract. We claim this modified algorithm will find the second-smallest minimum cut K with probability Ω ( ) n. Before the last step, no edges in K will be contracted with probability p n p n p 4 = Ω ( ) n, and in the last step, we will contract an edge in K with probability /3. Putting them together, we have probability Ω ( ) n. b. For a parameter α, we say that a cut (X, Y ) is an α-approximate minimum cut, iff E(X, Y ) α C. In this question, our goal is to modify Karger s algorithm, so it returns an α-approximate cut with a reasonably large probability. Suppose we are given an integer α. We run Karger s algorithm until α vertices remain in the graph. As a last step, we compute a random partition of the remaining graph vertices into two subsets, and use this partition to define a cut in the original graph. Prove that if (X, Y ) is an α-approximate cut, then the algorithm returns this cut with probability at least. Give an upper bound on the number of α-approximate minimum cuts in any ( α) n α graph. Explain your bound. 6

7 solution. The proof is similar to part a), and we adopt the same notation. First, observe that E nc/, because every vertex has degree at least C. Then p n αc E α n. For i = n, n,..., α +, when there are i vertices remaining, every vertex has degree at least C, after any contractions. Thus, Therefore, p i αc Ci = α i. Pr[no edges in E(X, Y ) are contracted] p n p n p α+ n ( α ) i i=α+ n α n ). ( n α n α n α + Conditioning on the event that no edges in E(X, Y ) are contracted at the point where there are α vertices remaining, the probability that (X, Y ) being chosen is α, because there are α cuts in total. Therefore, the algorithm returns the cut (X, Y ) with probability at least ( n α ) α. For each cut C, let p(c) denote the probability that it is being returned by the (randomized) algorithm. We have p(c) =, C where C ranges over all cuts C. If C is an α-approximate cut, then p(c), which implies α that the total number of α-approximate cut is bounded by ( n α) α. ( α) n c. (0 points extra credit) Consider the following analogue of Karger s algorithm for solving the minimum s-t cut problem. In each iteration, let s and t denote the possibly contracted nodes that contain the original vertices s and t, respectively. To make sure that s and t do not get contracted, in each iteration we select an edge to contract uniformly at random from among all edges of the current graph, excluding the edges connecting s to t. Give an example to show that the probability that this method finds a minimum s-t cut can be as small as Ω(n). You can use parallel edges in your example. solution. Let G = (V, E), where V = {s, t, v, v,..., v n } and E = {(s, v i ), (v i, t) : i =,,..., n }, where (v i, t) denotes a pair of parallel edges. It is clear that ({s}, {v, v,..., v n, t}) is the unique minimum s-t cut. The algorithm will return this cut if and only if no edges of the form (s, v i ) are contracted. However, the probability that such an edge not being chosen is 3 at each step, and therefore it will return this cut with probability ( 3) n = Ω(n). 7