Topic E: Max Flow

---

• Section 1: The Max Flow Problem
• Section 2: Ford Fulkerson
• Section 3: Correctness and Min Cut
• Section 4: Implementing Ford-Fulkerson and Running Time
• Section 5: Reductions and Applications

---

Section 1: The Max Flow Problem

This section introduces the max flow problem.

Objectives. After learning this material, you should be able to:

• State the format of an input to the max flow problem.
• Define when a function is a valid flow in the graph.
• Define the amount of flow and the max flow.

Motivation and input

We have already looked at finding paths in a graph. What if we want to route a large amount of traffic across a graph, such as packets across a computer network? In this case, the traffic may need to take multiple routes at once. Each edge of the network can only handle so much traffic at once -- the capacity of that edge. We'd like to figure out how to route the traffic so as to get the most possible across.

In the max flow problem, the input consists of:

• A directed graph $G = (V,E)$,
• a source $s \in V$ and sink $t \in V$, and
• a capacity function $c: E \to \mathbb{R}_{\geq 0}$.

We can also think of the capacity function as nonnegative edge weights. We extend $c$ to be a function on all pairs of vertices, by defining $c(u,v) = 0$ if $(u,v) \not\in E$. We will also make the following simplifying assumption, which isn't necessary, but makes our lives a bit easier:

Assumption: no anti-parallel edges. We assume that if $(u,v) \in E$, then $(v,u) \not\in E$. In other words, there is only one edge between any pair of vertices.

Valid flows

Given the input, a potential solution is any method of routing flow from $s$ to $t$. But what does that mean, exactly? A function $f: V \times V \to \mathbb{R}_{\geq 0}$ is called a flow, and the flow is valid if:

• (capacity constraint) $f(u,v) \leq c(u,v)$ for all $u,v \in V$. This implies that if there is no edge $(u,v)$, then $f(u,v) = 0$.
• (flow constraint) for all vertices $v \not\in \{s,t\}$, $\sum_{u \in V} f(u,v) = \sum_{w \in V} f(v,w)$.

We illustrate the current flow compared to the capacity of the edge using the notation "flow/capacity", e.g. 6/10.

Max flow

Given a flow $f$, we define the amount of flow, written $|f|$ for short, to be the following quantity:

$|f| = \sum_{v \in V} f(v,t) - \sum_{w \in V} f(t,w)$.

In other words, the total amount of flow $|f|$ is the net flow into the sink $t$.

In the max flow problem, the output is:

• A valid flow $f$ whose amount is maximized, over all possible valid flows.

---

Section 2: Ford-Fulkerson

This section describes the Ford Fulkerson framework for solving max flow.

Objectives. After learning this material, you should be able to:

• Given a flow $f$, construct the residual graph $G_f$ and residual capacity $r_f$.
• Find an augmenting path and use it to augment $f$.
• Use the above steps to run the Ford Fulkerson framework on examples.

Breaking and fixing the natural approach

Here's a very natural algorithm that almost works:

• Find a path from $s$ to $t$.
• Send as much flow along that path as possible.
• Repeat until impossible.

Unfortunately, this doesn't always work to find the max flow! We need the ability to "cancel" use of an edge and backtrack on some decisions. Luckily, it turns out that we can achieve this by pretending to send flow "backward" along that edge, which has the effect of cancelling out the forward flow. Here's an example:

We first send 5 units of flow along the path $s,y,x,t$. This results in the following flow.

Now, we are stuck, because there is no path from $s$ to $t$ along which we can send more flow. But we have not found the max flow yet. The way out is to send 3 units of flow along the path $s,x,y,t$. Even though $(x,y)$ is not an edge in the graph, we can "send" flow along this edge by reducing the current amount of flow.

Another way to think of what happened is that we took 3 units of flow along $(y,x)$ and re-routed it to $(y,t)$. To replace that 3 units of flow at $x$, we brought over 3 units of flow along $(s,x)$.

This idea leads to the Ford-Fulkerson framework for max-flow algorithms. First, we need to make some useful definitions in order to fully define the algorithm.

Residual capacity function and residual graph

The residual capacity function $r_f: V \times V \to \mathbb{R}_+$ is defined as follows:

• If $(u,v) \in E$, then $r_f(u,v) = c(u,v) - f(u,v)$. This is the amount by which we could increase the flow along this edge without breaking the capacity.
• Otherwise, if the reverse edge $(v,u) \in E$, then $r_f(u,v) = f(v,u)$. We can "increase" the flow from $u$ to $v$ by decreasing the flow from $v$ to $u$. The current flow is $f(v,u)$, so that is how much we can decrease it.
• If neither $(u,v)$ nor $(v,u)$ is an edge, then $r_f(u,v) = 0$.

The residual graph $G_f = (V, E_f)$ is a graph where there is an edge $(u,v) \in E_f$ if $r_f(u,v) > 0$, otherwise $(u,v) \not\in E_f$. It is important that if $r_f(u,v) = 0$, then the edge $(u,v)$ is NOT in $E_f$. We will draw $r_f$ as edge weights on $G_f$, and we'll sometimes refer to both together as the "residual graph".

We can describe these operations more formally as follows.

1  residuals(G, c, f):
2      // G = (V,E) is a directed graph, c is a capacity function, f is a flow
3      let Ef be an empty set
4      for each edge (u,v) in G:
5          set rf(u,v) = c(u,v) - f(u,v)
6          if rf(u,v) > 0:
7              add (u,v) to Ef
8          set rf(v,u) = f(u,v)
9          if rf(v,u) > 0:
10             add (v,u) to Ef
11     return rf, (V,Ef)

Notice the differences between which edges are present in the residual graph, compared to the original graph:

• Even if there is an edge such as $(s,y)$ in the original graph, it may not be present in the residual graph. This happens when flow equals capacity.
• Even if an edge such as $(y,s)$ does not exist in the original graph, it may be present in the residual graph. This happens when the reverse direction $(s,y)$ has flow.
• Even though the original graph has no antiparallel edges, the residual graph can have antiparallel edges such as $(x,y)$ and $(y,x)$. This happens when the flow is greater than zero but less than capacity.

Augmenting paths

The last concept we need is an augmenting path: a path $s=v_1,\dots,v_k=t$ from $s$ to $t$ in the residual graph. Note that because this is a path in the residual graph, we have that $r_f(v_i, v_{i+1}) > 0$ for every edge along this path. In other words, we can send more flow along every edge in this path.

// Subroutine 1: Augment a flow along a path
1  augment(G, f, rf, path):
2      // G is the input graph, f is a flow, rf is residual flow
3      // path goes from s to t in the residual graph
4      let d = min( rf(u,v) for (u,v) in path )
5      for each edge (u,v) in path:
6          if (u,v) in G:
7              f(u,v) += d
8          else:              // here, (v,u) must be in G
9              f(v,u) -= d
10     return f and d

Ford-Fulkerson Framework

The Ford-Fulkerson Framework is the following algorithmic framework:

// Algorithmic Framework 1: Ford-Fulkerson
1  fordfulkerson(G, c):
2      // G is a directed graph, c is a capacity function
3      let f(u,v) = 0 for all vertex pairs u,v
4      repeat:
5          let Gf and rf = residuals(G, c, f)
6          find a path from s to t in Gf
7          let f and d = augment(G, f, rf, path)
8          if d == 0:
9              return f

Notice that line 6, where we find a path, is underspecified. How do we choose the path? There turn out to be several reasonable choices for this step. Because of this, Ford-Fulkerson is called a framework rather than an algorithm. To make it an algorithm, we need to specify how to implement line 6.

---

Section 3: Correctness and Min Cut

This section proves Ford Fulkerson correct using the concept of the min $s-t$ cut.

Objectives. After learning this material, you should be able to:

• Define an $s-t$ cut $(S,T)$ in the graph and find the value of the cut.
• Explain why Ford Fulkerson stops when it find both a max flow and a min cut.
• Use Ford Fulkerson to find a min $s-t$ cut in the graph.

Min cut

To prove that Ford Fulkerson is correct, we'll need a non-obvious, very mathematically nice strategy. The idea is that the maximum flow is limited by bottlenecks in the graph, where no more flow can squeeze through. If there is a bottleneck where the total capacity to squeeze through is 10, then the max the flow could possibly be is 10. The tricky part is that a bottleneck could contain multiple edges.

A $s-t$ cut in a directed graph $G = (V,E)$ is a partition of the vertices into two sets, $S$ and $T$, such that $s \in S$ and $t \in T$.

Given a capacity function $c$, the capacity of an $s-t$ cut $(S,T)$ is the total capacity of edges that cross from $S$ to $T$, which is

\[ K(S,T) = \sum_{u \in S, v \in T} c(u,v) . \]

Here, we only sum over pairs $(u,v) \in E$ such that $u \in S, v \in T$. Meanwhile, given a flow $f$, the flow across an $s-t$ cut $(S,T)$ is the total net flow from $S$ to $T$, which is

\[ F(S,T) = \sum_{u \in S, v \in T} (f(u,v) - f(v,u)) . \]

The Min $s-t$ Cut problem is, given an input graph to max flow, to find the $s-t$ cut that minimizes $K(S,T)$. This will turn out to be highly related to the max flow problem.

It turns out that the flow across the cut is the same for any $s-t$ cut we choose! It's just the amount of flow.

But we also know that flow across the cut is upper-bounded by the capacity of the cut.

Now we can prove that Ford-Fulkerson is correct.

This corollary follows because FF only halts if there is no path from $s$ to $t$ in the residual graph.

The corollary follows because Ford-Fulkerson, assuming it halts, finds a max flow that equals a min cut, every time.

Using Ford-Fulkerson to find a min cut

Knowing what we now know, finding a min cut in a graph is straightforward:

1. Use a Ford-Fulkerson algorithm to find a maximum flow $f$.
2. Let $G_f$ be the residual graph.
3. Let $S = $ the set of vertices reachable from $s$ in $G_f$; we can use e.g. BFS to find this set. Let $T = V \setminus S$.
4. Return $(S,T)$.

To recap, we know that $(S,T)$ is a min cut because for every edge from $S$ to $T$, the flow equals the capacity, and there are no reverse edges with flow (otherwise $T$ would be reachable), so $F(S,T) = K(S,T)$.

---

Section 4: Implementing Ford-Fulkerson and Running Time

This section discusses an implementation of Ford-Fulkerson called Edmonds-Karp and analyzes its running time.

Objectives. After learning this material, you should be able to:

• Implement the Edmonds-Karp algorithm on examples.
• Identify the time complexity of Edmonds-Karp.

Using Breadth-First Search

The part of Ford-Fulkerson that is not fully specified is how to choose a path from $s$ to $t$ in the residual graph, $G_f$. We will simply use BFS. The resulting algorithm is called Edmonds-Karp.

// Algorithm 1: Edmonds-Karp
1  edmondskarp(G, c):
2      // G is a directed graph, c is a capacity function
3      let f(u,v) = 0 for all vertex pairs u,v
4      repeat:
5          let Gf and rf = residuals(G, c, f)
6          "color: purple;">use BFS to find a path from s to t in Gf
7          let f and d = augment(G, f, rf, path)
8          if d == 0:
9              return f

Because Edmonds-Karp is in the Ford-Fulkerson framework, we know that it is correct as long as it halts. We will show that it halts and give a bound on the number of time steps. The proof is "bonus material".

Proof (optional).

In a round of Edmonds-Karp, an edge is called critical if we augment along a path containing that edge, and the residual capacity is equal to the augmentation amount. In other words, that edge has the minimum residual capacity of any edge along the path.

Note that a critical edge is present in $G_f$ in the current round, but disappears in the next round, because the edge's capacity is fully saturated.

First, we show that in each round, a vertex's distance from $s$ in the residual graph $G_f$ can only increase. (This is the unweighted distance, i.e. number of hops.) To see this, consider the change in the residual graph. When we augment along a path $s=v_1,\dots,v_k=t$, we may add new reverse edges of the form $(v_j, v_{j-1})$ to $G_f$, and we remove forward edges if they are critical edges. Because $v_1,\dots,v_k$ is a shortest path from $s$, adding reverse edges cannot make any paths shorter, since we would never go through $v_{j+1}$ to get to $v_j$. And eliminating edges cannot make any paths shorter.

Next, we show that each edge $(u,v)$ can only be critical in at most $n/2$ iterations. When an edge is critical, it is removed from the residual graph by augmenting. To become critical again, it must be added back into the flow graph by augmenting along the reverse direction, $(v,u)$. But that implies the distance from $s$ to $u$ has increased by at least $2$, since it was strictly less than the distance to $v$, and now it's strictly more, and the distance to $v$ has not decreased. Since the distance begins at zero or more, and ends at $n$ or less, and increases by at least $2$ each round, the total number of times the edge is critical is at most $n/2$.

Finally, we put the pieces together. There are up to $2m$ potential edges in the residual graph: each edge in the original graph, and its reverse. Each can be critical at most $n/2$ times, and every round there is at least one critical edge, so there are at most $(2m)(n/2) = mn$ iterations. In each iteration, we do a constant amount of work and run BFS, which takes $O(m + n)$ time. We can assume that $m \geq n-1$ here, as the graph can be assumed to be connected, so the running time of BFS is $O(m)$. Putting it all together, we have a running time of $O((mn)(m)) = O(n m^2)$.

---

Section 5: Reductions and Applications

This section discusses how we can solve other problems by turning them into max-flow problems.

Objectives. After learning this material, you should be able to:

• Construct reductions from related problems or variants to max flow.
• Identify failures of incorrect reductions.

Variants of max flow

First, we will look at other versions of the max flow problem. It would be nice if we didn't have to come up with a new algorithm every time we changed the problem slightly! As we will see, often we can solve a slightly different problem by "reducing" it to max flow.

Antiparallel edges

A pair of antiparallel edges are $(u,v)$ and $(v,u)$, i.e. two directed edges between two vertices pointing opposite directions. Remember that we solved max flow assuming that the input graph contains no antiparallel edges. Actually, one can modify our solution to account for antiparallel edges, but here is a method using a reduction.

• We take as input a flow instance $G_1, c_1$ that may contain antiparallel edges.
• We use it to construct a new flow instance $G_2, c_2$ that does not contain any antiparallel edges.
• We run our max flow algorithm, such as Edmonds Karp, on $G_2, c_2$. It produces some output flow $f_2$.
• We use $f_2$ to construct a solution $f_1$ for the original instance.

Here's how we construct $G_2$ and $c_2$.

• $G_2$ will contain all of the vertices of $G_1$, plus more vertices defined below.
• For every edge $(u,v)$ in $G_1$, we can create a new vertex, call it $w_{u,v}$. Note that $w_{u,v}$ is different from $w_{v,u}$.
• Then, we create two new edges: $(u, w_{u,v})$ and $(w_{u,v},v)$.
• We make the capacity of these new edges equal to the old capacity, i.e. $c_2(u, w_{u,v}) = c_2(w_{u,v},v) = c_1(u,v)$.

Now, we need to explain how to convert $f_2$ into $f_1$.

• For each vertex of the form $w_{u,v}$, we let $f_1(u,v) = f_2(u,w_{u,v})$. Note by the net flow constraint, this equals $f_2(w_{u,v},v)$.
• This defines the flow on every edge of the original graph $G_1$.

Multiple sources and sinks

Suppose we have a max flow problem, but there are multiple possible sources of flow and multiple possible sinks. The new goal is to maximize the total flow into all of the sinks. The constraints on a flow are the same, except that now the net flow constraint does not apply to any of the sources or sinks.