1 / 37

# notes - PowerPoint PPT Presentation

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.

Related searches for notes

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

## PowerPoint Slideshow about 'notes' - JasminFlorian

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

### 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.

• 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

• 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.

• 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

• 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.

• 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.

• 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

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 )

Lemma : | f | = f (V, t).

Pf)

• 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.

• 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.

• 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 |

• 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 ' | .

• 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 }.

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 |.

The following are equivalent :

• f is a maximum flow.

• f admits no augmenting path.

• | f | = c(S,T ) for some cut (S,T ).

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]

• 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.

• 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)

• 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’.

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.

• 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.

• 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.

• 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.

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.

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.

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)

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.

• 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.

• 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)

• 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.

• 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.

• 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]]

• 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)

elsif cf (u, v) > 0, and h(u) = h(v) + 1

then PUSH(u,v)

else current[u] ← next-neighbor[v]

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}

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]

• 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.