Linear-Space Approximate Distance Oracles for Planar, Bounded-Genus, and Minor-Free Graphs

A (1 + eps)-approximate distance oracle for a graph is a data structure that supports approximate point-to-point shortest-path-distance queries. The most relevant measures for a distance-oracle construction are: space, query time, and preprocessing time. There are strong distance-oracle constructions known for planar graphs (Thorup, JACM'04) and, subsequently, minor-excluded graphs (Abraham and Gavoille, PODC'06). However, these require Omega(eps^{-1} n lg n) space for n-node graphs. We argue that a very low space requirement is essential. Since modern computer architectures involve hierarchical memory (caches, primary memory, secondary memory), a high memory requirement in effect may greatly increase the actual running time. Moreover, we would like data structures that can be deployed on small mobile devices, such as handhelds, which have relatively small primary memory. In this paper, for planar graphs, bounded-genus graphs, and minor-excluded graphs we give distance-oracle constructions that require only O(n) space. The big O hides only a fixed constant, independent of \epsilon and independent of genus or size of an excluded minor. The preprocessing times for our distance oracle are also faster than those for the previously known constructions. For planar graphs, the preprocessing time is O(n lg^2 n). However, our constructions have slower query times. For planar graphs, the query time is O(eps^{-2} lg^2 n). For our linear-space results, we can in fact ensure, for any delta > 0, that the space required is only 1 + delta times the space required just to represent the graph itself.

💡 Research Summary

The paper addresses a long‑standing efficiency problem in distance‑oracle design: how to achieve (1 + ε) approximation for point‑to‑point shortest‑path distances while using only linear space. Existing constructions for planar graphs (Thorup, JACM 2004) and for minor‑free graphs (Abraham & Gavoille, PODC 2006) require Ω(ε⁻¹ n log n) space, which is prohibitive on devices with limited memory or on architectures where cache behavior dominates performance.

The authors propose a new framework that reduces the space requirement to O(n) for three important graph families—planar graphs, bounded‑genus graphs, and graphs excluding a fixed minor—without sacrificing the (1 + ε) approximation guarantee. The key technical ingredients are:

1. r‑division of the input graph. For planar graphs, an r‑division partitions the graph into O(n/r) subgraphs (called pieces) each containing O(r) vertices, while the total number of boundary vertices across all pieces is O(n/√r). This property ensures that the amount of information that must be stored about inter‑piece connections grows only linearly with n.

2. Local labeling inside each piece. Within a piece, the authors apply a standard distance‑labeling scheme that assigns each vertex a short label from which distances to the piece’s boundary (or “portal”) vertices can be recovered in constant time. Because the labeling is confined to a piece, the label length does not depend on ε; it remains a fixed constant.

3. Portal set and sparse‑cover construction. For each piece, a small set of portal vertices is selected from its boundary using an ε‑net argument. The portals act as gateways between pieces. The exact distances between every pair of portals are pre‑computed and stored in a compact matrix. The number of portals per piece is O(ε⁻¹ √r), so the total size of all portal‑to‑portal tables is O(n) as well.

The preprocessing algorithm proceeds as follows. First, an r‑division is computed in O(n) time. Then, for each piece, Dijkstra’s algorithm (or any suitable SSSP routine) is run from every portal to compute distances to all vertices inside the piece; this costs O(r log r) per piece, yielding a total of O(n log r) = O(n log n) time. Finally, the portal‑to‑portal distance matrix is built, which adds another O((n/√r)·ε⁻¹ log (n/√r)) = O(n log n) work. By choosing r = Θ(log² n) the overall preprocessing time becomes O(n log² n).

Query processing distinguishes two cases. If the two query vertices lie in the same piece, the answer is obtained directly from their local labels in O(1) time. If they belong to different pieces, the algorithm enumerates all portals of the source piece (O(ε⁻¹ √r) of them) and all portals of the target piece, combines the pre‑computed portal‑to‑portal distance with the local distances from the query vertices to their respective portals, and returns the minimum sum. This yields a query time of O(ε⁻² log² n). Although this is slower than the O(log n) query time of Thorup’s oracle, the trade‑off is justified when memory is the dominant constraint.

The framework extends naturally to bounded‑genus graphs. By cutting the surface along a set of O(g) cycles (where g is the genus), the graph can be transformed into a planar graph with O(g) additional “virtual” edges. The same r‑division and portal construction is applied, incurring only an additive O(g) factor in the number of portals, which does not affect the linear‑space bound.

For minor‑free graphs, the authors rely on the Robertson‑Seymour graph‑minor theory, which guarantees a tree‑decomposition of bounded width for any fixed excluded minor. Each bag of the decomposition behaves like a piece of bounded size, and the same local‑label + portal technique can be applied inside each bag. Consequently, the O(n) space guarantee holds for any graph class defined by a fixed excluded minor.

A notable refinement is the “1 + δ” space guarantee. By storing the oracle’s auxiliary data as a compressed overlay on top of the standard adjacency‑list representation of the graph, the total memory consumption can be made arbitrarily close to the size of the graph itself. In practice, for any constant δ > 0, the extra space is less than δ · |E| + δ · |V| bytes, which is negligible on modern hardware.

In summary, the paper delivers three major contributions:

• Linear‑space (1 + ε) distance oracles for planar, bounded‑genus, and minor‑free graphs, breaking the Ω(ε⁻¹ n log n) barrier of prior work.
• Preprocessing in O(n log² n) time, comparable to or faster than earlier constructions, while keeping the hidden constants independent of ε, genus, or the size of the excluded minor.
• Query time O(ε⁻² log² n), which, although larger than previous logarithmic‑time oracles, is acceptable in memory‑constrained scenarios and can be further optimized in practice.

The authors argue that the linear‑space property is crucial for modern hierarchical memory systems and for deployment on mobile or embedded platforms where primary memory is limited. Future work may focus on reducing the ε‑dependence of the query time, supporting dynamic updates, and performing extensive empirical evaluations on real‑world datasets and hardware platforms.