Two-Point Shortest Path Query

Updated 19 December 2025

Two-Point Shortest Path Query Problem is the task of preprocessing a domain to rapidly answer shortest path queries between any two points, essential for route planning and network analytics.
It employs diverse methods such as labeling, gateway-based schemes, and geometric decompositions to achieve low query times while balancing storage and preprocessing effort.
Key trade-offs include managing index size, update efficiency, and computational complexity, with applications ranging from transportation planning to quantum and hybrid algorithm frameworks.

The two-point shortest path query problem is the algorithmic task of preprocessing a space, typically represented as an abstract graph, geometric domain, or metric structure, so that queries for the shortest path (or simply the distance) between arbitrary pairs of points (“two-point queries”) can be answered rapidly. This fundamental operation underlies applications ranging from route planning in transportation and robotics to large-scale network analytics and geometric computing. The rigorous study of data structures and algorithms for efficient two-point shortest path queries involves diverse models: general weighted graphs, geometric domains (such as polygonal maps, polyhedra, and CAT(0) complexes), and continuous or hybrid spaces with both discrete and continuous structure.

1. Formal Problem Definition

Given a domain (most commonly an undirected, weighted, simple graph $G=(V_G, E_G, w_G)$ with $w_G: E_G \to \mathbb{N}^+$ ), the two-point shortest path query problem seeks a data structure supporting queries of the form: given $s, t \in V_G$ , report

$\text{dist}_G(s, t) = \min \left\{\sum_{e \in P} w_G(e)\colon P \text{ is a path from } s \text{ to } t \text{ in } G\right\}$

or $\infty$ if $s$ and $t$ are disconnected. For geometric domains (polygonal domains, sets with obstacles, surfaces), the task is to preprocess $P$ such that, for any two query points $s, t \in P$ , the geodesic (shortest path) length $d(s, t)$ and, in many cases, the actual path, can be reported efficiently. For cell complexes, such as CAT(0) rectangular complexes, the goal is to preprocess the structure so distances and realizing paths between any two points are computable quickly.

Key design objectives include:

Sublinear (ideally polylogarithmic) query time.
Minimization of preprocessing time and index/storage space.
Support for exact or approximate queries, depending on the application.

2. Core Methodologies and Data Structures

Approaches across domains vary, but several core paradigms dominate:

Labeling/Indexing for General Graphs:

Independent-set labeling (IS-LABEL): Decompose $V_G$ into independent-set layers $L_1, ..., L_h$ , constructing a sequence of distance-preserving subgraphs $G_1, ..., G_h$ . Each vertex receives a label containing distances to selected ancestors, enabling queries via label intersection and a possible bidirectional Dijkstra on a tiny residual core. IS-LABEL achieves microsecond-to-millisecond queries on massive sparse graphs while maintaining manageable index size (Fu et al., 2012).

Vicinity-based Labeling for Social/Sparse Graphs:

Assign to each node a small vicinity comprising its nearest "landmark," the local subgraph, and boundary nodes. Queries intersect vicinities of $s$ and $t$ ; if nonempty, report the minimum witness sum. Super-millisecond query times (>99.9% coverage), leveraging low-diameter, scale-free structure (Agarwal et al., 2012).

Geometric Domains and Shortest-Path Maps:

Euclidean (polygonal) case: Use visibility-based decompositions, multi-level cutting trees, and lower envelope structures over region-pairs to encode all possible path structures. State-of-the-art data structures use $O(n^{10+\varepsilon})$ to $O(n^{9+\varepsilon})$ space and $O(\log n)$ – $O(\log^2 n)$ query time for domains with $n$ vertices (Berg et al., 2023).
Boundary-restricted variants and simpler metrics (such as $L_1$ ) allow further reductions, e.g., $O(n^{4+\varepsilon})$ space and $O(\log n)$ time for boundary-to-boundary queries (0911.5017, Berg et al., 2023).

Rectilinear and Polygonal Path Domains:

Gateway-based frameworks: Insert $O(\log n)$ – $O(\sqrt{\log n})$ "gateways" for each query point, reduce the query to the minimal pairwise sum over gateways, and exploit corridor or convex decompositions. Advanced divide-and-conquer techniques yield $O(\log n)$ query for general polygonal domains in the $L_1$ -metric, with near-linear or subquadratic space (Wang, 2019, Chen et al., 2014).

CAT(0) Rectangular Complexes:

Precompute all-pairs distances and local adjacency lists. Queries extract minimal boundary subcomplexes, unfold these convex subspaces, and run geometric shortest path algorithms linear in the subcomplex diameter (Chepoi et al., 2010).

Continuous/Hybrid Methods (Graphs of Convex Sets):

Precompute quadratic lower bounds via semidefinite programming on the global cost-to-go function, enable online $n$ -step lookahead convex optimization over candidate paths with guaranteed feasibility and near-optimality at sub-10 ms online query latency for hybrid discrete-continuous spaces (Morozov et al., 29 Sep 2024).

Quantum Algorithms:

Quantum walks for shortest path, using electric-flow state preparation and effective resistance techniques, yield $\tilde O(\ell \sqrt{m})$ – $\tilde O(\ell^2 \sqrt{m})$ step complexity (for $\ell$ = shortest path length, $m$ = edge count) in structured graphs, with advantages only under certain resistance gap conditions. Quantum algorithms partially match path-detection lower bounds up to polylog factors (Wesołowski et al., 19 Aug 2024).

3. Algorithmic Workflows and Query Procedures

A prototypical high-performance two-point distance query index follows these stages:

Preprocessing:
- Layer the graph or domain into recursively defined substructures with well-characterized combinatorics.
- Build per-vertex or per-region label sets, capturing essential distance relations (ancestors, vicinities, or gateway sets).
- Construct auxiliary data structures (e.g., lower envelopes, shortest-path maps, cuttings, or search trees).
Query Algorithm:
- For a query $(s, t)$ $(s, t)$ :
  - In label-based frameworks, compute the intersection $X =$ label $(s) \cap$ label $(t)$ , minimize over the candidate witnesses $w\in X$ the sum $d(s,w) + d(t,w)$ .
  - If intersection is empty or core subgraph search is needed, fallback to a bidirectional Dijkstra on a tiny core with boundary conditions given by the labeling (Fu et al., 2012).
  - In geometric frameworks, use point-location to identify relevant regions ( $O(\log n)$ ) and evaluate path length by lower envelope or explicit enumeration of candidate gateway pairs (Berg et al., 2023, Wang, 2019).
  - In $L_1$ and rectilinear settings, leverage corridor/gateway decomposition to reduce to a small set of representative subproblems (Chen et al., 2014, Wang, 2017).
Complexity and Performance:
- Query time in best cases is $O(\log n)$ or $O(\log n + k)$ (with $k$ the output path length); index size ranges from $O(n)$ (for simple polygons in $L_1$ ) up to $O(n^{10+\varepsilon})$ (full generality) (Berg et al., 2023, Bae et al., 2018).
- Empirical tests on massive networks (e.g., 10 $^8$ -vertex graphs) demonstrate microsecond-to-millisecond latency and several orders of magnitude speed-up over vanilla Dijkstra (Fu et al., 2012, Agarwal et al., 2012).

4. Achievable Trade-offs and Theoretical Bounds

The following table synthesizes space and query time trade-offs for the two-point shortest path problem across different settings, as determined by recent advances:

Domain/Model	Index Size/Preprocessing	Query Time	Reference
General sparse graphs	$O(k \cdot \text{sort}(\|G\|))$	$O(\|\text{label}(s)\|)$	(Fu et al., 2012)
Social/scale-free graphs	$O(\alpha n^{3/2})$	$O(\alpha \sqrt{n})$	(Agarwal et al., 2012)
Polygonal domain (Euclidean)	$O(n^{10+\varepsilon})$	$O(\log n)$	(Berg et al., 2023)
Polygonal domain (boundary pts)	$O(n^{4+\varepsilon})$	$O(\log n)$	(Berg et al., 2023)
Simple polygon ( $L_1$ -metric)	$O(n)$	$O(\log n)$	(Bae et al., 2018)
$L_1$ , general poly domains	$O(n + h^2 \log h 4^{\sqrt{\log h}})$	$O(\log n + k)$	(Chen et al., 2014)
Convex polyhedral surfaces	$O(n^{6+\varepsilon})$	$O(\log n)$	(Wang, 12 Dec 2025)
CAT(0) rectangular complex	$O(n^2)$	$O(d_G(p,q))$	(Chepoi et al., 2010)
Graphs of Convex Sets (GCS)	$O(\text{SDP})$	$O(\text{few} \times \text{convex solve})$	(Morozov et al., 29 Sep 2024)
Quantum (resistance structured)	--	$\tilde{O}(\ell \sqrt{m})$	(Wesołowski et al., 19 Aug 2024)

All logarithmic and $\varepsilon$ notations can be made arbitrarily small for fixed approximation parameters.

5. Comparative Analysis and Domain-specific Innovations

Significant advances in the domain stem from leveraging problem-specific structure:

For large real-world graphs, hierarchical labeling via independent sets, vicinity intersection, and separator-based overlays enable both scalability and rapid queries (Fu et al., 2012, Agarwal et al., 2012).
In geometric domains, the breakthrough from $O(n^{11})$ (Chiang–Mitchell) to $O(n^{10+\varepsilon})$ space (Berg et al., 2023), as well as $O(n^{4+\varepsilon})$ for boundary-restricted cases, arises by representing all candidate shortest-path regions via a multi-level cutting tree on augmented shortest-path map cells. Modern lower envelope data structures permit near-optimal trade-offs.
For $L_1$ settings, the combination of mountain/corridor decomposition and efficient gateway selection yields $O(n)$ space and logarithmic query times in simple and even multiply-connected polygons (Bae et al., 2018, Chen et al., 2014, Wang, 2019).
In high-dimensional or hybrid spaces (robot motion, GCS), offline semidefinite programming for cost-to-go function approximation combined with rapid online convex optimization enables near-optimal trajectories within a few milliseconds, with provable bounds on suboptimality (Morozov et al., 29 Sep 2024).
For specific topological or algebraic settings (CAT(0) complexes), reduction to median graph intervals and output-sensitive unfolding techniques produce linear-in-path-length queries, with optimal or near-optimal data structure size (Chepoi et al., 2010).

6. Limitations, Open Directions, and Practical Considerations

While two-point shortest path query indices exhibit strong theoretical and empirical performance in structured domains, several important aspects remain at the research frontier:

Worst-case label or index size: Pathological graph instances may force near-quadratic or higher index sizes, despite sparsity in typical real-world networks (Fu et al., 2012).
Dynamic and high-update-rate networks: Incremental or online update mechanisms exist for localized changes, but high-frequency dynamism may necessitate periodic full rebuilds or batched updates (Fu et al., 2012, Agarwal et al., 2012).
Parallel and Distributed Architectures: Full exploitation of modern hardware remains an active area, especially for massive-scale graphs and geometric domains where partitioning and sharding must preserve query efficiency and correctness.
Quantum computing applicability: Quantum speedups for two-point queries require electrical-resistance gap conditions, with open questions on extension to general graphs, directed variants, and matching lower bounds (Wesołowski et al., 19 Aug 2024).
Real-time, memory-constrained environments: While leading algorithms can serve million-node graphs in RAM, crossing into the multi-billion node regime or memory-limited scenarios requires aggressive compression and selective index construction.

A plausible implication is that for every domain, tight integration of domain-specific structure (e.g., geometric, topological, algebraic, or probabilistic properties) with algorithmic design is essential to achieve practical, scalable two-point shortest path queries.

7. Historical Evolution and Notable Milestones

The gateway/cut-line and corridor-based frameworks for rectilinear and polygonal domains originate in studies from the late 1980s (Clarkson, Reif), with major advancements in the late 2010s via divide-and-conquer schemes and enhanced intersection algorithms (Chen et al., 2014, Wang, 2019).
In general graphs, the emergence of scalable labeling schemes such as IS-LABEL, and the vicinity-intersection method, mark a shift toward real-time performance at massive scale (Fu et al., 2012, Agarwal et al., 2012).
For geometric and topological settings, advances in cutting-tree decompositions and lower envelope machinery have reduced the combinatorial explosion inherent to the problem, achieving the first improvements in the Euclidean two-point query domain in over two decades (Berg et al., 2023).
The application of convex optimization and semidefinite programming to multi-query motion planning represents the latest evolution in handling hybrid discrete-continuous path spaces (Morozov et al., 29 Sep 2024).
The quantum algorithmic perspective recently advanced the frontier for specific resistance-structured instances, setting benchmarks for quantum-classical separation in the query model (Wesołowski et al., 19 Aug 2024).

These developments collectively anchor the two-point shortest path query problem as a central testbed for algorithms and data structures at the interface of combinatorial optimization, computational geometry, and large-scale data analytics.