Ford-Fulkerson

Max-flow Maximize the total amount of flow from s to t subject to two constraints Flow on edge e doesn’t exceed capacity(e) For every node v ≠ {s, t}, incoming flow is equal to outgoing flow

Ford-Fulkerson The general idea is simple while (hasAugmentingPath) { public FordFulkerson(FlowNetwork G, int s, int t) { V = G.V(); value = excess(G, t); while (hasAugmentingPath(G, s, t)) { double bottle = Double.POSITIVE_INFINITY; for (int v = t; v != s; v = edgeTo[v].other(v)) { bottle = Math.min(bottle, edgeTo[v].residualCapacityTo(v)); } edgeTo[v].addResidualFlowTo(v, bottle); value += bottle; The general idea is simple while (hasAugmentingPath) { augment the the current max flow by the minimum residual capacity on the augmenting path. }

Ford-Fulkerson The general idea is simple while (hasAugmentingPath) { public FordFulkerson(FlowNetwork G, int s, int t) { V = G.V(); value = excess(G, t); while (hasAugmentingPath(G, s, t)) { double bottle = Double.POSITIVE_INFINITY; for (int v = t; v != s; v = edgeTo[v].other(v)) { bottle = Math.min(bottle, edgeTo[v].residualCapacityTo(v)); } edgeTo[v].addResidualFlowTo(v, bottle); value += bottle; The general idea is simple while (hasAugmentingPath) { augment the the current max flow by the minimum residual capacity on the augmenting path. } To find minimum residual capacity edgeTo: backtrack trace. edgeTo[t] is the last edge on shortest residual s->t path.

Ford-Fulkerson The general idea is simple while (hasAugmentingPath) { public FordFulkerson(FlowNetwork G, int s, int t) { V = G.V(); value = excess(G, t); while (hasAugmentingPath(G, s, t)) { double bottle = Double.POSITIVE_INFINITY; for (int v = t; v != s; v = edgeTo[v].other(v)) { bottle = Math.min(bottle, edgeTo[v].residualCapacityTo(v)); } edgeTo[v].addResidualFlowTo(v, bottle); value += bottle; The general idea is simple while (hasAugmentingPath) { augment the the current max flow by the minimum residual capacity on the augmenting path. } Two remaining problems How to find augmenting path Adjust the residual graph after upating the max flow

Augmenting path Find augmenting path hasAugmentingPath ? t s B C A D Flow = 4 + 7 + 6 = 17 ? Find augmenting path s->A->t [4] s->B->C->t [7] s->D->t [6] hasAugmentingPath ? No: max-flow = 17 Yes: max-flow > 17 t s 4|4 B C A D 7|7 6|10 4|10 0|2 7|10 6|6 G while (hasAugmentingPath) { augment the the current max flow by the minimum residual capacity on the augmenting path. }

Augmenting path Find augmenting path hasAugmentingPath ? t s B C A D Flow = 4 + 7 + 6 = 17 ? Find augmenting path s->A->t [4] s->B->C->t [7] s->D->t [6] s->…->t hasAugmentingPath ? Yes: max-flow > 17 But why cannot we find it ? t s 4|4 B C A D 7|7 6|10 4|10 0|2 7|10 6|6 G while (hasAugmentingPath) { augment the the current max flow by the minimum residual capacity on the augmenting path. }

Residual graph Residual graph t s B C A D We look for augmenting path on the residual graph G’ At the same time we also update the residual graph G’ At initial time, G’== G t s 4|4 B C A D 7|7 6|10 4|10 0|2 7|10 6|6 G public FordFulkerson(FlowNetwork G, int s, int t) { V = G.V(); value = excess(G, t); while (hasAugmentingPath(G, s, t)) { double bottle = Double.POSITIVE_INFINITY; for (int v = t; v != s; v = edgeTo[v].other(v)) { bottle = Math.min(bottle, edgeTo[v].residualCapacityTo(v)); } edgeTo[v].addResidualFlowTo(v, bottle); value += bottle;

Residual graph Method addResidualFlowTo(v, bottle) t s B C A D t s B C s->A->t, bottle=4 For s->A, A->t: decrease capacity of forward edge by 4 while increase capacity of backward edge by 4 s->B->C->t, bottle=7 For s->B, B->C, c->t decrease capacity of forward edge by 7 while increase capacity of backward edge by 7 s->D->t, bottle=6 For s->D, D->t, decrease capacity of forward edge by 7 while increase capacity of backward edge by 7 t s 4|4 B C A D 7|7 6|10 4|10 0|2 7|10 6|6 G t s 4 B C A D 6 3 2 7 G’ We show both forward and backward edge here, yet you only store one edge in the implementation.

Residual graph Method addResidualFlowTo(v, bottle) t s B C A D t s B C We found a new augmenting path! Method addResidualFlowTo(v, bottle) s->D->C->B->A->t is an augmenting path, bottle=2 For s->D, D->C, B->A, A->t, decrease capacity of forward edge by 2 while increase capacity of backward edge by 2 For C->B, increase capacity of forward edge by 2 while decrease capacity of backward edge by 2 Forward edge, backward edge On the path of s->D->C->B->A->t, C->B is a backward edge, while all others are forward edges t s 4|4 B C A D 7|7 6|10 4|10 0|2 7|10 6|6 G t s 4 B C A D 6 3 2 7 G’ We show both forward and backward edge here, yet you only store one edge in the implementation.

Residual graph Method addResidualFlowTo(v, bottle) t s B C A D A s B C We found a new augmenting path! MaxFlow=17+2=19 Method addResidualFlowTo(v, bottle) s->D->C->B->A->t is an augmenting path, bottle=2 For s->D, D->C, B->A, A->t, decrease capacity of forward edge by 2 while increase capacity of backward edge by 2 For C->B, increase capacity of forward edge by 2 while decrease capacity of backward edge by 2 Forward edge, backward edge On the path of s->D->C->B->A->t, C->B is a backward edge, while all others are forward edges t s 4 B C A D 6 3 2 7 G’ A 4 6 2 2 4 5 s B C t 7 5 2 2 6 2 8 D G’ We show both forward and backward edge here, yet you only store one edge in the implementation.

Residual graph Method addResidualFlowTo(v, bottle) A t s B C A D s B C We found a new augmenting path! MaxFlow=17+2=19 Method addResidualFlowTo(v, bottle) s->D->C->B->A->t is an augmenting path, bottle=2 Understand backward edge C->B Backward edge C->B tries to `fork` the previous path S->B->C->t, thus pump extra flows into the graph A t s 4|4 B C A D 7|7 8|10 6|10 0|2 2|2 5|10 6|6 G 4 6 2 2 4 5 s B C t 7 5 2 2 6 2 8 D G’ We show both forward and backward edge here, yet you only store one edge in the implementation.

Ford-Fulkerson The general idea is simple while (hasAugmentingPath) { public FordFulkerson(FlowNetwork G, int s, int t) { V = G.V(); value = excess(G, t); while (hasAugmentingPath(G, s, t)) { double bottle = Double.POSITIVE_INFINITY; for (int v = t; v != s; v = edgeTo[v].other(v)) { bottle = Math.min(bottle, edgeTo[v].residualCapacityTo(v)); } edgeTo[v].addResidualFlowTo(v, bottle); value += bottle; The general idea is simple while (hasAugmentingPath) { augment the the current max flow by the minimum residual capacity on the augmenting path. } Two remaining problems How to find augmenting path Adjust the residual graph after upating the max flow

Ford-Fulkerson Method hasAugmentingPath(FlowNetwork G, int s, int t) t For each edge in the residual graph G’, the summation of backward and forward edges capacity equals to the capacity of the edge in G Thus we need to store only one copy, the capacity of the other could be calculated using subtraction E.g., cap(D->S)=10-cap(S->D) t s 4|4 B C A D 7|7 6|10 4|10 0|2 7|10 6|6 G t s 4 B C A D 6 3 2 7 G’ FlowEdge.java public double residualCapacityTo(int vertex) { if (vertex == v) return flow; // backward edge else if (vertex == w) return capacity - flow; // forward edge }

Ford-Fulkerson Method hasAugmentingPath(FlowNetwork G, int s, int t) t FlowNetwork.java public void addEdge(FlowEdge e) { int v = e.from(); int w = e.to(); adj[v].add(e); adj[w].add(e); E++; } Explaination: Vertex B is connected to edge B->C Vertex C is also connected to edge B->C This ensures that vertices are connected by both forward edge and backward edge t s 4|4 B C A D 7|7 6|10 4|10 0|2 7|10 6|6 G t s 4 B C A D 6 3 2 7 G’ FlowEdge e is defined to be from v to w

Ford-Fulkerson Method hasAugmentingPath(FlowNetwork G, int s, int t) t private boolean hasAugmentingPath(FlowNetwork G, int s, int t) { edgeTo = new FlowEdge[G.V()]; marked = new boolean[G.V()]; Queue<Integer> queue = new Queue<Integer>(); queue.enqueue(s); marked[s] = true; while (!queue.isEmpty() && !marked[t]) { int v = queue.dequeue(); for (FlowEdge e : G.adj(v)) { int w = e.other(v); if (e.residualCapacityTo(w) > 0) { if (!marked[w]) { edgeTo[w] = e; marked[w] = true; queue.enqueue(w); } return marked[t]; t s 4 B C A D 6 3 2 7 G’ For example, residualCapacity from B to C is 3, yet from C to B is 7 From s, we could not visit A since there is no residual Capacity

Ford-Fulkerson The general idea is simple while (hasAugmentingPath) { public FordFulkerson(FlowNetwork G, int s, int t) { V = G.V(); value = excess(G, t); while (hasAugmentingPath(G, s, t)) { double bottle = Double.POSITIVE_INFINITY; for (int v = t; v != s; v = edgeTo[v].other(v)) { bottle = Math.min(bottle, edgeTo[v].residualCapacityTo(v)); } edgeTo[v].addResidualFlowTo(v, bottle); value += bottle; The general idea is simple while (hasAugmentingPath) { augment the the current max flow by the minimum residual capacity on the augmenting path. } Two remaining problems How to find augmenting path Adjust the residual graph after upating the max flow

Ford-Fulkerson Method addResidualFlowTo(v, bottle) t s B C A D t s B C s->D->C->B->A->t is an augmenting path, bottle=2 For s->D, D->C, B->A, A->t, decrease capacity of forward edge by 2 while increase capacity of backward edge by 2 For C->B, increase capacity of forward edge by 2 while decrease capacity of backward edge by 2 Forward edge, backward edge On the path of s->D->C->B->A->t, C->B is a backward edge, while all others are forward edges Ford-Fulkerson Method addResidualFlowTo(v, bottle) t s 4 B C A D 8 6 5 2 7 t s 4 B C A D 6 3 2 7 G’ public void addResidualFlowTo(int vertex, double delta) { if (vertex == v) flow -= delta; // backward edge else if (vertex == w) flow += delta; // forward edge } Edge are defined to be from v to w