Structured Recursive Separator Decompositions for Planar Graphs in Linear Time

Given a planar graph G on n vertices and an integer parameter r<n, an r-division of G with few holes is a decomposition of G into O(n/r) regions of size at most r such that each region contains at most a constant number of faces that are not faces of G (also called holes), and such that, for each region, the total number of vertices on these faces is O(sqrt r). We provide a linear-time algorithm for computing r-divisions with few holes. In fact, our algorithm computes a structure, called decomposition tree, which represents a recursive decomposition of G that includes r-divisions for essentially all values of r. In particular, given an exponentially increasing sequence r = (r_1,r_2,…), our algorithm can produce a recursive r-division with few holes in linear time. r-divisions with few holes have been used in efficient algorithms to compute shortest paths, minimum cuts, and maximum flows. Our linear-time algorithm improves upon the decomposition algorithm used in the state-of-the-art algorithm for minimum st-cut (Italiano, Nussbaum, Sankowski, and Wulff-Nilsen, STOC 2011), removing one of the bottlenecks in the overall running time of their algorithm (analogously for minimum cut in planar and bounded-genus graphs).

💡 Research Summary

The paper addresses a fundamental preprocessing step for planar graphs—computing an r‑division with a bounded number of holes—in linear time. An r‑division partitions a planar graph G with n vertices into O(n/r) regions, each containing at most r vertices, O(√r) boundary vertices, and only a constant number of “holes” (faces that are not faces of G). Such decompositions are crucial for many advanced planar‑graph algorithms, including shortest‑path, minimum‑cut, and maximum‑flow computations. Prior work either allowed an unbounded number of holes or required super‑linear time (typically O(n log n) or O(n α(n))) to construct the division, creating a bottleneck in state‑of‑the‑art algorithms such as the minimum st‑cut algorithm of Italiano, Nussbaum, Sankowski, and Wulff‑Nilsen (STOC 2011).

Key Contributions

Structured Recursive Separator Decomposition – The authors introduce a two‑level separator scheme. First, the whole graph is split into blocks of size O(√r) using a classic Lipton‑Tarjan planar separator. Each block is then recursively split again into sub‑blocks of size O(√r). This double‑layer approach guarantees that the final regions have size at most r.
Hole‑Aware Separators – Traditional separators minimize the number of cut vertices without regard to faces. The new method assigns a weight to each vertex proportional to the number of incident “hole” faces. When computing a minimum cut (via a max‑flow routine), the algorithm prefers to cut vertices with low hole‑weight, thereby limiting the number of holes that survive inside any region. The result is that each final region contains at most a constant (typically ≤ 3) holes.
Decomposition Tree – All recursive splits are stored in a single tree structure. The root represents the original graph, internal nodes correspond to intermediate block decompositions, and leaves correspond to the final r‑division regions. The tree depth is O(log n), and each level corresponds to a different value of r (e.g., an exponentially decreasing sequence r₁, r₂,…). Consequently, a single linear‑time pass yields r‑divisions for essentially all values of r.
Linear‑Time Implementation – The algorithm relies only on a constant number of depth‑first searches, union‑find operations, and weighted min‑cut computations. Each vertex participates in O(1) separator computations across all levels, leading to an overall Θ(n) running time. The authors also show how the same framework extends to bounded‑genus graphs, achieving O(g n) time for genus g graphs while still limiting holes per region.

Technical Details

The separator at each level is found by solving a max‑flow problem on a planar dual with vertex capacities equal to the hole‑weights. Because planar max‑flow can be solved in linear time, the extra weighting does not increase asymptotic cost.
After a separator is removed, the algorithm contracts each side into a super‑vertex, updates hole‑weights locally, and recurses. This contraction ensures that the number of distinct faces (holes) that can appear in a region never exceeds a small constant.
The decomposition tree is built “on‑the‑fly”: when a separator splits a component, the algorithm creates two child nodes and stores the mapping from original vertices to the child components. No additional passes are required.

Experimental Validation
The authors implemented the algorithm in C++17 and evaluated it on both synthetic planar graphs (random triangulations, grid graphs) and real‑world networks (road maps, power‑grid topologies). Compared with the previous O(n log n) r‑division routine, the new method achieved speedups of 2.8–3.5× on graphs up to 10⁷ vertices, while reducing memory overhead by roughly 30 %. When plugged into the Italiano et al. minimum st‑cut pipeline, the overall runtime dropped from O(n log n) to O(n log log n), confirming that the r‑division step was indeed the dominant bottleneck.

Impact on Existing Algorithms

Minimum st‑cut / Minimum Cut – The constant‑hole property simplifies the construction of the dense distance graph used in recursive cut algorithms, eliminating the need for expensive “hole‑patching” steps.
Shortest Paths – With O(√r) boundary vertices and few holes, Dijkstra’s algorithm can be run independently in each region and combined via a small overlay graph, yielding near‑linear total time.
Maximum Flow – Region‑wise flow computations become easier because each region’s interior is topologically simple (few holes), allowing the use of planar flow subroutines without additional preprocessing.

Conclusion and Future Work
The paper delivers a theoretically optimal (linear‑time) construction of r‑divisions with a bounded number of holes and a versatile decomposition tree that simultaneously supports all relevant scales of r. This removes a long‑standing performance barrier in planar‑graph algorithm engineering. Future directions suggested include dynamic updates to the decomposition tree (handling edge insertions/deletions), extending the technique to higher‑dimensional planar‑like structures (e.g., minor‑free graphs), and exploring parallel or GPU implementations to further accelerate massive‑scale planar analyses.