Download presentation

Presentation is loading. Please wait.

Published byMervyn Phillips Modified about 1 year ago

1
ADA: 12. Max Flow1 Objective o 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) Algorithm Design and Analysis (ADA) , Semester Max Flow Networks

2
Overview 1.A Flow Network 2.The Maxflow Problem 3.The Mincut Problem 4.Ford-Fulkerson (FF) Algorithm 5.Residual Network 6.Ford-Fulkerson (FF) Again 7.Edmonds-Karp Algorithm 8.Capacity Scaling 9.Two Flow Problems Again 10.Bipartite Matching 11.Edge Disjoint Paths 12.Making Maxflow Faster

3
ADA: 12. Max Flow3 1. A Flow Network postive flow capacities source sink

4
ADA: 12. Max Flow4 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
ADA: 12. Max Flow5 The maxflow problem o find a flow of maximum value The mincut problem o 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. Two Flow Problems

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

7
ADA: 12. Max Flow7 The flow value f is the inflow at the sink t o or the outflow at the source s Maxflow problem: find a flow of maximum value flow = = 28

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

9
ADA: 12. Max Flow9 Flow Notation

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

11
ADA: 12. Max Flow11 A cut is 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. 3. The Mincut Problem

12
ADA: 12. Max Flow12Examples capacity = = 34 don't count edges from B to A capacity = = 30 The minimum cut (mincut) problem: find a cut of minimum capacity. The minimum cut (mincut) problem: find a cut of minimum capacity.

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

14
ADA: 12. Max Flow14 First Augmenting Path

15
ADA: 12. Max Flow15 Second Augmenting Path

16
ADA: 12. Max Flow16 Third Augmenting Path

17
ADA: 12. Max Flow17 Fourth Augmenting Path

18
ADA: 12. Max Flow18 No more augmenting paths All paths from s to t are blocked by either: o a full forward edge, or o a empty backward edgeTermination maxflow = 28 mincut = 28

19
ADA: 12. Max Flow19 Let f be a flow on G = (V, E). The residual network Gf(V, Ef ) is a graph showing residual capacities o 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 ( and decrease ) the chosen path causes. 5. Residual Network uv 6 / 17 flow f()capacity c() Graph G uv 11 6 two residual capacities cf() Graph Gf for increasing flow in (u,v) for decreasing flow in (u,v)

20
ADA: 12. Max Flow20 Residual networks also show how flow along an edge can be reduced o 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) Gf Edges for Reducing

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

22
ADA: 12. Max Flow22 A path from s to t in Gf is an augmenting path in G which carries flow f. The flow amount can be increased along an augmenting path by the minimum amount cf( p) = min {c f (u,v)} cf(p) is the residual or bottleneck capacity – it is the most that the flow can be increased due to one or more of p's edges being used at full capacity. Augmenting Paths (u,v) ∈ p

23
ADA: 12. Max Flow23Example 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
ADA: 12. Max Flow24 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 Gf version of this G graph. No more augmented paths can be added, so f is the maxflow (f = 23).

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

26
ADA: 12. Max Flow26 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 } FF in More Detail

27
ADA: 12. Max Flow27 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)). Executing of FF with a Residual Network

28
ADA: 12. Max Flow28 GfG

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

30
ADA: 12. Max Flow30 In the worst case, the running time of FF is O(E · |f|), where f is the maxflow o 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) o 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 FF Running Time

31
ADA: 12. Max Flow31 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). Worst Running Time

32
ADA: 12. Max Flow32 The Augmenting Paths FirstSecond

33
ADA: 12. Max Flow33 ThirdFourth many, many more

34
ADA: 12. Max Flow34 199th 200th (= maxflow)

35
ADA: 12. Max Flow35 This case is easily avoided by a choosing a better series of augmenting paths. Choosing Paths is Important Only two iterations are needed.

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

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

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

39
ADA: 12. Max Flow39 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) o 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.Proof

40
ADA: 12. Max Flow40 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
ADA: 12. Max Flow41 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. Case 1: (u, v) ∈ Ef

42
ADA: 12. Max Flow42 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 : o 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. Case 2: (u, v) ∉ Ef

43
ADA: 12. Max Flow43 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 o 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. Counting Flow Augmentations

44
ADA: 12. Max Flow44 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
ADA: 12. Max Flow45 Example Why "+2"? assume (u,v) is critical

46
ADA: 12. Max Flow46 was 5, now is 7 was 6, now is 8 assume (v,u) is critical

47
ADA: 12. Max Flow47 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 o 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). Running time of Edmonds-Karp

48
ADA: 12. Max Flow48 Corollary. The Edmonds-Karp maximum-flow algorithm runs in O(V· E 2 ) 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· E 2 )

49
ADA: 12. Max Flow49 boolean[] marked; // true if s->v path is in residual network FlowEdge[] edgeTo; // last edge on s->v path Queue q = new Queue (); // use when finding an augmenting path Edmonds-Karp Code

50
ADA: 12. Max Flow50 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 }

51
ADA: 12. Max Flow51 boolean hasAugmentingPath(FlowNetwork graph, int s, int t) { marked.clear(); // set all marks to false q.reset(s); marked[s] = true; while (!q.isEmpty()) { int v = q.remove(); for (FlowEdge e : graph.adj(v)) { int w = e.other(v); // found path from s to w? if(e.residualCapacityTo(w) > 0 && !marked[w]) { edgeTo[w] = e; // save last edge on path to w; mark w; marked[w] = true; q.add(w); } return marked[t]; // is t reachable from s in residual network? }

52
ADA: 12. Max Flow52 Choosing an augmenting path with the highest bottleneck capacity will increase the flow by the biggest possible amount. o Don't try to find an exact highest bottleneck path (too slow) o Use a scaling parameter Δ instead o Let Gf (Δ) be the subgraph of the residual graph consisting of only arcs with capacity of at least Δ 8. Capacity Scaling

53
ADA: 12. Max Flow53 scaling-Max-Flow(G, C) { foreach e ∈ E in G f(e) = 0 Δ = smallest power of 2 greater than or equal to C Gf = residual graph of G while (Δ ≥ 1) { Gf(Δ) = Δ-residual graph while (there exists augmenting path P in Gf(Δ)) { cf(p) = min{ cf(u,v) : (u,v) ∈ P } // bottleneck capacity foreach e ∈ P { // augment flows with P if (e ∈ E) f(e) = f(e) + b // forward edge e=(u,v) else f(e') = f(e') - b // reverse edge e'=(v,u) } update Gf(Δ) } Δ = Δ / 2 } Capacity Scaling Code

54
ADA: 12. Max Flow54 The number of augmenting paths this algorithm calculates is O(E log C) o the log component is due to the outer while loop repeating O(log2 C) times since initially C ≤ Δ < 2C, and Δ decreases by a factor of 2 on each iteration Total running time is O(E 2 log C) o since each augmentating path will be calculated in O(E) time using BFS (as before) Running Time

55
ADA: 12. Max Flow55 The maxflow problem o find a flow of maximum value The mincut problem o find a cut of minimum capacity Two problems that appear very different but are actually two versions of the same question. Maxflow-mincut theorem: maxflow value = mincut capacity 9. Two Flow Problems Again

56
ADA: 12. Max Flow56 The net flow across a cut (A, B) is the sum of the flows on its edges from A to B minus the sum of the flows on its edges from from B to A. If f is the current flow and let (A, B) be any cut. Then, the net flow across (A, B) equals the value of f. Relationship between Flows and Cuts

57
ADA: 12. Max Flow57Example flow = 25 net flow across cut = = 25

58
ADA: 12. Max Flow58Example maxflow = 28 mincut = 28

59
ADA: 12. Max Flow59 It is easy to calculate the mincut (A, B) if the maxflow is known (f). The A set of the mincut = the set of vertices connected to s by an undirected path with no full forward or empty backward edges. Computing a mincut from a maxflow

60
ADA: 12. Max Flow60 N students apply for N jobs. Each gets several offers. Is there a way to match every student to a job? 10. Bipartite Matching

61
ADA: 12. Max Flow61 Input: undirected, bipartite graph G = (L R, E). M E is a matching if each node appears in at most edge in M. Max matching: find a maximum cardinality matching. More Formally Matching: 1- 2', 3 – 1', 4 – 5' Matching: 1- 2', 3 – 1', 4 – 5'

62
ADA: 12. Max Flow62 Direct all edges in E from L to R, and assign capacity 1 to each edge. Add source s, and capacity 1 edges from s to each node in L. Add sink t, and capacity 1 edges from each node in R to t. The resulting digraph G' = (L R {s, t}, E' ). Changing Bipartite to Max Flow

63
ADA: 12. Max Flow63 Conversion to Max Flow Alice Bob CarolDave Eliza Frank source Adobe Amazon Facebook Google IBM Yahoo sink

64
ADA: 12. Max Flow64 Given a digraph G = (V, E) and two nodes s and t, find the max number of edge-disjoint s-t paths. o two paths are edge-disjoint if they have no edge in common Example: communication networks 11. Edge Disjoint Paths

65
ADA: 12. Max Flow65 A solution using 2 edge-disjoint paths:

66
ADA: 12. Max Flow66 Assign unit capacity to every edge. The maximum number of edge-disjoint source-to- sink paths equals the max flow value. Max Flow Formulation

67
ADA: 12. Max Flow67 Given a digraph G = (V, E) and two nodes s and t, find the minimum number of edges whose removal disconnects t from s. A set of edges F E disconnects t from s if each s-t paths uses at least one edge in F o removing F would make t unreachable from s Dual Problem: Network Connectivity Removing two edges breaks the s-t link Removing two edges breaks the s-t link

68
ADA: 12. Max Flow68 Theorem [Menger 1927]. The max number of edge- disjoint s-t paths is equal to the min number of edges whose removal disconnects t from s. utilizes the mincut

69
ADA: 12. Max Flow Making MaxFlow Faster yearmethodworst case running time discovered by 1955augmenting pathO(E · |f|)Ford-Fulkerson 1970shortest augmented path O(V · E 2 )Edmonds-Karp 1983dynamic treesO(E 2 ·log E)Sleator-Tarjan 1985capacity scalingO(E 2 · log C)Gabow 1997length functionO(E 3/2 · log E · log C)Goldberg-Rao ??E? C is the maximum capacity of any edge

70
ADA: 12. Max Flow70 Worst-case big-Oh is generally not useful for predicting or comparing real-world max flow algorithm performance. Best in practice: push-relabel method with gap relabeling: O(E 3/2 ) (can be written as O(V 3 ) o very close to linear in E, but still an open question Analysis is Tricky

Similar presentations

© 2016 SlidePlayer.com Inc.

All rights reserved.

Ads by Google