network flow n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Network Flow PowerPoint Presentation
Download Presentation
Network Flow

Loading in 2 Seconds...

play fullscreen
1 / 37

Network Flow - PowerPoint PPT Presentation


  • 589 Views
  • Updated on

Network Flow. Network flow. Use a graph to model material that flows through conduits. Each edge represents one conduit, and has a capacity, which is an upper bound on the flow rate = units/time. Can think of edges as pipes of different sizes.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

Network Flow


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
    Presentation Transcript
    1. Network Flow

    2. Network flow • Use a graph to model material that flows through conduits. • Each edge represents one conduit, and has a capacity, which is an upper bound on the flow rate = units/time. • Can think of edges as pipes of different sizes. • Want to compute max rate that we can ship material from a designated source to a designated sink.

    3. Flow networks • G = (V, E) directed. • Each edge (u,v) has a capacity c(u, v)  0. • If (u, v)  E, then c (u, v) = 0. • Source vertex s, sink vertex t, assume s  v  t for all v  V. • Therefore, G is connected, and |E|  |V| - 1

    4. Flow • Let G be a flow network with a capacity function c. Let s be the source and t be the sink. • A flow in G is a real-valued function f : V  V  R satisfying • Capacity constraint : For all u, v V , f(u, v) ≤ c(u, v). • Skew symmetry : For all u, v V, f(u, v) = - f(v, u). • Flow conservation : For all u V – {s, t}, ∑ v  Vf(u, v) = 0. • f(u, v) is called the flow from u to v, and can be positive, negative, or zero. • The value of a flow f is defined as | f | = ∑ v  Vf(s, v) = total flow out of source. • Given a flow network G with capacity function c, source s and sink t, maximum-flow problem finds a flow of maximum value.

    5. Positive flow • The total positive flow entering a vertex is defined by ∑ f (u, v). • The total positive flow leaving a vertex is defined symmetrically. • The total net flow at a vertex = total positive flow leaving a vertex – total positive flow entering a vertex. • Flow conservation says total positive flow entering a vertex (other than s or t ) = total positive flow leaving the vertex (“flow in = flow out”) v  V f(u,v) > 0

    6. Cancellation with flow • If we have edges (u, v) and (v, u), skew symmetry makes it so that at most one of these edges has positive flow. • Say f(u, v) = 5. If we “ship” 2 units v u, we lower f (u, v) to 3. The 2 units v u cancel 2 of the u  v units. • Due to cancellation, a flow only gives us this “net” effect. We cannot reconstruct actual shipments from a flow. 5 units u  v , 0 units v u is the same as 8 units u  v , 3 units v u The flow from u to v remain f (u, v) = 5 and f (v, u) = -5.

    7. Networks with multiple sources and sinks • If there are multiple sources {s1, s2 , …, sm } and sinks {t1, t2 , …, tn}, we can reduce the problem of determining a maximum flow in a network with multiple sources and multiple sinks to an ordinary maximum-flow problem. • We add a supersources and a directed edge (s, si) with capacity c(s, si) =  for each i = 1, 2, …, m. • We add a supersinktand a directed edge (ti, t) with capacity c(ti, t) =  for each i = 1, 2, …, n.

    8. Implicit summation notation • Extend the notation of f, to take sets of vertices, with interpretation of summing over all vertices in the set. • If X and Y are sets of vertices, f (X, Y) = ∑∑ f (x, y). Therefore, can express flow conservation as f (u, V) = 0, for all u  V – {s, t}. For convenience, omit set braces in the implicit summations. In equation f (s, V - s) = f (s, V ) , V – s means V – {s}. x  X y  Y

    9. Lemma For any flow f in G = (V, E) : • For all X  V, f (X, X ) = 0. • For all X, Y  V, f (X, Y ) = - f (Y, X ). • For all X, Y, Z  V with X ∩ Y = , f (X  Y, Z ) = f (X, Z ) + f (Y, Z ) and f (Z, X  Y ) = f (Z, X) + f (Z, Y )

    10. Example Lemma : | f | = f (V, t). Pf)

    11. Cuts • A cut (S, T ) of flow network G = (V, E ) is a partition of V into S and T = V – S such that s  S and t  T. • For flow f, the net flow across cut (S, T ) is f (S, T ). • Capacity of cut (S, T ) is c (S, T ). • A minimum cut of G is a cut whose capacity is minimum over all cuts of G.

    12. Lemma • Lemma (26.5) For any cut (S, T ), f (S, T ) = | f | • Corollary (26.6) The value of any flow f in a flow network G ≤ capacity of any cut. • Therefore, maximum flow ≤ capacity of minimum cut. We’ll see later that maximum flow = capacity of minimum cut.

    13. Residual network • Given a flow f in network G = (V, E ), consider a pair of vertices u, v  V. How much additional flow can we push directly from u to v ? That’s the residual capacity, cf (u, v) = c (u, v) – f (u, v)  0 • Residual network: Gf (V, Ef ), Ef = { ( u, v )  V  V : cf (u, v) > 0}. • Each edge of the residual network (residual edge ) can admit a positive flow. • The edges in Ef is either edges in E or their reversals. Thus, | Ef | ≤ 2 | E |

    14. Residual network • Residual network Gf is itself a flow network with capacities given by cf • Given flows f 1and f 2 , the flow sum f 1+ f 2 is defined by ( f 1+ f 2 ) (u, v ) = f 1 (u, v ) + f 2 (u, v ) for all u, v  V . • Lemma 26.2 Given flow network G, a flow f in G, the residual network Gf , let f 'be any flow in Gf . Then the flow sum f + f 'is a flow in G with value | f + f '| = | f | + | f ' | .

    15. Augmenting path • Given a flow network G and a flow f, an augmenting path p is a simple path from s tot in the residual network Gf . • Each edge (u, v) on an augmenting path can admit some additional positive flow from u to v. • We call the maximum amount by which we can increase the flow on each edge in an augmenting path p, the residual capacity of p, given by cf (p) = min {cf (u, v): (u, v) is on p }.

    16. Lemma 26.3. Let G = (V, E ) be a flow network, let f be a flow in G, let p be an augmenting path in Gf . .Define a function fp : V  V  R by fp (u, v) = cf (u, v)if (u, v) is on p, - cf (u, v)if (v, u) is on p 0 otherwise. Then fp is a flow in Gf with value | fp | = cf (p) > 0 Corollary Given flow network G, flow f in G, and an augmenting path p in Gf , define fpas in lemma, and define f’ : V  V  R by f’ = f + fp. Then f’ is a flow in G with value | f’ | = | f | + cf (p) > | f |.

    17. Theorem 26.7 (Max-flow min-cut theorem) The following are equivalent : • f is a maximum flow. • f admits no augmenting path. • | f | = c(S,T ) for some cut (S,T ).

    18. Ford-Fulkerson algorithm FORD-FULKERSON (G, s, t) for each edge (u,v) E(G) dof [u,v] ← f [v,u]← 0 while there is an augmenting path p in Gf docf (p) ← min {cf (u, v): (u, v) is on p } for each edge (u,v) in p dof [u,v] ← f [u,v] + cf (p) f [v,u] ← - f [u,v]

    19. Analysis of Ford-Fulkerson • Running time depends on how the augmenting path is determined. (It may not even terminate for irrational capacities!) • If capacities are all integers, then each augmenting path raises | f | by ≥1. If max flow is f* , then need ≤ | f* | iterations. O(E | f* | ). • We can improve the bound if we implement the computation of the augmenting path p with a breadth-first search ( = if the augmenting path is a shortest path from s to t in the residual network with all edge weights = 1. ) This is called Edmonds-Karp algorithm.

    20. Analysis of Edmonds-Karp algorithm • Edmonds-Karp runs in O(V E2) time. • To prove, need to look at distances to vertices in Gf • Let δf (u,v) = shortest path distance u to v in Gf with unit edge weights. • Lemma(26.8) : For all v V – {s, t} , δf (s,v) increases monotonically with each flow augmentation. • Theorem(26.9) : Edmonds-Karp performs O(V E ) augmentations. • Use BFS to find each augmenting path in O(E) time. • “push-relabel algorithms” can yield better bounds (O(V2E) in Section 26.4, O(V3) in Section 26.5)

    21. Maximum bipartite matching • G = (V, E) (undirected ) is bipartite if we can partition V = L  R such that all edges in E go between L and R. • A matching is a subset of edges M  E such that for all v  V , ≤ 1 edge of M is incident on v (vertex v is matched if an edge of M is incident on it; otherwise unmatched). • Maximum matching : a matching of maximum cardinality. • Problem : given a bipartite graph G = (V, E), find a maximum matching. • Define flow network G’ = (V’, E’), • V’ = V  {s, t}. • E’ = {(s, u) : u  L }  { (u,v) : u  L, v  R}  { (v,t) : v  R}. • c(u,v)=1 for all (u,v)  E’.

    22. Lemma If M is a matching in G, then there is an integer-value flow f in G’ with value | f | = |M|. If f is an integer-valued flow in G’, then there is a matching M in G with cardinality |M| = | f | . • Integrality theorem : If the capacity function c takes only integral values, then the maximum flow f produced by the Ford-Fulkerson method has the property that |f | is integer-valued. Moreover, for all vertices u and v, the value of f (u,v) is an integer.

    23. Push-relabel algorithms • Works on one vertex at a time, looking only at the vertex’s neighbors in the residual network. • Do not maintain flow conservation property throughout the execution. • Maintain a preflow f, which satisfies skew symmetry, capacity constraints, and f (V,u)≥ 0 for all vertices u V – {s}. • Excess flow into u is given by e(u) = f (V,u) • Vertex u  V – {s, t} is overflowing if e(u) > 0.

    24. Push-relabel algorithms • Each vertex has heights. Push flow downhill, from a higher vertex to a lower vertex. • The height of the source is |V |, and the height of the sink is fixed at 0. • All other vertex heights start at 0 and increase with time. • First, send as much flow as possible downhill from the source toward the sink – sends the capacity of the cut (s, V – s). • When the only pipes that leave a vertex u and are not already saturated with flow connect to vertices that are not downhill from u, increase its height (“relabel” u ) – increase the height to be one more than the height of the lowest of its neighbors to which it has an unsaturated pipe. • After all the flow that can get to the sink has arrived there, make the preflow a “legal” flow by sending the excess of overflowing vertices back to the source by relabeling vertices to above the fixed height |V| of the source.

    25. Basic operations • Two basic operations : pushing flow excess from a vertex to one of its neighbors, and relabeling a vertex. • A function h : V → Nis a height function if h(s) = |V |, h(t) = 0, and h(u) ≤ h(v) + 1 for every residual edge (u, v)  Ef. • Lemma 26.13 : Let G=(V, E) be a flow network, let f be a preflow in G, and let h be a height function on V. For any two vertices u, v V, if h(u) > h(v) + 1, then (u,v) is not an edge in the residual graph.

    26. Push operation PUSH(u,v) Applies when : u is an overflowing , cf (u, v) > 0, and h(u) = h(v) + 1. Action : Push df (u, v) = min(e[u], cf (u, v)) from u to v. df (u, v) ← min(e[u], cf (u, v)) f [u, v] ← f [u, v] + df (u, v) f [v, u] ← - f [u, v] e[u] ← e[u] - df (u, v) e[v] ← e[v] + df (u, v) • If edge (u,v) becomes saturated (cf (u, v) = 0 afterward), it is a saturating push. Otherwise, a nonsaturating push. • Lemma : after a nonsaturating push from u to v, v is no longer overflowing.

    27. Relabel operation RELABEL(u) Applies when : u is overflowing, and for all v V such that (u, v)  Ef , h(u) ≤ h(v) . Action : increase the height of u. h(u) ← 1 + min{h(v) : (u, v)  Ef } • After RELABEL(u), Ef contains at least one edge that leaves u because u is overflowing. So it gives u the greatest height allowed by the constraint on height functions,h(u) ≤ h(v) + 1 for every residual edge (u, v)  Ef.

    28. Initialization INITIALIZE-PREFLOW(G, s) for each vertex u  V [G] do h[u]← 0 e[u]← 0 for each edge (u, v)  E[G] do f [u, v] ← 0 f [v, u] ← 0 h[s]← | V [G] | for each vertex u  Adj[s] do f [s, u] ← c(s, u) f [u, s] ← -c(s, u) e[u] ← c(s, u) e[s] ← e[s] - c(s, u)

    29. Generic algorithm GENERIC-PUSH-RELABEL(G) INITIALIZE-PREFLOW(G,s) while there exists an applicable push or relabel operation do select an applicable push or relabel operation and perform it • Lemma : An overflowing vertex can be either pushed or relabeled.

    30. Correctness of the push-relabel method • Prove that if it terminates, the preflow f is a maximum flow. • Prove that it terminates. • Lemma : Vertex heights never decrease during the execution of the algorithm. Whenever relabel operation is applied to u, h[u] increases by at least 1. • Lemma : During the execution of the algorithm, h is maintained as a height function. • Lemma : Let f be a preflow in a flow network G. Then, there is no path from s to t in the residual network Gf • Theorem : If the algorithm terminates, the preflow f compute is a maximum flow.

    31. Analysis of the push-relabel method • Lemma : For any overflowing vertex u, there is a simple path from u to s in the residual network Gf . • Lemma : At any time during the execution of the algorithm, h[u] ≤ 2 |V | - 1 for all vertices u  V. • Corollary : The number of relabel operations is at most h[u] ≤ 2 |V | - 1 per vertex and at most (2 |V | - 1 )(|V | - 2 ) < 2 |V |2overall. • Lemma : The number of saturating pushes is < 2 |V | | E |. • Lemma : The number of nonsaturating pushes is <4|V |2(|V |+ |E| ). • Theorem : the number of basic operations is O(V 2 E)

    32. Relable-to-front algorithm • A push-relabel algorithm but choosing the order of basic operations carefully. • O(V 3) running time. • Maintains a list of the vertices in the network • Beginning at the front, scan the list repeatedly selecting an overflowing vertex u and then “discharging” it. (“discharge” = push and relabel until u is no longer overflowing.) • Whenever a vertex is relabeled, it is moved to the front of the list and the algorithm begins its scan anew.

    33. Admissible edges and networks • If G=(V, E) be a flow network, f is a preflow in G, and h is a height function, then (u, v) is anadmissible edgeif cf (u, v) > 0, and h(u) = h(v) + 1. Otherwise, (u, v) is inadmissible. • The admissible network is Gf,h =(V, Ef,h ), whereEf,his the set of admissible edges. • The admissible network consists of those edges through which flow can be pushed. • Lemma : admissible netwosk is acyclic. • Lemma : if a vertex u is overflowing, and (u,v) is an admissible edge, then PUSH(u,v) applies. It does not create any new admissible edges, but it may make (u,v) inadmissible. • Lemma : if u is overflowing, and there is no admissible edges leaving u, RELABEL(u) applies. After operation, there is at least one admissible edge leaving u, but no admissible edges entering u.

    34. Neighbor lists • Neighbor list N [u] for a vertex u  V is a singly linked list of the neighbors of u in G. • head[N [u]] – points the first vertex in N [u] • next-neighbor[v] – points the next vertex in the list Relable-to-front algorithm cycles through each neighbor list in an arbitrary order fixed throughout the execution. For each vertex u, current[u] points to the vertex currently under consideration in N [u] Initially, current[u] is set to head[N [u]]

    35. Discharging an overflowing vertex • An overflowing vertex u is discharged by pushing all its excess flow through admissible edges, relabeling u as necessary to cause edges leaving u to become admissible. DISCHARGE(u) while e[u] > 0 do v ← current[u] if v = NIL then RELABEL(u) current[u] ← head[N[u]] elsif cf (u, v) > 0, and h(u) = h(v) + 1 then PUSH(u,v) else current[u] ← next-neighbor[v]

    36. Relable-to-front algorithm RELABLE-TO-FRONT(G,s,t) INITIALIZE-PREFLOW(G,s) L ← V[G] – {s, t}, in any order for each vertex u V[G] – {s,t} do current[u] ← head[N[u]] u ← head[L] while u  NIL do old-height ← h[u] DISCHARGE(u) if h[u] > old-height then move u to the front of list L u ← next[u]

    37. Correctness of relabel-to-front • An implementation of generic push-relabel algorithm – performs push and relabel operations only when they apply. • Need to show when relabel-to-front terminates, no basic operations apply. • Loop invariant : List L is a topological sort of the vertices in the admissible network and no vertex before u in the list has excess flow.