1. Algorithm Design and Analysis (ADA)
, Semester
12. Maxflow Networks v.2
Objectives
describe the maxflow problem, explain and analyse the Ford-Fulkerson, Edmonds-Karp
look at the mincut problem, bipartite matching and edge disjoint paths

2. Overview A Flow Network Ford-Fulkerson (FF) Algorithm
Edmonds-Karp (EK) Algorithm
The Mincut Problem
Bipartite Matching
Edge Disjoint Paths
Making Maxflow Faster

3. 1. A Flow Network 'pipe' capacity for 'water' flow x 20 10 30 s t
source
terminal
(sink) 20 10 y
What is the maximum flow f from s to t?

4. Answer flow / capacity x 20/20 10/10 10/30 s t 20/20 10/10 y
flows must
be integer
10/30 s t
20/20
10/10 y
Maxflow f = 30 = ∑ outflow of s = ∑ inflow of t

5. Flow Rules Capacity constraint Flow conservation inflow at v =
0 ≤ edge's flow ≤ edge's capacity
Flow conservation
inflow = outflow at every vertex (except s and t)
inflow at v =
= 10
outflow at v =
= 10

6. Another Example
A maxflow f in G is 19

7. Many Applications of Maxflow
Bipartite matching
Data mining
Network reliability
Image processing
Network connectivity
Distributed computing
many more ...
blood flow analysis

8. 2. Ford-Fulkerson (FF) Algorithm
void FF(Graph G, Node s, Node t) { initialize flows on all edges in G to 0; change G into residual graph Gf; while (can find an augmented path P in Gf) { bottleneck b = minimum of edge weights in P; augment flow along P in G using b; regenerate Gf from updated G; } report maxflow f in G; }

9. Graph  Residual Graph
Every flow/capacity edge in the graph G becomes two edges in the residual graph Gf
forward edge: max amount can increase flow
flow / capacity Gf 11 G
6 / 17 u v u v 6
values on edges
called residual
capacities
backward edge: max amount can decrease flow

10. 2.1 Example: initial G  Gf x x G to Gf s t s t y y x
0/10 x
0/20 20 10
G to Gf s t s t
0/30 30 10
0/10
0/20 20 y y 20 x 10
To make Gf less messy, 0 weighted
edges are not drawn. s t 30 10 20 y

11. Find an Augmented Path P in Gf
In FF, an augmented path is any path from s to t in the residual graph Gf
forward and backward edges can be used (if not 0) 20 x
One possible augmented path P:
s  x  y  t 10 s t 20 30 30 20 10 20 y
Bottleneck b = min of edge weights in P
= 20

12. Augment Flow along P in G using b
The flow fe on each edge e in G can change in two ways:
fe = fe + b in G if the edge in P is a forward edge
i.e. increase the flow
fe = fe – b in G if the edge in P is a backward edge
i.e. decrease the flow

13. Update G x x G to Gf s t s t y y One augmented path P: s  x  y  t x
0/10
0/20 20 x 10
G to Gf s t
0/30 s t 30 10
0/10
0/20 20 y y
One augmented path P:
s  x  y  t x
0/10
20/20
augment
flow s t 20 30
20/30 20
0/10
20/20
Bottleneck b = 20;
s  x and y  t are
the critical edges y

14. Regenerate Gf from Updated Gx 10 x
0/10
20/20
G to Gf 20 s 10 t s t
20/30 20 10 20
0/10
20/20 y y
remove 0 weight edges x 10 20 s 10 t 20 10 20 y

15. Find Augmented Path x One augmented path P: s  y  x  t s t y10 20 10
One augmented path P:
s  y  x  t s t 20 10 20 10 20 10 y
Bottleneck b = 10;
s  y and x  t are
the critical edges

16. Update G x x G to Gf s t s t y y One augmented path P: s  y  x  t x
0/10 x
20/20 10
G to Gf 20 s t s 10 t
20/30 20 10 20
0/10
20/20 y y
One augmented path P:
s  y  x  t x
10/10
20/20
augment
flow 10 20 10 s t
10/30
Bottleneck b = 10
10/10
20/20 y

17. Regenerate Gf from Updated Gx x
10/10
20/20
G to Gf 20 s 20 10 t s t 10
10/30 20 10
10/10
20/20 y y
remove 0 weight edges x 20 s 20 10 t 10 20 10 y

18. Find Augmented Path x There are no paths from s to t.
The while loop in FF() exits,
and the maximum flow f
in G is reported. 20 s 20 10 t 10 20 10 y
maxflow f = 30
= ∑ outflow of s = ∑ inflow of t = ∑ all bottlenecks b's
= = 30 x
10/10
20/20 s t
10/30
10/10
20/20 y

19. 2.2 Another Example v1 12 v3 20 16 t s 4 7 9 13 v2 v4 4 14

20. Add Initial Flows of 0 v1 v3 t s v2 v4 0/12 0/20 0/16 0/4 0/7 0/9 0/13
0/14

21. Generate Initial Gf G to Gf s t s t remove 0 weight edges s t 12 v1
0/12 v3 v1 v3
0/20 16 20
0/16
0/9 9 s t s 4 7 t
0/4
0/7 14
0/13 v2 v4 13 4
0/14 v2 v4
0/4
remove 0 weight edges 12 v1 v3 16 20 9 s 4 7 t 14 13 v2 4 v4

22. Gf G
b = 4
b = 4
b = 4

23. Gf G
b = 7 2
b = 4 11
maxflow f = 23
(also = ∑ all b's) 2 11

24. 2.3. FF Running Time dfs/bfs = O(V+E) = O(E) O(E) O(E) O(E) O(E)
void FF(Graph G, Node s, Node t) { initialize flows on all edges in G to 0; change G into residual graph Gf; while (can find an augmented path P in Gf) { bottleneck b = minimum of edge weights in P; augment flow along P in G using b; regenerate Gf from updated G; } report maxflow f in G; }
O(E)
O(E)
O(E)
O(E)
Total Running time:
O(E ∙ |f|)
no. of loops = | f |

25. Why no. of loops == |f|? The loop stops when no more b's can be found.
The maxflow f = ∑ all b's
In the worst case each time round loop produces the smallest b, which is 1
So it will take f loops before ∑ all b's == f
So max no. of loops == |f|

26. In the worst case, the running time of FF is O(E · |f|)
|f| might be very big depending on the problem.
It might be much larger than the number of edges.

27. 2.4. FF can be slow!

28. The Augmenting Paths
First
Second

29. many,
many
more
Third
Fourth

30. 199th
200th (= maxflow)

31. Choosing Paths is Important
Only two
iterations
are needed.

32. 2.5. Choosing 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

33. 3. Edmonds-Karp (EK) Algorithm
void EK(Graph G, Node s, Node t) { initialize flows on all edges in G to 0; change G into residual graph Gf; while (can find an augmented SHORTEST path P in Gf) { bottleneck b = minimum of edge weights in P; augment flow along P in G using b; regenerate Gf from updated G; } report maxflow f in G; }
Running time: O(V· E2)

34. Finds an augmenting path using breadth-first search.
The bfs algorithm is slightly changed:
a weight of 1 is assigned to every forward and backward edge, not the edge's residual capacity
i.e. count the no. of edges

35. 3.1. First Example Again x 20 10 30 s t 20 10 y

36. Generate Initial Gf x x G to Gf s t s t y y remove 0 weight edges x s
0/10 x
0/20 20 10
G to Gf s t s t
0/30 30 10
0/10
0/20 20 y y
remove 0 weight edges 20 x 10 s t 30 10 20 y

37. Gf  G x x s t s t b = 10 y y x x s t s t b = 10 y y 10/10 20 10 10/20
0/30 30 10
b = 10 20
0/10
0/20 y y 10 x x
10/10 10
10/20 10 s t s t
0/30 30 10
b = 10 20
10/10
10/20 y y

38. Gf  G x x s t s t b = 10 y y x maxflow f = 30 (also = ∑ all b's) s t
10/10 10
20/20 10 s 30 t s t
10/30 10 10
b = 10 10
10/10
20/20 y y x 10
maxflow f = 30
(also = ∑ all b's) 20 s 20 10 t 10 20 y

39. 3.2. EK Running Time bfs = O(V+E) = O(E) O(E) O(E) O(E) O(E)
void EK(Graph G, Node s, Node t) { initialize flows on all edges in G to 0; change G into residual graph Gf; while (can find an augmented SHORTEST path P in Gf) { bottleneck b = minimum of edge weights in P; augment flow along P in G using b; regenerate Gf from updated G; } report maxflow f in G; }
O(E)
O(E)
O(E)
O(E)
Running time: O(V· E2)
no. of loops = O(V · E)

40. Why no. of loops == O(V∙E)?
The loop stops when no more b's can be found (i.e. when there are no more critical edges).
So max no of loops == max no. of critical edges
Remember:
Smallest shortest path == 1
Longest shortest path == |V| - 1
Smallest b in a path == 1

41. Assume e is critical when path distance = p:
What is the maximum number of times one edge e (u -- v) can be critical?
Assume e is critical when path distance = p:
assume path distance of s to u == d u s t 1
assume path distance of s to t == p v
path s to v == d+1

42. The earliest that e can next be critical is when path distance = p+2
path distance of s to u == d + 2 u s t 1
smallest path distance of s to t == p + 2 v
smallest path s to v == d+1

43. So the most times that one edge can be critcal is when p ==
1, 3, 5, 7, ..., |V-1|
= O(v/2) = O(V) times
The most times that all e edges can be critical is:
E * O(V) = O(E ∙ V)
Max no. of critical edges == O(V ∙ E) == max no. of loops

44. 4. The Mincut Problem
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.

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

46. Maxflow == Mincut The maxflow problem The mincut problem
find a flow of maximum value
The mincut problem
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

47. 5. Bipartite Matching Offers: Students apply for jobs.
Each student gets several offers.
Is there a way to match every student to a different job?

48. As a Bipartite Graph Alice Adobe Bob Amazon Carol Facebook Dave Google
Eliza
IBM
Frank
Yahoo

49. Maximize No. of 1-1 Edges Alice Adobe Bob Amazon Carol Facebook Dave
Google
A perfect match
Eliza
IBM
Frank
Yahoo

50. Changing Bipartite to Maxflow
Direct edges from L to R, and set all capacities to 1.
Add source s, and link s to each node in L.
Add sink t, and link each node in R to t. 1 1 1 1 1

51. Conversion to Maxflow Alice Adobe Bob Amazon Carol Facebook s t Dave
1/1
1/1
1/1
Bob
Amazon
1/1
1/1
1/1
1/1
Carol
1/1
Facebook
1/1
1/1 s t
1/1
1/1
Dave
Google
1/1
1/1
1/1
Eliza
IBM
1/1
1/1
1/1
Frank
Yahoo
Other edges are 0/1

52. 6. Edge Disjoint Paths
Find the max number of edge-disjoint s-t paths in a digraph.
two paths are edge-disjoint if they have no edge in common

53. Solution
Two edge-disjoint s-t paths:

54. Maxflow Formulation Assign capacities of 1 to every edge.
Max no. of edge-disjoint s-to-t paths = maxflow
1/1
0/1
1/1
1/1
1/1
1/1
0/1
1/1
1/1
1/1
1/1
Other edges are 0/1

55. 6.1. Network Connectivity
Related Problem: Find the min. no. of edges whose removal disconnects t from s.
A set of edges F disconnects t from s if each s-t paths uses at least one edge in F
removing F would make t unreachable from s
Removing
two edges
breaks the
s-t link

56. The max no. of edge-disjoint s-t paths = min no
The max no. of edge-disjoint s-t paths = min no. of edges whose removal disconnects t from s.
utilizes the mincut

57. 7. Making MaxFlow Faster
year
method
worst case
running time
discovered by
1955
augmenting path
O(E · |f|)
Ford-Fulkerson
1970
shortest
augmented path
O(V · E2)
Edmonds-Karp
1983
dynamic trees
O(E2 ·log E)
Sleator-Tarjan
1985
capacity scaling
O(E2 · log C)
Gabow
1997
length function
O(E3/2 · log E · log C)
Goldberg-Rao ? E
C is the biggest capacity on an edge in the graph.

58. Analysis is Tricky
Worst-case big-Oh is generally not useful for predicting or comparing real-world maxflow algorithm speeds.
Best in practice: push-relabel method with gap relabeling: O(E3/2) (can be written as O(V3)
very close to linear in E