Randomized $\tilde{O}(m\sqrt{n})$ Bellman-Ford from Fineman and the Boilermakers

Abstract: A classical algorithm by Bellman and Ford from the 1950's computes shortest paths in weighted graphs on $n$ vertices and $m$ edges with possibly negative weights in $O(mn)$ time. Indeed, this algorithm is taught regularly in undergraduate Algorithms courses. In 2023, after nearly 70 years, Fineman \cite{fineman2024single} developed an $\tilde{O}(m n^{8/9})$ expected time algorithm for this problem. Huang, Jin and Quanrud improved on Fineman's startling breakthrough by providing an $\tilde{O}(m n^{4/5} )$ time algorithm. This paper builds on ideas from those results to produce an $\tilde{O}(m\sqrt{n})$ expected time algorithm. The simple observation that distances can be updated with respect to the reduced costs for a price function in linear time is key to the improvement. This almost immediately improves the previous work. To produce the final bound, this paper provides recursive versions of Fineman's structures.

• The paper presents a randomized algorithm achieving O(m sqrt n) expected time for single-source shortest paths in graphs with negative weights.
• Key techniques involve using reduced costs derived from potential functions and an O(m) linear-time update procedure to refine distance estimates.
• The algorithm uses a recursive framework adapting prior techniques to efficiently propagate distance updates and improve upon previous Bellman-Ford variants.

The paper "Randomized $\tilde{O}(m\sqrt{n})$ Bellman-Ford from Fineman and the Boilermakers" (2503.22613) presents a significant advancement in computing single-source shortest paths (SSSP) in graphs with $n$ vertices, $m$ edges, and potentially negative edge weights. It builds directly upon the frameworks introduced by Fineman $\tilde{O}(mn^{8/9})$" title="" rel="nofollow" data-turbo="false" class="assistant-link">fineman2024single and subsequently improved by Huang, Jin, and Quanrud ($\tilde{O}(mn^{4/5})$), ultimately achieving an expected runtime of $\tilde{O}(m\sqrt{n})$. The core techniques involve leveraging reduced costs with respect to potential functions (price functions) and introducing recursive structures inspired by Fineman's original approach.

Background and Foundational Concepts

The classical Bellman-Ford algorithm addresses the SSSP problem in $O(mn)$ time. It works by iteratively relaxing edges, guaranteeing correctness after $n-1$ iterations if no negative cycles reachable from the source exist. Detecting negative cycles requires one additional iteration. Recent breakthroughs focus on accelerating this process, often by reducing the SSSP problem to negative cycle detection or by employing sophisticated data structures and potential function methods.

Fineman's work introduced novel techniques, likely involving dynamic data structures and potentially randomized partitioning or sampling, to speed up the relaxation process or detect negative cycles more efficiently. The subsequent improvement by Huang et al. refined these techniques. A common thread in these approaches is the use of potential functions $\phi: V \to \mathbb{R}$ and reduced costs $w_{\phi}(u, v) = w(u, v) + \phi(u) - \phi(v)$. If a potential function yields non-negative reduced costs for all edges, Dijkstra's algorithm can be applied to the graph with reduced costs, and distances can be recovered using $d(s, v) = d_{\phi}(s, v) - \phi(s) + \phi(v)$. Finding such a potential function is equivalent to solving SSSP. These recent algorithms often work by iteratively improving an estimate of the shortest path distances (which act as a potential function) and using reduced costs to guide the process, frequently employing scaling techniques on edge weights.

Key Insight: Linear-Time Updates via Reduced Costs

A central contribution of the (2503.22613) paper is the observation that, given a price function $\mathbf{p}$ (representing estimated distances, potentially derived from previous iterations or recursive calls), one can update the distance estimates $\mathbf{d}$ using the reduced costs $$w_{\mathbf{p}}(u, v) = w(u, v) + \mathbf{p}[u] - \mathbf{p}[v]$$ in $O(m)$ time.

Specifically, the standard Bellman-Ford relaxation step updates $d[v]$ for all neighbors $v$ of $u$ based on $d[u] + w(u, v)$. The paper likely shows how to perform a full iteration of relaxations (or an equivalent update achieving similar progress) based on the reduced costs $w_{\mathbf{p}}$ in linear time. This might involve a procedure like:

1. Compute all reduced costs $w_{\mathbf{p}}(u, v)$ for all edges $(u, v) \in E$. This takes $O(m)$ time.
2. Perform relaxation updates using these reduced costs. The exact mechanism for achieving this efficiently within the overall framework needs clarification, but the claim is it leads to an $O(m)$ time procedure for incorporating the information from the potential function $\mathbf{p}$ into the current distance estimates $\mathbf{d}$.

Consider a Bellman-Ford-like update step. Instead of directly relaxing using $w(u,v)$, we consider the reduced costs $w_\mathbf{p}$. If we aim to update distances $\mathbf{d}$ based on $\mathbf{p}$, the standard relaxation $d[v] = \min(d[v], d[u] + w(u,v))$ can be related to reduced costs. If $\mathbf{d}$ represents current shortest path estimates, and $\mathbf{p}$ is a potential function, an update iteration might look for edges where $d[u] + w(u,v) < d[v]$. This is equivalent to $$d[u] + w_\mathbf{p}(u,v) - \mathbf{p}[u] + \mathbf{p}[v] < d[v]$$. The paper's insight likely provides a specific update rule or process utilizing the $w_\mathbf{p}$ values that can be executed across all edges in $O(m)$ time, perhaps avoiding the need for complex priority queues in this specific step, thus differing from Dijkstra on reduced costs. It might involve a single pass over edges similar to a Bellman-Ford iteration but formulated using $\mathbf{p}$ and $w_\mathbf{p}$.

This linear-time update step is crucial because it provides a computationally cheap way to incorporate global information captured by the potential function $\mathbf{p}$ into the distance estimates. Previous approaches might have involved more expensive updates or data structure operations.

Recursive Framework

Building on the linear-time update mechanism and Fineman's original structures, the paper introduces a recursive approach. Fineman's original work [fineman2024single] likely involved partitioning vertices or edges, potentially based on distance estimates or random sampling, and using specialized data structures to handle updates within or between partitions.

The recursive algorithm in (2503.22613) likely applies these ideas hierarchically. A possible structure could be:

1. Base Case: If the number of vertices $n$ is small, use a standard algorithm (e.g., Bellman-Ford).
2. Recursive Step:

   a. Select a subset of vertices $V' \subset V$, perhaps randomly or based on structural properties. The size might be related to $\sqrt{n}$. b. Recursively compute shortest paths (or a relevant potential function $\mathbf{p}$) within the subgraph induced by $V'$, or solve a related subproblem. c. Use the result from the recursive call (the potential function $\mathbf{p}$) to compute reduced costs $w_{\mathbf{p}}$ for all edges in the original graph $G$. d. Apply the $O(m)$-time update procedure using $w_{\mathbf{p}}$ to improve the distance estimates $\mathbf{d}$ in $G$. e. Potentially perform additional steps using structures inspired by Fineman (e.g., handling updates for vertices not in $V'$ or refining paths that cross the partition boundary). This might involve further recursive calls on modified graphs or residual problems.

The interaction between the recursion and the linear-time update is key. The recursive calls compute potential functions or solve subproblems on smaller instances, and the results are efficiently propagated to the larger problem using the $O(m)$ update step based on reduced costs. Fineman's structures, adapted recursively, likely manage the information flow and updates between different levels of the recursion or different parts of the graph partitioning.

Algorithm Outline and Complexity

Let RecursiveSSSP(G=(V, E, w), s) be the function.

function RecursiveSSSP(G=(V, E, w), s): n = |V| m = |E| if n <= n_base_case: return BellmanFord(G, s) // Or another suitable base case algorithm // Parameter k, potentially related to sqrt(n) k = sqrt(n) // Or chosen based on analysis // Phase 1: Initial estimation / Sampling (Details depend on Fineman's structures) // This might involve random sampling of pivots or initial Bellman-Ford iterations. // Let d_initial be initial distance estimates. // Phase 2: Recursive computation and potential function generation // Select V' subset of V, potentially size ~n/k or related parameter. // Construct a subproblem G' based on V' or partitions. p = RecursiveSSSP(G', s') // Solve subproblem to get potential function p // Phase 3: Global update using potential function p // Compute reduced costs w_p(u, v) = w(u, v) + p[u] - p[v] for all edges. // Apply the O(m)-time update procedure based on w_p to refine distance estimates d. d = LinearTimeUpdate(G, w, p, d_initial) // O(m) operation // Phase 4: Refinement / Handling remaining paths // This phase likely uses recursively adapted Fineman structures. // It might involve further iterations or recursive calls on residual problems // to ensure all shortest paths are found. // The number of iterations/refinements might be related to k = sqrt(n). for i = 1 to k: // Example structure, actual details may differ // Perform operations using recursive Fineman structures // Potentially more LinearTimeUpdate steps with refined potentials p_refined = RefinePotential(G, w, d) // Hypothetical refinement step d = LinearTimeUpdate(G, w, p_refined, d) return d

The complexity analysis likely follows a recurrence relation. If each recursive level involves $O(m)$ work plus recursive calls on smaller instances, and the depth or number of iterations at each level is controlled appropriately (e.g., by the $k \approx \sqrt{n}$ parameter), the total time can be bounded. A simplified recurrence might look like $T(n, m) = T(n/k, m') + O(k \cdot m)$, where $k \approx \sqrt{n}$. Solving such a recurrence (with appropriate adjustments for $m'$ and polylogarithmic factors) leads to the $\tilde{O}(m\sqrt{n})$ expected time complexity. The randomization likely comes into play during the selection of subsets/pivots ($V'$) or within the adapted Fineman structures, leading to an expected time bound.

Implementation Considerations

• Data Structures: Implementing the algorithm requires standard graph representations (adjacency lists). The core challenge lies in implementing the recursive versions of Fineman's structures. The original structures might involve specialized heaps, dynamic trees, or other advanced data structures for maintaining potentials or distances under updates. The recursive adaptation needs careful implementation.
• Linear-Time Update: The exact procedure for the $O(m)$ update step using reduced costs needs to be implemented carefully based on the paper's description. It might be a specific sequence of scans over edges or nodes.
• Recursion Management: Standard techniques for recursion (managing call stacks, base cases) apply. The construction of subproblems ($G'$) and the integration of results ($\mathbf{p}$) back into the main problem are critical steps.
• Randomization: The source and use of randomness (e.g., vertex sampling) must be implemented correctly. The analysis relies on properties holding in expectation or with high probability.
• Constant Factors: While the asymptotic complexity is $\tilde{O}(m\sqrt{n})$, the constant factors hidden by the $\tilde{O}$ notation could be significant, especially due to the complexity of the underlying structures and the recursive overhead. Practical performance compared to simpler algorithms like SPFA (Shortest Path Faster Algorithm) or even standard Bellman-Ford on typical inputs would need empirical evaluation.
• Negative Cycles: The algorithm needs to correctly handle negative cycles reachable from the source. Like Bellman-Ford, this might involve detecting distances that continue to decrease after a certain number of iterations or updates, or detecting negative reduced costs in a specific context. The paper likely details how negative cycle detection integrates with the recursive framework.

Conclusion

The algorithm presented in "Randomized $\tilde{O}(m\sqrt{n})$ Bellman-Ford from Fineman and the Boilermakers" (2503.22613) marks a substantial theoretical improvement for the SSSP problem with potentially negative edge weights. By combining a key insight about linear-time updates using reduced costs with a recursive adaptation of Fineman's structures, it achieves an expected time complexity of $\tilde{O}(m\sqrt{n})$. Implementing this algorithm requires careful handling of the recursive structure, the specific linear-time update mechanism, and potentially complex underlying data structures derived from Fineman's work. Its practical efficiency relative to its asymptotic complexity remains an area for empirical investigation.