CS253: Network Flow (2019)

Network Flow
Data Structures and Algorithms
Emory University
Jinho D. Choi

Network Flow
2
S
1
2
3
4
T
Each edge e is associated with a capacity c.

Network Flow
2
S
1
2
3
4
T
4
2
3
1
2
3
4
2

Network Flow
2
S
1
2
3
4
T
4
2
3
1
2
3
4
2
Push as much ﬂow f as possible from S to T.

Network Flow
2
S
1
2
3
4
T
4
2
3
1
2
3
4
2
f(e) ≤ c(e)

Network Flow
2
S
1
2
3
4
T
4
2
3
1
2
3
4
2
f(e) ≤ c(e)
Σu f(u, v) = Σw f(v, w), where v ∉ {S, T}

Network Flow
2
S
1
2
3
4
T
4
2
3
1
2
3
4
2
f(e) ≤ c(e)
Maximum ﬂow?

Network Flow
2
S
1
2
3
4
T
4
2
3
1
2
3
4
2
f(e) ≤ c(e)
3
Maximum ﬂow?

Network Flow
2
S
1
2
3
4
T
4
2
3
1
2
3
4
2
f(e) ≤ c(e)
3
3
Maximum ﬂow?

Network Flow
2
S
1
2
3
4
T
4
2
3
1
2
3
4
2
f(e) ≤ c(e)
3
3
1
2
Maximum ﬂow?

Network Flow
2
S
1
2
3
4
T
4
2
3
1
2
3
4
2
f(e) ≤ c(e)
3
3
1
2
2
Maximum ﬂow?

Network Flow
2
S
1
2
3
4
T
4
2
3
1
2
3
4
2
f(e) ≤ c(e)
3
3
1
2
2
1+2
Maximum ﬂow?

Network Flow
2
S
1
2
3
4
T
4
2
3
1
2
3
4
2
f(e) ≤ c(e)
3
3
1
2
2
1+2
3
Maximum ﬂow?

Network Flow
2
S
1
2
3
4
T
4
2
3
1
2
3
4
2
f(e) ≤ c(e)
3
3
1
2
2
1+2
3
Maximum ﬂow? Optimum?

4
4 2
Ford-Fulkerson Algorithm
3
S
1
2
3
4
T
2
3
1
2
3

4
4 2
3
S
1
2
3
4
T
2
3
1
2
3
Find a path p from S to T, where ∀e 𝜖 p. r(e) = c(e) - f(e) > 0.

4
4 2
3
S
1
2
3
4
T
2
3
1
2
3
∀e 𝜖 p. c(e) = c(e) - min(f(p)).

4
4 22 0
3
S
1
2
3
4
T
2
3
1
2
3
1
∀e 𝜖 p. c(e) = c(e) - min(f(p)).

4
4 22 0
3
S
1
2
3
4
T
2
3
1
2
3
1
∀e 𝜖 p. c(e) = c(e) - min(f(p)).
MaxFlow = MaxFlow + min(f(p)).

4
4 22 0
3
S
1
2
3
4
T
2
3
1
2
3
1
∀e 𝜖 p. c(e) = c(e) - min(f(p)).
2

43
4 22 01
3
S
1
2
3
4
T
2
3
1
2
3
1
∀e 𝜖 p. c(e) = c(e) - min(f(p)).
2
0
0
2

43
4 22 01
3
S
1
2
3
4
T
2
3
1
2
3
1
∀e 𝜖 p. c(e) = c(e) - min(f(p)).
2
0
0
2
1

431
4 22 01
3
S
1
2
3
4
T
2
3
1
2
3
1
∀e 𝜖 p. c(e) = c(e) - min(f(p)).
2
0
0
2
1
0
0

431
4 22 01
3
S
1
2
3
4
T
2
3
1
2
3
1
∀e 𝜖 p. c(e) = c(e) - min(f(p)).
2
0
0
2
1
0
0
2

431
4 22 01
3
S
1
2
3
4
T
2
3
1
2
3
1
∀e 𝜖 p. c(e) = c(e) - min(f(p)).
2
0
0
2
1
0
0
2
No more
augmenting path!

MaxFlow Class
4
public class MaxFlow
{
private Map<Edge,Double> m_flows;
private double d_maxFlow;
public MaxFlow(Graph graph)
{
init(graph);
}
public void init(Graph graph)
{
m_flows = new HashMap<>();
d_maxFlow = 0;
for (Edge edge : graph.getAllEdges())
m_flows.put(edge, 0d);
}
}

MaxFlow Class
5
public void updateResidual(List<Edge> path, double flow)
{
for (Edge edge : path) updateResidual(edge, flow);
d_maxFlow += flow;
}
public void updateResidual(Edge edge, double flow)
{
Double prev = m_flows.get(edge);
if (prev == null) prev = 0d;
m_flows.put(edge, prev + flow);
}
public double getResidual(Edge edge)
{
return edge.getWeight() - m_flows.get(edge);
}
public double getMaxFlow()
{
return d_maxFlow;
}

FordFulkerson Class
6
private Subgraph getAugmentingPath(Graph graph, MaxFlow mf,  
Subgraph sub, int source, int target)
{
if (source == target) return sub;
Subgraph tmp;
for (Edge edge : graph.getIncomingEdges(target))
{
if (sub.contains(edge.getSource())) continue; // cycle
if (mf.getResidual(edge) <= 0) continue; // no residual
tmp = new Subgraph(sub);
tmp.addEdge(edge);
tmp = getAugmentingPath(graph, mf, tmp, source, edge.getSource());
if (tmp != null) return tmp;
}
return null;
}

FordFulkerson Class
6
private Subgraph getAugmentingPath(Graph graph, MaxFlow mf,  
Subgraph sub, int source, int target)
{
if (source == target) return sub;
Subgraph tmp;
for (Edge edge : graph.getIncomingEdges(target))
{
if (sub.contains(edge.getSource())) continue; // cycle
if (mf.getResidual(edge) <= 0) continue; // no residual
tmp = new Subgraph(sub);
tmp.addEdge(edge);
tmp = getAugmentingPath(graph, mf, tmp, source, edge.getSource());
if (tmp != null) return tmp;
}
return null;
}
Complexity?

FordFulkerson Class
7
public MaxFlow getMaximumFlow(Graph graph, int source, int target)
{
MaxFlow mf = new MaxFlow(graph);
Subgraph sub = new Subgraph();
double min;
while ((sub = getAugmentingPath(graph, mf, sub, source, target)) != null)
{
min = getMin(mf, sub.getEdges());
mf.updateResidual(sub.getEdges(), min);
}
return mf;
}

FordFulkerson Class
7
public MaxFlow getMaximumFlow(Graph graph, int source, int target)
{
MaxFlow mf = new MaxFlow(graph);
Subgraph sub = new Subgraph();
double min;
while ((sub = getAugmentingPath(graph, mf, sub, source, target)) != null)
{
min = getMin(mf, sub.getEdges());
mf.updateResidual(sub.getEdges(), min);
}
return mf;
}
private double getMin(MaxFlow mf, List<Edge> path)
{
double min = mf.getResidual(path.get(0));
for (int i=1; i<path.size(); i++)
min = Math.min(min, mf.getResidual(path.get(i)));
return min;
}

2 2
2 2
Ford-Fulkerson: Backward Pushing
8
S
1
2
T1

2 2
2 21
1
8
S
1
2
T10

2 2
2 21
1
8
S
1
2
T10
1

2 2
2 2
1
1
1
8
S
1
2
T10
1
0

2 2
2 2
1
1
1
8
S
1
2
T10
1
1
0

2 2
2 2
1
1
1
8
S
1
2
T10
1
1
0
1 0

2 2
2 2
1
1
1
8
S
1
2
T10
1
1
0
1 0
1

2 2
2 2
9
S
1
2
T1

2 2
2 21
1
9
S
1
2
T10

2 2
2 21
1
9
S
1
2
T10
1

2 2
2 21
1
9
S
1
2
T10
1
1
1
1

2 2
2 2
1
1
1
9
S
1
2
T10
1
1
1
10

2 2
2 2
1
1
1
9
S
1
2
T10
1
1
1
1
1
0

2 2
2 2
1
1
1
9
S
1
2
T10
1
1
1 12
1
1
0

2 2
2 2
1
1
1
9
S
1
2
T10
1
1
1
0
12
1
1
0
1
0

2 2
2 2
1
1
1
9
S
1
2
T10
1
1
1
0
12
1
1
0
1
0
1

2 2
2 2
1
1
1
9
S
1
2
T10
1
1
1
0
1
12
1
1
0
1
0
1
1
2

2 2
2 2
1
1
1
9
S
1
2
T10
1
1
1
0
1
12
1
1
0
1
0
1
1
2
0 0
22

2 2
2 2
1
1
1
9
S
1
2
T10
1
1
1
0
1
12
1
1
0
1
0
1
1
2
0 0
22
1

protected void updateBackward(Graph graph, Subgraph sub, MaxFlow mf, double min)
{
boolean found;
for (Edge edge : sub.getEdges())
{
found = false;
for (Edge rEdge : graph.getIncomingEdges(edge.getSource()))
{
if (rEdge.getSource() == edge.getTarget())
{
mf.updateResidual(rEdge, -min);
found = true; break;
}
}
if (!found)
{
Edge rEdge = graph.setDirectedEdge 
(edge.getTarget(), edge.getSource(), edge.getWeight());
mf.updateResidual(rEdge, -min);
}
}
}
10

Max-Flow Min-Cut Theorem
11
• S-T cut

11
• S-T cut
- A set of edges whose removal disconnects S to T.

11
• S-T cut
- The capacity of a cut = Σ c(e), ∀e in the cut.

11
S
1
2
3
4
T
4
2
3
1
2
3
4
2
• S-T cut

11
S
1
2
3
4
T
4
2
3
1
2
3
4
2
Minimum cut
• S-T cut

11
S
1
2
3
4
T
4
2
3
1
2
3
4
2
vs.
Maximum ﬂow
Minimum cut
• S-T cut

11
S
1
2
3
4
T
4
2
3
1
2
3
4
2
3
3
1
2
2
3
3
vs.
Maximum ﬂow
Minimum cut
• S-T cut

Finding Min-Cut
12
4
4 2
S
1
2
3
4
T
2
3
1
2
3

Finding Min-Cut
12
4
4 22 0
S
1
2
3
4
T
2
3
1
2
3
1

Finding Min-Cut
12
43
4 22 01
S
1
2
3
4
T
2
3
1
2
3
10
0
2

Finding Min-Cut
12
431
4 22 01
S
1
2
3
4
T
2
3
1
2
3
10
0
2
0
0

Finding Min-Cut
12
431
4 22 01
S
1
2
3
4
T
2
3
1
2
3
10
0
2
0
0
• Algorithm

Finding Min-Cut
12
431
4 22 01
S
1
2
3
4
T
2
3
1
2
3
10
0
2
0
0
• Algorithm
1. Find a path p from S to T, remove any edge e in p, and put e to a set C.

Finding Min-Cut
12
431
4 22 01
S
1
2
3
4
T
2
3
1
2
3
10
0
2
0
0
• Algorithm
2. Repeat #1 until no path is found, and return C.

Finding Min-Cut
12
431
4 22 01
S
1
2
3
4
T
2
3
1
2
3
10
0
2
0
0
• Algorithm
• How can we ﬁnd a min-cut?

Finding Min-Cut
12
431
4 22 01
S
1
2
3
4
T
2
3
1
2
3
10
0
2
0
0
• Algorithm
• How can we ﬁnd a min-cut?
- Instead of removing any edge in #1, remove an edge with the
minimum original (not residual) weight.

Min-Cut vs. Max-Flow
13
• Lemma 1

13
• Lemma 1
- There is no extra edge in the min-cut.

13
• Lemma 1
- Prove?

13
• Lemma 1
- Prove?
• Lemma 2

13
• Lemma 1
- Prove?
• Lemma 2
- All edges in the min-cut must be parts of augmenting paths.

13
• Lemma 1
- Prove?
• Lemma 2
- Prove?

13
• Lemma 1
- Prove?
• Lemma 2
- Prove?
• Lemma 3

13
• Lemma 1
- Prove?
• Lemma 2
- Prove?
• Lemma 3
- Each edge in the min-cut is the minimum weighted edge in each
augmenting path.

13
• Lemma 1
- Prove?
• Lemma 2
- Prove?
• Lemma 3
- Each edge in the min-cut is the minimum weighted edge in each
augmenting path.
- Prove?

Network Flow Using Simplex
14
S
1
2
4
3
T
2
2

14
S
1
2
4
3
T
2
2
x1 x2
x3 x4

14
S
1
2
4
3
T
2
2
x1 x2
x3 x4
Max-Flow

14
S
1
2
4
3
T
2
2
x1 x2
x3 x4
Maximize:
Max-Flow

14
S
1
2
4
3
T
2
2
x1 x2
x3 x4
Maximize:
x2 + x4
Max-Flow

14
S
1
2
4
3
T
2
2
x1 x2
x3 x4
Maximize:
x2 + x4
Subject to:
Max-Flow

14
S
1
2
4
3
T
2
2
x1 x2
x3 x4
Maximize:
x2 + x4
Subject to:
x1 ≤ 4
x2 ≤ 2
x3 ≤ 3
x4 ≤ 2
x2 - x1 ≤ 0
x4 - x3 ≤ 0
Max-Flow

15
S
1
2
3
4
T
4
2
3
1
2
3
4
2

15
S
1
2
3
4
T
4
2
3
1
2
3
4
2
x1
x3
x6
x7
x2
x5
x8
x4

15
S
1
2
3
4
T
4
2
3
1
2
3
4
2
x1
x3
x6
x7
x2
x5
x8
x4
Maximize:

15
S
1
2
3
4
T
4
2
3
1
2
3
4
2
x1
x3
x6
x7
x2
x5
x8
x4
Maximize: Subject to:

15
S
1
2
3
4
T
4
2
3
1
2
3
4
2
x1
x3
x6
x7
x2
x5
x8
x4
x7 + x8

15
S
1
2
3
4
T
4
2
3
1
2
3
4
2
x1
x3
x6
x7
x2
x5
x8
x4
x7 + x8 x3 - x1 ≤ 0
x4 + x5 - x2 - x6 ≤ 0
x6 + x7 - x3 - x4 ≤ 0
x8 - x5 ≤ 0
x1 ≤ 4
x2 ≤ 2
x3 ≤ 3
x4 ≤ 2
x5 ≤ 3
x6 ≤ 1
x7 ≤ 2
x8 ≤ 4

16
S
1
2
4
3
T
2
2
x1 x2
x3 x4
Maximize:
x2 + x4
Subject to:
x1 ≤ 4
x2 ≤ 2
x3 ≤ 3
x4 ≤ 2
x2 - x1 ≤ 0
x4 - x3 ≤ 0
Max-Flow

16
S
1
2
4
3
T
2
2
x1 x2
x3 x4
Maximize:
x2 + x4
Subject to:
x1 ≤ 4
x2 ≤ 2
x3 ≤ 3
x4 ≤ 2
x2 - x1 ≤ 0
x4 - x3 ≤ 0
Max-Flow Min-Cut

16
S
1
2
4
3
T
2
2
x1 x2
x3 x4
Maximize:
x2 + x4
Subject to:
x1 ≤ 4
x2 ≤ 2
x3 ≤ 3
x4 ≤ 2
x2 - x1 ≤ 0
x4 - x3 ≤ 0
Max-Flow Min-Cut
Minimize:

16
S
1
2
4
3
T
2
2
x1 x2
x3 x4
Maximize:
x2 + x4
Subject to:
x1 ≤ 4
x2 ≤ 2
x3 ≤ 3
x4 ≤ 2
x2 - x1 ≤ 0
x4 - x3 ≤ 0
Max-Flow Min-Cut
Minimize:
4x1 + 2x2 + 3x3 + 2x4

16
S
1
2
4
3
T
2
2
x1 x2
x3 x4
Maximize:
x2 + x4
Subject to:
x1 ≤ 4
x2 ≤ 2
x3 ≤ 3
x4 ≤ 2
x2 - x1 ≤ 0
x4 - x3 ≤ 0
Max-Flow Min-Cut
Minimize:
4x1 + 2x2 + 3x3 + 2x4
Subject to:

16
S
1
2
4
3
T
2
2
x1 x2
x3 x4
Maximize:
x2 + x4
Subject to:
x1 ≤ 4
x2 ≤ 2
x3 ≤ 3
x4 ≤ 2
x2 - x1 ≤ 0
x4 - x3 ≤ 0
Max-Flow Min-Cut
Minimize:
4x1 + 2x2 + 3x3 + 2x4
Subject to:
x1 + y1 ≥ 1
x3 + y3 ≥ 1
x2 - y1 ≥ 0
x4 - y3 ≥ 0

17
S
1
2
3
4
T
4
2
3
1
2
3
4
2

17
S
1
2
3
4
T
4
2
3
1
2
3
4
2
x1
x3
x6
x7
x2
x5
x8
x4

17
S
1
2
3
4
T
4
2
3
1
2
3
4
2
x1
x3
x6
x7
x2
x5
x8
x4
Minimize:

17
S
1
2
3
4
T
4
2
3
1
2
3
4
2
x1
x3
x6
x7
x2
x5
x8
x4
Minimize: Subject to:

17
S
1
2
3
4
T
4
2
3
1
2
3
4
2
x1
x3
x6
x7
x2
x5
x8
x4
4x1 + 2x2 + 3x3 + 2x4 +
3x5 + x6 + 2x7 + 4x8

17
S
1
2
3
4
T
4
2
3
1
2
3
4
2
x1
x3
x6
x7
x2
x5
x8
x4
4x1 + 2x2 + 3x3 + 2x4 +
3x5 + x6 + 2x7 + 4x8
x1 + y1 ≥ 1
x2 + y2 ≥ 1
x3 - y1 + y3 ≥ 0
x4 - y2 + y3 ≥ 0
x5 - y2 + y4 ≥ 0
x6 - y3 + y2 ≥ 0
x7 - y3 ≥ 0
x8 - y4 ≥ 0

CS253: Network Flow (2019)

More Related Content

What's hot (20)

Similar to CS253: Network Flow (2019) (20)

More from Jinho Choi (20)

Recently uploaded (20)

CS253: Network Flow (2019)