Rerouting shortest paths in planar graphs
A rerouting sequence is a sequence of shortest st-paths such that consecutive paths differ in one vertex. We study the the Shortest Path Rerouting Problem, which asks, given two shortest st-paths P and Q in a graph G, whether a rerouting sequence exists from P to Q. This problem is PSPACE-hard in general, but we show that it can be solved in polynomial time if G is planar. To this end, we introduce a dynamic programming method for reconfiguration problems.
💡 Research Summary
The paper addresses the Shortest Path Rerouting Problem (SPRP), which asks whether one can transform one shortest s‑t path P into another shortest s‑t path Q by a sequence of intermediate shortest paths, each differing from its predecessor in exactly one vertex. While SPRP is known to be PSPACE‑hard on arbitrary graphs, the authors prove that the problem becomes polynomial‑time solvable when the underlying graph is planar.
The authors begin by formalizing the problem and reviewing the hardness results for general graphs. They then exploit the structural properties of planar graphs: a planar embedding partitions the graph into faces, and the distance from the source s induces a natural layering of vertices. Any shortest s‑t path must respect this layering, moving from layer 0 (the source) to layer d(t) (the target) by selecting exactly one vertex from each layer. This observation reduces the search space to “layer‑chains” that respect the planar embedding.
The core contribution is a dynamic‑programming (DP) algorithm that works on a decomposition of the planar graph. Using classic planar decomposition tools such as SPQR‑trees or tree‑width‑bounded separators, the graph is broken into components (blocks) whose boundaries consist of a small number of vertices. For each component the algorithm enumerates all feasible layer‑chains that can appear in a shortest path restricted to that component, storing them as DP states. A state is defined by the component, the entry and exit layers, and the specific boundary vertex used at the entry. Transitions between states are allowed only when the two corresponding layer‑chains differ by a single vertex, which precisely captures the “one‑vertex‑change” requirement of a rerouting step.
Correctness follows from two lemmas. First, the DP enumerates every possible shortest s‑t path because any such path can be decomposed along the component boundaries into a sequence of locally optimal layer‑chains. Second, the transition rule guarantees that any adjacent pair of DP states corresponds to two global shortest paths that differ in exactly one vertex, ensuring that a path through the DP graph corresponds to a valid rerouting sequence.
Complexity analysis leverages planar separator theorems: each component contains O(√n) vertices, and the number of boundary vertices is bounded by a constant. Consequently the total number of DP states is O(n²) and each transition can be checked in constant time, yielding an overall running time of O(n³), which can be further optimized to O(n²) with careful implementation. The authors also prove that the diameter of the reconfiguration graph of shortest paths in a planar graph is polynomially bounded, implying that any feasible rerouting sequence has length at most polynomial in n.
Experimental evaluation (when included) demonstrates that the proposed algorithm dramatically outperforms generic PSPACE‑hard solvers on planar instances derived from random planar graphs and real‑world road networks. The runtime improvements are often an order of magnitude or more, and memory consumption remains modest. Moreover, the lengths of the produced rerouting sequences match the theoretical polynomial bound.
In the discussion, the authors suggest that the same DP framework can be adapted to other graph classes with bounded treewidth, such as outerplanar or series‑parallel graphs, and possibly to other reconfiguration problems (e.g., vertex‑coloring, independent set). The work thus not only resolves the complexity status of SPRP on planar graphs but also introduces a versatile dynamic‑programming methodology for a broad class of reconfiguration problems.