Logo
ScienceStack
Table of Contents
Fetching ...
Sign In

SPHERE: Spherical partitioning for large-scale routing optimization

Robert Fabian Lindermann, Paul-Niklas Ken Kandora, Simon Caspar Zeller, Adrian Asmund Fessler, Steffen Rebennack

TL;DR

SPHERE addresses scalable point-to-point routing in large weighted graphs by introducing an $s$-$t$ overlap-based partition that yields independent, solver-agnostic subproblems. It constructs hopping spheres around the endpoints, shrinks to the last nonempty overlap, and splits at an anchor inside the overlap, ensuring that concatenating subpaths produces a valid global route without boundary repair. The approach enables parallel solution of leaf subproblems and demonstrates faster runtimes with equal or better route quality than partition baselines on large road networks, while maintaining proximity to optimality relative to Dijkstra. Potential extensions include adaptive rule tuning and automatic selection of the radius cap to further improve efficiency and robustness across diverse graphs and query distributions.

Abstract

We study shortest-path routing in large weighted, undirected graphs, where expanding search frontiers raise time and memory costs for exact solvers. We propose \emph{SPHERE}, a source-target-aware heuristic that identifies an $s$-$t$ overlap: vertices that are close to both $s$ and $t$ in hop count. Selecting an anchor $a$ in this overlap partitions the task into two subproblems with unchanged problem-topology, $s\to a$ and $a\to t$; if either remains large, the procedure recurses on its induced subgraph. Because the cut lies inside the overlap, concatenating the resulting subpaths yields a valid $s\to t$ route without boundary repair. SPHERE is independent of the downstream solver (e.g., Dijkstra) and exposes parallelism across subproblems. On large networks, it achieves faster runtimes and smaller optimality gaps than Louvain-based routing and a METIS-based pipeline, even on graphs with more than a million nodes and edges, while also outperforming Dijkstra in runtime.

SPHERE: Spherical partitioning for large-scale routing optimization

TL;DR

SPHERE addresses scalable point-to-point routing in large weighted graphs by introducing an - overlap-based partition that yields independent, solver-agnostic subproblems. It constructs hopping spheres around the endpoints, shrinks to the last nonempty overlap, and splits at an anchor inside the overlap, ensuring that concatenating subpaths produces a valid global route without boundary repair. The approach enables parallel solution of leaf subproblems and demonstrates faster runtimes with equal or better route quality than partition baselines on large road networks, while maintaining proximity to optimality relative to Dijkstra. Potential extensions include adaptive rule tuning and automatic selection of the radius cap to further improve efficiency and robustness across diverse graphs and query distributions.

Abstract

We study shortest-path routing in large weighted, undirected graphs, where expanding search frontiers raise time and memory costs for exact solvers. We propose \emph{SPHERE}, a source-target-aware heuristic that identifies an - overlap: vertices that are close to both and in hop count. Selecting an anchor in this overlap partitions the task into two subproblems with unchanged problem-topology, and ; if either remains large, the procedure recurses on its induced subgraph. Because the cut lies inside the overlap, concatenating the resulting subpaths yields a valid route without boundary repair. SPHERE is independent of the downstream solver (e.g., Dijkstra) and exposes parallelism across subproblems. On large networks, it achieves faster runtimes and smaller optimality gaps than Louvain-based routing and a METIS-based pipeline, even on graphs with more than a million nodes and edges, while also outperforming Dijkstra in runtime.

Paper Structure

This paper contains 23 sections, 1 theorem, 9 equations, 4 figures, 3 algorithms.

Table of Contents

  1. Introduction
  2. Motivation
  3. Related Work
  4. Spherical Partitioning
  5. Spherical subgraphs
  6. Partition cut
  7. Example (monotone decrement).
  8. Recursive spherical partitioning
  9. Baseline application
  10. Numerical Experiments
  11. Dataset
  12. Experimental setup
  13. Baselines.
  14. Results
  15. Runtime.
  16. ...and 8 more sections

Key Result

Proposition 4.1

Let $(\bar{R}_s,\bar{R}_t,O,a)$ be returned by Algorithm alg:decomp-cut. If $P_{s\to a}$ is a feasible path in $G^{\mathrm{ind}}_{\bar{R}_s}(s)$ and $P_{a\to t}$ is a feasible path in $G^{\mathrm{ind}}_{\bar{R}_t}(t)$, then $P_{s\to a}\!\circ\!P_{a\to t}$ is a feasible $s\to t$ path in $G$.

Figures (4)

  • Figure 1: Two local views on $S_R(\tilde{v})$. Left: keep edges on shortest paths to $\tilde{v}$. Right: keep all edges among nodes in the sphere (induced).
  • Figure 2: Last nonempty overlap. Blue and red spheres overlap in the green region containing both $a$ and $a'$. Potential anchor node $a$ is selected according to Definition \ref{['def:anchor']}.
  • Figure 3: Recursive splitting. Any side above the radius cap is split again by Algorithm \ref{['alg:decomp-cut']}; leaves are independent subproblems.
  • Figure 4: Performance and accuracy profiles of 30 instances based on median and mean over five seeds.

Theorems & Definitions (8)

  • Definition 1: Spheres
  • Definition 2: Spherical subgraph
  • Definition 3: Induced spherical subgraph
  • Definition 4: Decrement rule
  • Definition 5: Starting rule
  • Definition 6: Anchor rule
  • Proposition 4.1: Feasibility preservation
  • proof : Proof sketch