Multiple-Source Multiple-Sink Maximum Flow in Directed Planar Graphs in Near-Linear Time

We give an O(n log^3 n) algorithm that, given an n-node directed planar graph with arc capacities, a set of source nodes, and a set of sink nodes, finds a maximum flow from the sources to the sinks. Previously, the fastest algorithms known for this problem were those for general graphs.

💡 Research Summary

The paper addresses the classic maximum‑flow problem in directed planar graphs when there are multiple sources and multiple sinks. While single‑source single‑sink planar max‑flow has been studied for decades and can be solved in near‑linear time, the multi‑source multi‑sink variant remained open: the only known approaches reduced the problem to a single‑source single‑sink instance by adding a super‑source and a super‑sink, which destroys planarity and leads to algorithms with O(n² log n) or O(n¹·⁵ log n log U) running times.

The authors present the first planar‑specific algorithm that solves the problem in O(n log³ n) time, where n is the number of vertices. This matches the best known bounds for single‑source single‑sink planar flow up to a polylogarithmic factor and dramatically improves over the general‑graph reductions. The main theorem states: Given an n‑vertex directed planar graph with arc capacities, a set S of source vertices, and a set T of sink vertices, a maximum feasible flow from S to T can be computed in O(n log³ n) time.

Algorithmic framework
The algorithm follows a recursive divide‑and‑conquer scheme based on a simple cycle separator C of size O(√n). The separator is obtained using the Miller‑Tamassia‑Vishkin cycle‑separator theorem. All edges of C except one are contracted, turning the whole cycle into a self‑loop attached to a single “super‑node” v. The graph is thereby split into two subgraphs: the interior G₁ and the exterior G₂ of the loop.

Each recursive call solves a slightly more general problem: besides the original sources S and sinks T, a constant‑size set A (|A| ≤ 6) of auxiliary vertices is also treated as sources and sinks. This allows the separator vertices to act as temporary terminals without blowing up the recursion depth. The recursion proceeds until the subgraphs become small enough that a direct planar max‑flow routine can be applied.

After the two recursive calls return pseudo‑flows (flows that respect capacities but may violate conservation at the separator vertices), the algorithm “uncontracts” the separator and performs three post‑processing phases:

1. FixConservationOnPath – The separator C is viewed as a path P (C minus one edge). Using a specialized Dijkstra implementation due to Fakcharoenphol and Rao, the algorithm pushes flow along P so that no vertex on P with positive excess can reach any vertex with negative excess via a residual path. This eliminates residual source‑to‑separator and separator‑to‑sink paths while preserving the overall flow value.

2. CycleToSingleSinkLimitedMaxFlow / SingleSourceToCycleLimitedMaxFlow – For each auxiliary vertex aᵢ ∈ A, the algorithm first pushes as much excess from the positive‑excess part of C to aᵢ, then pushes as much deficit from aᵢ back to the negative‑excess part of C. These subroutines are limited‑capacity max‑flow computations that respect the current pseudo‑flow and use the same dense‑distance‑graph Dijkstra machinery. Because |A| is constant, the total cost of these steps is O(n log² n).

3. Final redistribution – Any remaining excess on C is sent back to the original sources S, and any remaining deficit is supplied from the original sinks T. At this point there is no residual path from any source to any sink in the whole graph.

The resulting pseudo‑flow is then converted into a feasible maximum flow in linear time by first canceling flow cycles (using the technique of Kaplan and Nussbaum) and then sending the remaining excess/deficit along a topological order.

Key technical ingredients

• Pseudo‑flow representation – The algorithm never stores the full flow on every arc; it only tracks excess at a small set of vertices and maintains a compact representation of the residual capacities. This dramatically reduces the amount of work per recursion level.

• Dual‑primal relationship – By exploiting the correspondence between circulations in the primal graph and shortest paths in the dual, the algorithm can update flows implicitly via shortest‑path queries.

• Monge matrix range queries – The vertices on the separator are cyclically ordered, which gives the distance matrix a Monge property. A data structure for range minimum queries in Monge matrices enables O(log n) updates of the “potential” values used in the limited max‑flow subroutines.

• Fakcharoenphol‑Rao dense‑distance Dijkstra – The algorithm repeatedly needs shortest‑path distances in subgraphs induced by the separator. The dense‑distance‑graph technique precomputes distances between boundary vertices and answers queries in near‑linear time, which is essential for achieving the O(n log³ n) bound.

• Cycle separator with weighted vertices – To keep the auxiliary set A small, the algorithm alternates between uniform vertex weights and weights concentrated on A when selecting the separator, a trick borrowed from previous planar flow work.

Complexity analysis
Each recursion level processes O(n) vertices, and the dominant operations (FixConservationOnPath and the two limited‑flow subroutines) each run in O(n log² n / log log n + |C|² log² n) time. Since |C| = O(√n), the term |C|² log² n = O(n log² n). Thus a single level costs O(n log² n). The recursion depth is O(log n) because the separator halves the number of vertices each time. Multiplying yields the overall O(n log³ n) running time. The space usage is linear in n, dominated by the planar embedding, the dense‑distance structures, and the pseudo‑flow bookkeeping.

Applications
The authors highlight two important domains:

• Computer vision – Many energy minimization problems (image restoration, segmentation, stereo, motion) can be expressed as a multi‑source multi‑sink min‑cut on a planar pixel grid. Since the underlying graph is planar, the new algorithm provides a theoretical near‑linear‑time solution, improving over the O(n log n) or O(n log³⁄² n) heuristics previously used.

• Planar bipartite matching – Maximum bipartite matching in a planar graph reduces to a multi‑source multi‑sink flow problem. The presented algorithm therefore yields the first near‑linear‑time planar‑specific matching algorithm.

Conclusion
The paper delivers a sophisticated blend of classic planar‑graph techniques (cycle separators, duality) with modern data structures (dense‑distance Dijkstra, Monge range queries) to solve a long‑standing open problem. By keeping the number of “boundary” vertices constant and handling excess/deficit via pseudo‑flows, the authors avoid the quadratic blow‑up that plagued earlier reductions. The result is an O(n log³ n) algorithm that is both theoretically optimal up to polylogarithmic factors and practically relevant for vision and matching tasks on planar networks.