[Paper Review] Faster Approximate Distance Queries and Compact Routing in Sparse Graphs

Rachit Agarwal, P. Brighten Godfrey+1 more|arXiv (Cornell University)|Jan 12, 2012

Caching and Content Delivery12 references4 citations

TL;DR

This paper presents novel distance oracles and compact routing schemes for sparse graphs that break the classical space-stretch trade-off barrier by using a tunable parameter α. It achieves linear space (O(m)) with constant stretch (2) and sublinear query time, enabling efficient approximate distance queries and the first optimal compact routing with worst-case stretch 2 on sparse graphs.

ABSTRACT

A distance oracle is a compact representation of the shortest distance matrix of a graph. It can be queried to approximate shortest paths between any pair of vertices. Any distance oracle that returns paths of worst-case stretch (2k-1) must require space $Ω(n^{1 + 1/k})$ for graphs of n nodes. The hard cases that enforce this lower bound are, however, rather dense graphs with average degree Ω(n^{1/k}). We present distance oracles that, for sparse graphs, substantially break the lower bound barrier at the expense of higher query time. For any 1 \leq α\leq n, our distance oracles can return stretch 2 paths using O(m + n^2/α) space and stretch 3 paths using O(m + n^2/α^2) space, at the expense of O(αm/n) query time. By setting appropriate values of α, we get the first distance oracles that have size linear in the size of the graph, and return constant stretch paths in non-trivial query time. The query time can be further reduced to O(α), by using an additional O(m α) space for all our distance oracles, or at the cost of a small constant additive stretch. We use our stretch 2 distance oracle to present the first compact routing scheme with worst-case stretch 2. Any compact routing scheme with stretch less than 2 must require linear memory at some nodes even for sparse graphs; our scheme, hence, achieves the optimal stretch with non-trivial memory requirements. Moreover, supported by large-scale simulations on graphs including the AS-level Internet graph, we argue that our stretch-2 scheme would be simple and efficient to implement as a distributed compact routing protocol.

Motivation & Objective

• Address the limitation of existing distance oracles that require Ω(n^{1+1/k}) space for stretch (2k−1), especially in sparse graphs.
• Overcome the space-stretch trade-off barrier in sparse graphs by introducing a tunable parameter α to balance space and query time.
• Design the first compact routing scheme with worst-case stretch 2 for sparse graphs, achieving optimal stretch with non-trivial memory usage.
• Enable practical deployment through efficient query mechanisms and validation via large-scale simulations on real-world graphs like the AS-level Internet graph.

Proposed method

• Introduce a parameter α to control the trade-off between space and query time, where α ∈ [1, n].
• Construct distance oracles that return stretch-2 paths using O(m + n²/α) space and O(αm/n) query time, and stretch-3 paths using O(m + n²/α²) space.
• Optimize query time to O(α) by adding O(mα) auxiliary space, or accept a small constant additive stretch for further speedup.
• Leverage the stretch-2 distance oracle to design a compact routing scheme with worst-case stretch 2, proving it optimal for sparse graphs.
• Use a hierarchical decomposition and landmark-based routing to support efficient path approximation and routing decisions.
• Validate the practicality of the scheme through simulations on real-world sparse graphs, including the AS-level Internet topology.

Experimental results

Research questions

• RQ1 Can distance oracles for sparse graphs achieve linear space while maintaining constant stretch and sublinear query time?
• RQ2 Is it possible to design a compact routing scheme with worst-case stretch 2 for sparse graphs using sublinear memory per node?
• RQ3 How can the classical space-stretch lower bound be circumvented in sparse graphs using a tunable parameter α?
• RQ4 What is the trade-off between space, query time, and stretch in approximate distance oracles for sparse graphs?
• RQ5 Can the proposed scheme be efficiently implemented and scaled in real-world distributed networks like the Internet?

Key findings

• The proposed distance oracles achieve stretch 2 with O(m + n²/α) space and O(αm/n) query time, breaking the classical Ω(n^{1+1/k}) space lower bound for sparse graphs.
• By setting α = n, the scheme achieves O(m) space and O(m) query time, enabling linear-space distance oracles with constant stretch.
• The query time can be reduced to O(α) using an additional O(mα) space, providing a tunable trade-off between space and latency.
• The stretch-2 distance oracle enables the first compact routing scheme with worst-case stretch 2 for sparse graphs, achieving optimal stretch with non-trivial memory usage.
• Simulations on the AS-level Internet graph and other real-world graphs confirm the scheme’s efficiency and practicality for distributed deployment.
• The scheme supports a small constant additive stretch with improved query time, offering a practical trade-off for real-world routing applications.