The paper presents a randomized algorithm that computes single-source shortest paths in a directed graph with real-valued edge weights — including negative weights — in time m^{1+o(1)}, where m is the number of edges. In plain terms, the running time is almost linear in the graph size. The algorithm is Las Vegas randomized, which means it always returns a correct answer and its stated running-time bound holds with high probability (the authors quantify “high probability” as at least 1 − 1/n^C for any fixed constant C). This improves on a long line of work: the 70-year-old Bellman–Ford algorithm was the standard for negative weights until recent subquadratic algorithms, and the new result pushes the running time down to nearly linear in m for the general real-weight case.

At a high level the authors build on a technique called shortcutting. The idea is to add carefully chosen extra edges (shortcut edges) to the graph so that shortest paths use fewer negative edges. Fewer negative edges, or “hops”, lets the algorithm use faster subroutines that assume only a small number of negative edges appear on shortest paths. Prior shortcutting approaches reduced the number of negative hops but could add many new edges and make the graph dense, which defeats the purpose. The main contributions here are an improved analysis of a routine called betweenness reduction and a new structural “unfolding” argument that together prevent the number of added edges from exploding across iterations.

Some of the concrete technical moves the paper uses are familiar from prior work but are combined and analyzed more tightly. The algorithm uses potential functions (a way to reweight edges so that some negative edges become non-negative without changing which paths are best) and a sampled subset of negative vertices to limit how many vertices appear “between” pairs of nodes in shortest paths (this is the betweenness measure). The authors show that these searches touch only about n^{1+o(1)} vertices overall, so the number of shortcut edges added in each iteration is only about m^{1+o(1)} rather than much larger. They also give an unfolding lemma that traces any shortcut edge back to a short certificate in the original graph, which lets them charge newly added edges to original edges and bound the total growth over many iterations. The paper also includes a preprocessing step that, by adding a small number of vertices, ensures each original vertex is incident to at most one negative edge; this simplifies later arguments.