Push–relabel maximum flow algorithm

Let:

• G = (V, E) be a network with capacity function c: V × V → ${\displaystyle \mathbb {R} }$_∞,
• F = (G, c, s, t) a flow network, where s ∈ V and t ∈ V are chosen source and sink vertices respectively,
• f : V × V → ${\displaystyle \mathbb {R} }$ denote a pre-flow in F,
• x_f : V → ${\displaystyle \mathbb {R} }$ denote the excess function with respect to the flow f, defined by x_f (u) = Σ_{v ∈ V} f (v, u) − Σ_{v ∈ V} f (u, v),
• c_f : V × V → ${\displaystyle \mathbb {R} }$_∞ denote the residual capacity function with respect to the flow f, defined by c_f (e) = c(e) − f (e),
• E_f ⊂ E being the edges where f < c,

and

• G_f (V, E_f ) denote the residual network of G with respect to the flow f.

The push–relabel algorithm uses a nonnegative integer valid labeling function which makes use of distance labels, or heights, on nodes to determine which arcs should be selected for the push operation. This labeling function is denoted by 𝓁 : V → ${\displaystyle \mathbb {N} }$. This function must satisfy the following conditions in order to be considered valid:

Valid labeling:

𝓁(u) ≤ 𝓁(v) + 1 for all (u, v) ∈ E_f

Source condition:

𝓁(s) = | V |

Sink conservation:

𝓁(t) = 0

In the algorithm, the label values of s and t are fixed. 𝓁(u) is a lower bound of the unweighted distance from u to t in G_f  if t is reachable from u. If u has been disconnected from t, then 𝓁(u) − | V | is a lower bound of the unweighted distance from u to s. As a result, if a valid labeling function exists, there are no s-t paths in G_f  because no such paths can be longer than | V | − 1.

An arc (u, v) ∈ E_f  is called admissible if 𝓁(u) = 𝓁(v) + 1. The admissible network G̃_f (V, Ẽ_f ) is composed of the set of arcs e ∈ E_f  that are admissible. The admissible network is acyclic.

For a fixed flow f, a vertex v ∉ {s, t} is called active if it has positive excess with respect to f, i.e., x_f (u) > 0.

The algorithm starts by creating a residual graph, initializing the preflow values to zero and performing a set of saturating push operations on residual arcs exiting the source, (s, v) where v ∈ V \ {s}. Similarly, the labels are initialized such that the label at the source is the number of nodes in the graph, 𝓁(s) = | V |, and all other nodes are given a label of zero. Once the initialization is complete the algorithm repeatedly performs either the push or relabel operations against active nodes until no applicable operation can be performed.

The push operation applies on an admissible out-arc (u, v) of an active node u in G_f. It moves min{x_f (u), c_f (u,v)} units of flow from u to v.

push(u, v):
    assert xf[u] > 0 and 𝓁[u] == 𝓁[v] + 1
    Δ = min(xf[u], c[u][v] - f[u][v])
    f[u][v] += Δ
    f[v][u] -= Δ
    xf[u] -= Δ
    xf[v] += Δ

A push operation that causes f (u, v) to reach c(u, v) is called a saturating push since it uses up all the available capacity of the residual arc. Otherwise, all of the excess at the node is pushed across the residual arc. This is called an unsaturating or non-saturating push.

The relabel operation applies on an active node u which is neither the source nor the sink without any admissible out-arcs in G_f. It modifies 𝓁(u) to be the minimum value such that an admissible out-arc is created. Note that this always increases 𝓁(u) and never creates a steep arc, which is an arc (u, v) such that c_f (u, v) > 0, and 𝓁(u) > 𝓁(v) + 1.

relabel(u):
    assert xf[u] > 0 and 𝓁[u] <= 𝓁[v] for all v such that cf[u][v] > 0
    𝓁[u] = 1 + min(𝓁[v] for all v such that cf[u][v] > 0)

After a push or relabel operation, 𝓁 remains a valid labeling function with respect to f.

For a push operation on an admissible arc (u, v), it may add an arc (v, u) to E_f, where 𝓁(v) = 𝓁(u) − 1 ≤ 𝓁(u) + 1; it may also remove the arc (u, v) from E_f, where it effectively removes the constraint 𝓁(u) ≤ 𝓁(v) + 1.

To see that a relabel operation on node u preserves the validity of 𝓁(u), notice that this is trivially guaranteed by definition for the out-arcs of u in G_f. For the in-arcs of u in G_f, the increased 𝓁(u) can only satisfy the constraints less tightly, not violate them.

The algorithm maintains the condition that 𝓁 is a valid labeling during its execution. This can be proven true by examining the effects of the push and relabel operations on the label function 𝓁. The relabel operation increases the label value by the associated minimum plus one which will always satisfy the 𝓁(u) ≤ 𝓁(v) + 1 constraint. The push operation can send flow from u to v if 𝓁(u) = 𝓁(v) + 1. This may add (v, u) to G_f  and may delete (u, v) from G_f . The addition of (v, u) to G_f  will not affect the valid labeling since 𝓁(v) = 𝓁(u) − 1. The deletion of (u, v) from G_f  removes the corresponding constraint since the valid labeling property 𝓁(u) ≤ 𝓁(v) + 1 only applies to residual arcs in G_f .[8]

If a preflow f and a valid labeling 𝓁 for f exists then there is no augmenting path from s to t in the residual graph G_f . This can be proven by contradiction based on inequalities which arise in the labeling function when supposing that an augmenting path does exist. If the algorithm terminates, then all nodes in V \ {s, t} are not active. This means all v ∈ V \ {s, t} have no excess flow, and with no excess the preflow f obeys the flow conservation constraint and can be considered a normal flow. This flow is the maximum flow according to the max-flow min-cut theorem since there is no augmenting path from s to t.[8]

Therefore, the algorithm will return the maximum flow upon termination.

In order to bound the time complexity of the algorithm, we must analyze the number of push and relabel operations which occur within the main loop. The numbers of relabel, saturating push and nonsaturating push operations are analyzed separately.

In the algorithm, the relabel operation can be performed at most (2| V | − 1)(| V | − 2) < 2| V |² times. This is because the labeling 𝓁(u) value for any node u can never decrease, and the maximum label value is at most 2| V | − 1 for all nodes. This means the relabel operation could potentially be performed 2| V | − 1 times for all nodes V \ {s, t} (i.e. | V | − 2). This results in a bound of O(V ²) for the relabel operation.

Each saturating push on an admissible arc (u, v) removes the arc from G_f . For the arc to be reinserted into G_f  for another saturating push, v must first be relabeled, followed by a push on the arc (v, u), then u must be relabeled. In the process, 𝓁(u) increases by at least two. Therefore, there are O(V) saturating pushes on (u, v), and the total number of saturating pushes is at most 2| V || E |. This results in a time bound of O(VE) for the saturating push operations.

Bounding the number of nonsaturating pushes can be achieved via a potential argument. We use the potential function Φ = Σ_{[u ∈ V ∧ xf (u) > 0]} 𝓁(u) (i.e. Φ is the sum of the labels of all active nodes). It is obvious that Φ is 0 initially and stays nonnegative throughout the execution of the algorithm. Both relabels and saturating pushes can increase Φ. However, the value of Φ must be equal to 0 at termination since there cannot be any remaining active nodes at the end of the algorithm's execution. This means that over the execution of the algorithm, the nonsaturating pushes must make up the difference of the relabel and saturating push operations in order for Φ to terminate with a value of 0. The relabel operation can increase Φ by at most (2| V | − 1)(| V | − 2). A saturating push on (u, v) activates v if it was inactive before the push, increasing Φ by at most 2| V | − 1. Hence, the total contribution of all saturating pushes operations to Φ is at most (2| V | − 1)(2| V || E |). A nonsaturating push on (u, v) always deactivates u, but it can also activate v as in a saturating push. As a result, it decreases Φ by at least 𝓁(u) − 𝓁(v) = 1. Since relabels and saturating pushes increase Φ, the total number of nonsaturating pushes must make up the difference of (2| V | − 1)(| V | − 2) + (2| V | − 1)(2| V || E |) ≤ 4| V |²| E |. This results in a time bound of O(V ²E) for the nonsaturating push operations.

In sum, the algorithm executes O(V ²) relabels, O(VE) saturating pushes and O(V ²E) nonsaturating pushes. Data structures can be designed to pick and execute an applicable operation in O(1) time. Therefore, the time complexity of the algorithm is O(V ²E).[1][8]

The following is a sample execution of the generic push-relabel algorithm, as defined above, on the following simple network flow graph diagram.

Initial flow network graph

Final maximum flow network graph

In the example, the h and e values denote the label 𝓁 and excess x_f , respectively, of the node during the execution of the algorithm. Each residual graph in the example only contains the residual arcs with a capacity larger than zero. Each residual graph may contain multiple iterations of the perform operation loop.

Algorithm Operation(s)	Residual Graph
Initialise the residual graph by setting the preflow to values 0 and initialising the labeling.
Initial saturating push is performed across all preflow arcs out of the source, s.
Node a is relabeled in order to push its excess flow towards the sink, t. The excess at a is then pushed to b then d in two subsequent saturating pushes; which still leaves a with some excess.
Once again, a is relabeled in order to push its excess along its last remaining positive residual (i.e. push the excess back to s). The node a is then removed from the set of active nodes.
Relabel b and then push its excess to t and c.
Relabel c and then push its excess to d.
Relabel d and then push its excess to t.
This leaves the node b as the only remaining active node, but it cannot push its excess flow towards the sink. Relabel b and then push its excess towards the source, s, via the node a.
Push the last bit of excess at a back to the source, s. There are no remaining active nodes. The algorithm terminates and returns the maximum flow of the graph (as seen above).

The example (but with initial flow of 0) can be run here interactively.

The "current-arc" data structure is a mechanism for visiting the in- and out-neighbors of a node in the flow network in a static circular order. If a singly linked list of neighbors is created for a node, the data structure can be as simple as a pointer into the list that steps through the list and rewinds to the head when it runs off the end.

Based on the "current-arc" data structure, the discharge operation can be defined. A discharge operation applies on an active node and repeatedly pushes flow from the node until it becomes inactive, relabeling it as necessary to create admissible arcs in the process.

discharge(u):
    while xf[u] > 0 do
        if current-arc[u] has run off the end of neighbors[u] then
            relabel(u)
            rewind current-arc[u]
        else
            let (u, v) = current-arc[u]
            if (u, v) is admissible then
                push(u, v)
            let current-arc[u] point to the next neighbor of u

Finding the next admissible edge to push on has ${\displaystyle O(1)}$ amortized complexity. The current-arc pointer only moves to the next neighbor when the edge to the current neighbor is saturated or non-admissible, and neither of these two properties can change until the active node ${\displaystyle u}$ is relabelled. Therefore, when the pointer runs off, there are no admissible unsaturated edges and we have to relabel the active node ${\displaystyle u}$, so having moved the pointer ${\displaystyle O(V)}$ times is paid for by the ${\displaystyle O(V)}$ relabel operation.[8]

Definition of the discharge operation reduces the push–relabel algorithm to repeatedly selecting an active node to discharge. Depending on the selection rule, the algorithm exhibits different time complexities. For the sake of brevity, we ignore s and t when referring to the nodes in the following discussion.

The FIFO push–relabel algorithm[2] organizes the active nodes into a queue. The initial active nodes can be inserted in arbitrary order. The algorithm always removes the node at the front of the queue for discharging. Whenever an inactive node becomes active, it is appended to the back of the queue.

The algorithm has O(V ³) time complexity.

The relabel-to-front push–relabel algorithm[1] organizes all nodes into a linked list and maintains the invariant that the list is topologically sorted with respect to the admissible network. The algorithm scans the list from front to back and performs a discharge operation on the current node if it is active. If the node is relabeled, it is moved to the front of the list, and the scan is restarted from the front.

The algorithm also has O(V ³) time complexity.

The highest-label push–relabel algorithm[11] organizes all nodes into buckets indexed by their labels. The algorithm always selects an active node with the largest label to discharge.

The algorithm has O(V ²√E) time complexity. If the lowest-label selection rule is used instead, the time complexity becomes O(V ²E).[3]

Although in the description of the generic push–relabel algorithm above, 𝓁(u) is set to zero for each node u other than s and t at the beginning, it is preferable to perform a backward breadth-first search from t to compute exact labels.[2]

The algorithm is typically separated into two phases. Phase one computes a maximum pre-flow by discharging only active nodes whose labels are below n. Phase two converts the maximum preflow into a maximum flow by returning excess flow that cannot reach t to s. It can be shown that phase two has O(VE) time complexity regardless of the order of push and relabel operations and is therefore dominated by phase one. Alternatively, it can be implemented using flow decomposition.[9]

Heuristics are crucial to improving the empirical performance of the algorithm.[12] Two commonly used heuristics are the gap heuristic and the global relabeling heuristic.[2][13] The gap heuristic detects gaps in the labeling function. If there is a label 0 < 𝓁' < | V | for which there is no node u such that 𝓁(u) = 𝓁', then any node u with 𝓁' < 𝓁(u) < | V | has been disconnected from t and can be relabeled to (| V | + 1) immediately. The global relabeling heuristic periodically performs backward breadth-first search from t in G_f  to compute the exact labels of the nodes. Both heuristics skip unhelpful relabel operations, which are a bottleneck of the algorithm and contribute to the ineffectiveness of dynamic trees.[4]