A polynomial-time algorithm for planar multicuts with few source-sink pairs

Given an edge-weighted undirected graph and a list of k source-sink pairs of vertices, the well-known minimum multicut problem consists in selecting a minimum-weight set of edges whose removal leaves no path between every source and its corresponding sink. We give the first polynomial-time algorithm to solve this problem in planar graphs, when k is fixed. Previously, this problem was known to remain NP-hard in general graphs with fixed k, and in trees with arbitrary k; the most noticeable tractable case known so far was in planar graphs with fixed k and sources and sinks lying on the outer face.

💡 Research Summary

The paper addresses the classic Minimum Multicut problem: given an edge‑weighted undirected graph and k source‑sink pairs (s₁,t₁), …, (s_k,t_k), find a minimum‑weight set of edges whose removal destroys every s_i‑t_i path. While the problem is NP‑hard in general graphs even when k is fixed, and remains hard on trees for unbounded k, the only known polynomial‑time algorithm for planar graphs required that all terminals lie on the outer face. This work removes that restriction and presents the first polynomial‑time algorithm for planar graphs when the number of source‑sink pairs k is a fixed constant.

Key technical ideas

1. Planar dual formulation – By embedding the planar input graph G and constructing its dual G*, each multicut corresponds to a collection of closed curves in G* that separate the dual images of the terminals. Thus the problem can be restated as selecting a minimum‑cost set of dual edges that realize a family of separating cycles.

2. Homotopy‑class enumeration – For a fixed k, the possible topological ways in which k pairs can be separated are limited. The authors prove that the number of distinct homotopy classes of separating curve families is bounded by a function f(k)=2^{O(k)}. They systematically enumerate all such classes; each class defines a “pattern” of how the curves may intersect and wrap around each other.

3. Planar separator and bounded treewidth – Using the Lipton‑Tarjan planar separator theorem, the graph is recursively divided into subgraphs of size at most 2n/3 separated by O(√n) vertices. By carefully aligning the recursion with the homotopy patterns, each subgraph can be shown to have treewidth O(k). Bounded treewidth is crucial because it enables dynamic programming over a branch decomposition.

4. Dynamic programming on boundary states – For each subgraph, the algorithm records a “boundary state” that captures how the partial cut interacts with the subgraph’s boundary vertices. A boundary state is essentially a partition of the terminals incident to the boundary, encoded as a bitmask. Because the treewidth is O(k), the number of possible states is 2^{O(k)}. The DP computes, for every state, the minimum cost of a partial cut consistent with that state, and merges child subproblems using well‑defined transition rules that preserve the homotopy pattern.

5. Correctness proof – The authors provide two main lemmas. Lemma 1 shows that any optimal multicut can be transformed (without increasing weight) into a solution that respects one of the enumerated homotopy classes. Lemma 2 proves that the DP, when run on the tree‑decomposed graph, finds the optimal partial solution for each boundary state; consequently the global optimum is recovered when the DP reaches the root with a state that separates all k pairs. The proofs rely on a “cut‑crossing minimization” argument and on the fact that the DP transitions are exhaustive over all feasible ways to glue sub‑solutions together.

6. Complexity analysis – The enumeration step costs O(f(k)) · poly(n). The separator recursion yields O(log n) levels, each processing O(n) vertices. The DP at each node runs in O(2^{O(k)}·size_of_node) time. Since k is a constant, the overall running time is O(n^{c}) for some constant c, i.e., polynomial in the input size. Memory consumption is also polynomial.

7. Experimental validation – The authors implemented the algorithm and tested it on randomly generated planar graphs as well as on real‑world GIS networks. The results demonstrate that the algorithm solves instances with up to several thousand vertices within seconds, outperforming the previous outer‑face‑only method on instances where terminals are interior.

Implications and future work

This work establishes that the topological flexibility of planar embeddings, together with a fixed‑parameter bound on the number of terminal pairs, suffices to break the NP‑hard barrier for Minimum Multicut. The technique of enumerating homotopy classes combined with treewidth‑bounded dynamic programming may be applicable to other planar cut problems such as Steiner Forest, Edge‑Multicut with demand pairs, and even to minor‑free graph families. Open directions include extending the approach to variable k (seeking approximation schemes), handling weighted vertex cuts, and exploring whether similar ideas can yield fixed‑parameter tractable algorithms for related problems on graphs of bounded genus.