Algorithm Design and Analysis (ADA)

1. Algorithm Design and Analysis (ADA) 242-535, Semester 1 2013-2014 • Objective • describe the maxflow problem, explain and analyse the Ford-Fulkerson, Edmonds-Karp, and capacity scaling algorithms, and look at two application areas (bipartite matching and edge disjoint paths) 12. Max Flow Networks

2. Overview A Flow Network The Maxflow Problem The Mincut Problem Ford-Fulkerson (FF) Algorithm Residual Network Ford-Fulkerson (FF) Again Edmonds-Karp Algorithm Capacity Scaling Two Flow Problems Again Bipartite Matching Edge Disjoint Paths Making Maxflow Faster

3. 1. A Flow Network postive flow capacities source sink

4. A flow network is a directed graph G = (V, E) with two special vertices: a source s and a sink t • Each edge (u, v) ∈ E has a non-negative capacity c(u, v) • If(u, v) ∉ E, then c(u, v) = 0

5. Two Flow Problems • The maxflowproblem • find a flow of maximum value • The mincutproblem • find a cut of minimum capacity • Two problems that appear very different but are actually two versions of the same question. • Most of this part is about the theory and implementation of maxflow.

6. 2. The Maxflow Problem • A flow is an assignment of values to edges such that: • capacity constraint: 0 ≤ edge's flow ≤ edge's capacity • flow conservation: inflow = outflow at every vertex (except s and t). inflow at v = 5 + 5 + 0 = 10 outflow at v = 10 + 0 = 10 flow: f(u,v) capacity: c(u,v) [ / is not division]

7. The flowvaluef is the inflow at the sink t • or the outflow at the source s • Maxflow problem: find a flow of maximum value flow = 8 + 10 + 10 = 28

8. Another Example A flow f in G with value 19. A flow network G labelled with its edge capacities c(u,v)

9. Flow Notation • A flow on G is a function f(u,v) satisfying the following conditions: • capacity constraint:u, v ∈ V, f(u, v) ≤ c(u, v) • flow conservation: u ∈ V - {s, t}, • skew symmetry:u, v ∈ V, f(u, v) = -f(v, u) • The flow value f = f(V, t) ( or f(s, V) )

10. Many Applications of Max Flow • Bipartite matching • Data mining • Network reliability • Image processing • Network connectivity • Distributed computing • many more ... blood flow analysis

11. 3. The Mincut Problem • A cutis a partition of a flow network's vertices into two disjoint sets, with the source (s) in one set A and the sink (t) in the other set B. • A cut's capacity is the sum of the capacities of the edges from A to B. • The minimum cut (mincut) problem: find a cut of minimum capacity.

12. Examples don't count edges from B to A capacity = 10 + 5 + 15 = 30 capacity = 10 + 8 + 16 = 34 The minimum cut (mincut) problem: find a cut of minimum capacity.

13. 4. Ford-Fulkerson (FF) Algorithm • Initialization. Start with a 0 flowon every edge. • Find an augmenting pathfrom s to t such that: • we can increase flow on forward edges (while they are not full) • we can decrease flow on backward edge (while they are not empty) initially flow value =0

14. First Augmenting Path

15. Second Augmenting Path

16. Third Augmenting Path

17. Fourth Augmenting Path

18. Termination • No more augmenting paths • All paths from s to t are blocked by either: • a full forward edge, or • a empty backward edge maxflow = 28 mincut = 28

19. 5. Residual Network • Let f be a flow on G = (V, E). The residual network Gf(V, Ef) is a graph showing residual capacities • cf(u, v) = c(u, v) - f(u, v) > 0 • The idea is to draw the flow network G as graph Gf to make it easier to find augmented paths, and to determine the flow increase (anddecrease) the chosen path causes. for increasing flow in (u,v) two residual capacities cf() flow f() capacity c() Graph G Graph Gf 11 6 / 17 u v u v 6 for decreasing flow in (u,v)

20. Gf Edges for Reducing • Residual networks also show how flow along an edge can be reduced • this is shown by having extra edges in Gf which are not in G • To represent a possible decrease of a flow f(u,v) on an edge in G, the edge (v,u) is added to Gf. Its residual capacity is: cf(v, u) = f(u,v)

21. Residual Capacity cf() for increasing flow in (u,v) • The complete definition of cf() is: for decreasing flow in (u,v) two residual capacities cf() flow f() capacity c() Graph G Graph Gf 11 6 / 17 u v u v 6

22. Augmenting Paths • A path from s to t in Gf is an aug­menting path in G which carries flow f. • The flow amount can be increased along an augmenting path by the minimum amountcf( p) = min {cf(u,v)} • cf(p) is the residualor bottleneckcapacity – it is the most that the flow can be increased due to one or more of p's edges being used at full capacity. (u,v) ∈ p

23. Example The flow network G from an earlier example. The residual network Gf with a possible augmenting path p shaded; its bottleneck capacity is cf(p) = cf(v2, v3) = 4. Edges with residual capacity equal to 0, such as (v1,v3) are not shown.

24. The new flow in G that results from augmenting along path p by its bottleneck capacity 4. Edges carrying no flow, such as (v3, v2), are labeled only by their capacity. The residual network Gfversion of this G graph. No more augmented paths can be added, so f is the maxflow (f = 23).

25. 6. Ford-Fulkerson (FF) Again • Start with 0 flow. • While there exists an augmenting path: • find an augmenting path • compute bottleneck capacity • increase flow on that path by bottleneck capacity

26. FF in More Detail ford-Fulkerson(G) { foreach e ∈E in G f(e) = 0 Gf = residual graph of G while (there exists augmenting path P) { cf(p) = min{ cf(u,v) : (u,v) ∈ P } // bottleneck capacity foreach e ∈P { // augment the flows with cf(p) if (e ∈ E in G) f(e) = f(e) + cf(p)// forward edge: e = (u,v) else f(e') = f(e') - cf(p) // reverse edge: e' = (v,u) } update Gf } }

27. Executing of FF with a Residual Network • The figures on the next 2 slides show successive iterations of the FF while-loop. • The left side shows the residual network Gf with the chosen augmenting path p drawn as a shaded thick line. • The right side shows the new flow f in G that results from adding the bottleneck capacity of p (cf(p)).

28. Gf G

29. The last residual network has no augmenting paths, and so the flow f shown in (e) above is a maximum flow (f = 23).

30. FF Running Time • In the worst case, the running time of FF is O(E · |f|), where f is the maxflow • in the worst case, the FF while loop will iterate f times since it's possible for the flow to increase by only I flow unit at a time (see example on the next slides) • finding a path can have varying execution times, but if DFS or BFS is used to find a path, the running time is O(V + E), or O(E) is a dense graph

31. Worst Running Time • The following example is designed so that each augmented path only increases the flow by 1 unit (i.e. the cf(p) is always 1).

32. The Augmenting Paths First Second

33. many, many more Third Fourth

34. 199th 200th (= maxflow)

35. Choosing Paths is Important • This case is easily avoided by a choosing a better series of augmenting paths. Only two iterations are needed.

36. Choosing Good Augmenting Paths • Use care when selecting augmenting paths • Some choices lead to exponential algorithms • Clever choices lead to polynomial algorithms • If capacities are not integers, some algorithm are not guaranteed to terminate • Goal: choose augmenting paths so that: • Can find augmenting paths efficiently • Few iterations • Choose augmenting paths with: • Max bottleneck capacity • Sufficiently large bottleneck capacity • Fewest number of edges

37. 7. Edmonds-Karp Algorithm • Edmonds and Karp's implementation of Ford-Fulkerson finds an augmenting path by using a breadth-first search. • the algorithm is slightly changed:a weight of 1 is assigned to every edge, not the edge's capacity • It runs in O(V· E2) time • this can be proved by counting the number of augmenting paths needed to find the maxflow (which is O(V· E) ) • the proof requires the monotonicity lemma

38. Monotonicity Lemma • Let d(v) = df(s, v) be the breadth-first distance from s (the source) to a vertex v in Gf • each edge has a weight of 1 • Lemma. During the execution of Edmonds-Karp, d(v) increases monotonically(only gets bigger).

39. Proof • Suppose that augmenting a flow f on G produces a new flow f'. Let d′(v) = df'(s, v). • We’ll show d′(v) ≥ d(v) by induction on d′(v) • we are proving that increased flow makes the shortest path distance bigger for every vertex v • For the base case, d′(v) = 0 implies v = s (the source), and since d(s) = 0, we have d′(v) ≥ d(v). • So the base case is true.

40. For the inductive case, consider a breadth-first path s → …→ u → v in Gf' • We must have d′(v) = d′(u) + 1, since subpaths of shortest paths are shortest paths (optimality). • So, we have d′(u) ≥ d(u) by induction, because d′(v) > d′(u). • (u, v) ∈ Ef' (because we assumed it; see above). • But we have to consider two cases depending on whether (u, v) ∈ Ef or not.

41. Case 1: (u, v) ∈ Ef • We have d(v) ≤ d(u) + 1 (triangle inequality) ≤ d′(u) + 1 (induction) = d′(v) (breadth-first path) and thus monotonicity of d(v) is established.

42. Case 2: (u, v) ∉ Ef • Since (u, v) ∈ Ef' , the augmenting path p that produced f' from f must have included (v, u). • Moreover, p is a breadth-first path in Gf : • p = s → … → v → u → … → t • Thus, we have d(v) = d(u) - 1 (breadth-first path) ≤ d′(u) - 1 (induction) = d′(v) - 2 (breadth-first path) < d′(v) thereby establishing monotonicity for this case, too.

43. Counting Flow Augmentations • Theorem. The number of flow augmentations in the Edmonds-Karp algorithm (Ford-Fulkerson with breadth-first augmenting paths) is O(V· E). • Proof. Let p be an augmenting path, and suppose that we have cf(u, v) = cf(p) for edge (u, v) ∈ p • i.e. the bottleneck edge is (u, v) • We say that (u, v) is critical, and it disappears from the residual graph after flow augmentation.

44. The first time an edge (u, v) is critical, we have d(v) = d(u) + 1, since p is a breadth-first path. • We must wait until (v, u) is on an augmenting path before (u, v) can be critical again. • Let d′ be the distance function when (v, u) is on an augmenting path. Then, we have d′(u) = d′(v) + 1 (breadth-first path) ≥ d(v) + 1 (monotonicity) = d(u) + 2 (breadth-first path)

45. Why "+2"? • Example assume (u,v) is critical

46. assume (v,u) is critical was 5, now is 7 was 6, now is 8

47. Running time of Edmonds-Karp • Path distances start out non-negative, never decrease, and are at most |V| - 1 long until the vertex becomes unreachable. • Thus, (u, v) occurs as a critical edge at most O(V/2) times, because d(v) increases by at least 2 between occurrences • simplify O(V/2) to be O(V) • Since the residual graph contains O(E) edges, the number of flow augmentations is O(V· E).

48. Corollary. The Edmonds-Karp maximum-flow algorithm runs in O(V· E2) time. • Proof. Breadth-first search runs in O(E)time(actually O(V + E) but ignore the V), so the total running time is: • O(V· E · E) = O(V· E2)

49. Edmonds-KarpCode boolean[] marked; // true if s->v path is in residual network FlowEdge[] edgeTo; // last edge on s->v path Queue<Integer> q = new Queue<Integer>(); // use when finding an augmenting path

50. double edmondsKarp(FlowNetwork graph, int s, int t) { double value = 0; // flow value while (hasAugmentingPath(graph, s, t)) { double bottle = Double.POSITIVE_INFINITY; // initial bottleneck capacity for (int v = t; v != s; v = edgeTo[v].other(v)) bottle = Math.min(bottle, edgeTo[v].residualCapacityTo(v)); for (int v = t; v != s; v = edgeTo[v].other(v)) edgeTo[v].addResidualFlowTo(v, bottle); value += bottle; // augment flow } return value; // will be the maxflow }