[Paper Review] Improved distance sensitivity oracles via tree partitioning

Ran Duan, Tianyi Zhang|arXiv (Cornell University)|May 15, 2016

Complexity and Algorithms in Graphs4 references3 citations

TL;DR

This paper presents a new distance sensitivity oracle (DSO) for directed, non-negative weighted graphs that achieves optimal O(n²) space complexity and O(1) query time, with preprocessing time of Õ(mn). The method uses tree partitioning and a novel tabulation technique based on the Four Russians method to reduce space from O(n² log n) to O(n²), while maintaining constant-time queries and near-optimal preprocessing, making it asymptotically space-optimal and efficient for dynamic routing under vertex failures.

ABSTRACT

We introduce an improved structure of distance sensitivity oracle (DSO). The task is to pre-process a non-negatively weighted graph so that a data structure can quickly answer replacement path length for every triple of source, terminal and failed vertex. The previous best algorithm constructs in time $ ilde{O}(mn)$ a distance sensitivity oracle of size $O(n^2\log n)$ that processes queries in $O(1)$ time. As an improvement, our oracle takes up $O(n^2)$ space, while preserving $O(1)$ query efficiency and $ ilde{O}(mn)$ preprocessing time. One should notice that space complexity and query time of our novel data structure are asymptotically optimal.

Motivation & Objective

• To design a distance sensitivity oracle (DSO) with asymptotically optimal space complexity for vertex-failure shortest path queries.
• To reduce the space complexity of existing DSOs from O(n² log n) to O(n²) without sacrificing O(1) query time.
• To achieve preprocessing time of Õ(mn), which is nearly optimal, while maintaining constant-time query efficiency.
• To extend the applicability of DSOs to real-time routing systems where node failures require fast re-routing without recomputing all-pairs shortest paths.

Proposed method

• The method partitions single-source shortest path (SSSP) trees and designates only a subset of vertices to store sparse table entries, reducing space usage.
• It introduces a hierarchical tree partitioning strategy that focuses on vertices far from source and target to handle degenerate cases efficiently.
• A tabulation technique based on the Four Russians method is used to compress storage for L′-short paths, reducing space to o(n²) for this component.
• The approach leverages admissible functions to replace bottleneck vertices in path decompositions, simplifying initialization and preserving correctness.
• It uses level-ancestor data structures and matrix indexing to quickly recover divergence and convergence points of replacement paths.
• The final DSO stores only O(n²) entries by combining sparse table entries with precomputed path segments for short paths, enabling O(1) queries.

Experimental results

Research questions

• RQ1 Can a distance sensitivity oracle be constructed with O(n²) space while maintaining O(1) query time?
• RQ2 Is it possible to reduce the space complexity of existing DSOs from O(n² log n) to O(n²) without increasing query time?
• RQ3 Can preprocessing time be maintained at Õ(mn) while achieving optimal space complexity?
• RQ4 How can the Four Russians technique be adapted to compress path information in DSOs for vertex-failure queries?
• RQ5 What is the minimal space complexity required to answer all-pair replacement path queries under vertex failures?

Key findings

• The proposed DSO achieves O(n²) space complexity, which is asymptotically optimal, as any DSO must store at least Ω(n²) entries in a complete graph with distinct edge weights.
• The DSO supports O(1) query time for replacement path lengths, matching the best prior results in terms of query efficiency.
• Preprocessing time is Õ(mn), which is nearly optimal and matches the best-known bounds, improving upon previous O(mn²) and O(mn^{1.5}) methods.
• The space complexity is reduced by eliminating the log n factor in the prior O(n² log n) DSOs, achieving a quadratic space bound.
• The method supports output-sensitive path reconstruction in O(|st⋄f|) time by storing the first edge of each path entry.
• The use of tabulation on L′-short paths reduces space for this component to o(n²), contributing to the overall O(n²) bound.