Breaking the Sorting Barrier for Directed Single-Source Shortest Paths

Abstract: We give a deterministic $O(m\log^{2/3}n)$-time algorithm for single-source shortest paths (SSSP) on directed graphs with real non-negative edge weights in the comparison-addition model. This is the first result to break the $O(m+n\log n)$ time bound of Dijkstra's algorithm on sparse graphs, showing that Dijkstra's algorithm is not optimal for SSSP.

• The paper introduces a deterministic O(m log^(2/3)n) algorithm for SSSP on directed graphs, challenging the optimality of Dijkstra's approach on sparse graphs.
• The paper employs a recursive partitioning technique and efficient frontier management to reduce the problem size without incurring high sorting costs.
• The paper demonstrates improved scalability and runtime performance, setting a new benchmark for deterministic shortest path algorithms in directed settings.

Breaking the Sorting Barrier for Directed Single-Source Shortest Paths

Introduction

The paper "Breaking the Sorting Barrier for Directed Single-Source Shortest Paths" introduces a novel approach to solving the Single-Source Shortest Path (SSSP) problem on directed graphs with real non-negative edge weights. The proposed algorithm achieves a deterministic runtime of $O(m\log^{2/3}n)$, breaking the widely accepted $O(m+n\log n)$ time bound established by Dijkstra's algorithm, particularly when applied to sparse graphs. This breakthrough effectively demonstrates that Dijkstra's algorithm is not inherently optimal for SSSP in all cases.

Algorithmic Framework

Traditional Approaches

Two classical algorithms are commonly used for SSSP:

1. Dijkstra's Algorithm: Utilizes a priority queue to extract vertices in order of their minimum distance from the source. Its time complexity is influenced by sorting, resulting in a minimum theoretical bound of $\Omega(n \log n)$.
2. Bellman-Ford Algorithm: Employs dynamic programming to relax edges iteratively, capable of supporting graphs with negative weights, in $O(mn)$ time.

New Approach

This paper's proposed approach significantly reduces the "sorting bottleneck" associated with Dijkstra's method without incurring the computational penalties associated with Bellman-Ford. The algorithm utilizes a recursive partitioning technique inspired by methods used in solving bottleneck path problems, which allows the reduction of the "frontier" (set of vertices to be processed) by a factor of $\log^{\Omega(1)}(n)$. This results in a smaller problem size at each recursion level, allowing the method to efficiently scale with graph size.

Key Technical Contributions

1. Priority Queue Frontier Management: At any point during execution, a smaller subset of vertices termed the frontier is maintained. Any shortest path extending beyond this frontier will use a "pivot" within it. The algorithm uses a recursive partitioning scheme to ensure that the size of this frontier is kept to $|U|/\log^{\Omega(1)}(n)$, where $|U|$ is the subset of vertices of current interest.
2. Divide-and-Conquer Procedure: The vertices are divided and sub-problems are created for each segment, with depths limited to $\log n / t$, where $t$ relates to recursion levels. Each recursion level reduces the scope and indirectly sorts vertices through computed distances without explicitly doing so.
3. Performance Metrics and Scalability: The method's efficiency is attributed to managing the problem size effectively, with the frontier reduction leading to an overall complexity of $O(m\log^{2/3}n)$, which is a substantial improvement over methods requiring explicit sorting of all nodes.

Relation to Existing Works

The results of this research build upon and contrast with various established algorithms and assumptions:

• Hierarchical Approaches: Similar hierarchical methods used in Pettie and Ramachandran's work inform the recursive partitioning technique but are adapted to directed graphs.
• Randomized Algorithms: Recent randomized methods achieve comparable runtime improvements but lack the deterministic guarantees of the proposed method. This result sets a new benchmark for deterministic algorithms in SSSP scenarios.

Conclusion

The deterministic $O(m\log^{2/3}n)$-time algorithm proposed in this paper constitutes a significant stride in SSSP problem solving for directed graphs, effectively challenging the optimality presupposed by Dijkstra's algorithm in certain graph scenarios. By blending concepts from priority queues and recursive decomposition, the research allows for faster execution in sparse scenarios without relying on randomness or sacrificing theoretical guarantees. This advancement opens new avenues for both theoretical exploration in adaptive algorithms and practical enhancement of systems where SSSP computations are critical. Future work may further refine these techniques or extend their applicability across broader classes of graphs and weights.