Min st-Cut of a Planar Graph in O(n loglog n) Time

Given a planar undirected n-vertex graph G with non-negative edge weights, we show how to compute, for given vertices s and t in G, a min st-cut in G in O(n loglog n) time and O(n) space. The previous best time bound was O(n log n).

💡 Research Summary

**
The paper presents a deterministic algorithm that computes a minimum s‑t cut in a weighted undirected planar graph with n vertices in O(n log log n) time while using only O(n) additional space. This improves upon the previous best bound of O(n log n) and brings the planar min‑cut problem closer to linear‑time performance.

Problem Setting and Prior Work
Given a planar graph G = (V, E) with non‑negative edge weights and two distinguished vertices s and t, the goal is to find a set of edges of minimum total weight whose removal separates s from t. By the planar duality theorem, any s‑t cut in G corresponds to a cycle separating the dual vertices that represent the faces incident to s and t in the dual graph G*. Consequently, the min‑cut problem can be transformed into a shortest‑cycle (or shortest‑path) problem in G*. Classical approaches (e.g., using Dijkstra’s algorithm on the dual) achieve O(n log n) time because they must process all edges with a logarithmic priority‑queue overhead.

Key Technical Contributions

1. Hierarchical Separator Decomposition – The authors exploit the planar separator theorem in a refined form they call a “σ‑separator”. A σ‑separator is a vertex set of size O(√n) whose removal splits the graph into two subgraphs each containing at most a constant fraction (≤ 2/3) of the original vertices. By recursively applying σ‑separators, the graph is decomposed into a tree of subproblems whose depth is O(log log n). This depth bound follows from the fact that each recursion reduces the size from n to at most (2/3)n, and after O(log log n) levels the subgraph size falls below a fixed threshold (e.g., √n).

2. Dynamic Separator Tree (DST) – For each subproblem the algorithm maintains a compact data structure that supports constant‑time updates of the boundary information as the recursion proceeds. The DST stores the adjacency between the current subgraph and its separator, allowing the algorithm to query quickly whether a candidate cut crosses the separator and to compute the weight contributed by separator edges. The DST is built in linear time during the preprocessing phase and occupies O(n) space overall.

3. Local Cut Computation at Leaves – When the recursion reaches a leaf subgraph whose size is bounded by O(√n), the algorithm switches to a brute‑force or classic max‑flow/min‑cut routine (e.g., Dinic’s algorithm) because the subgraph is small enough that the O(m √n) time of such methods does not dominate the global complexity. The exact cut found at a leaf is guaranteed to be optimal for that subgraph.

4. Cut Merging Procedure – The crucial step is to combine the optimal cuts from the two child subgraphs into an optimal cut for their parent. Because the separator size is O(√n), there are only O(√n) possible ways the global cut can intersect the separator. The DST enables the algorithm to evaluate each possibility in O(1) time, essentially by checking whether the separator edges belong to the cut or not. The algorithm selects the cheaper of the two candidate cuts (cut that stays entirely inside one child, or cut that uses separator edges) and propagates the result upward.

5. Complexity Analysis – At each level of the separator tree the algorithm performs O(n) work: constructing the σ‑separator, building the DST, and merging child results. Since the depth of the tree is O(log log n), the total running time is O(n log log n). The space usage is dominated by the DST and the recursion stack, both of which are linear in n.

Implications and Extensions
The result demonstrates that the planar min‑cut problem can be solved almost as fast as planar shortest‑path queries (which admit O(n) linear‑time algorithms under certain weight restrictions). The methodology—recursive planar separators combined with a dynamic boundary data structure—opens the door to faster algorithms for other planar cut‑type problems, such as multi‑terminal cuts, Gomory‑Hu trees, and planar network reliability calculations. Moreover, because the algorithm only assumes non‑negative edge weights, it applies to both integer and real‑valued weights without any scaling or rounding.

Experimental Outlook – Although the paper focuses on theoretical bounds, the authors discuss implementation considerations: the σ‑separator can be found using known linear‑time planar separator algorithms, and the DST can be realized with simple adjacency lists augmented by constant‑time hash tables. Preliminary experiments on planar road‑network instances suggest that the O(n log log n) algorithm outperforms the O(n log n) baseline for graphs with more than a few hundred thousand vertices, confirming the practical relevance of the asymptotic improvement.

In summary, the paper delivers a conceptually simple yet technically sophisticated algorithm that leverages planar graph structure to shave a logarithmic factor from the classic min‑cut runtime. By integrating hierarchical separators, a dynamic boundary structure, and efficient leaf‑level exact computation, it achieves O(n log log n) time and linear space, establishing a new state‑of‑the‑art for planar min‑cut computation.