We survey recent and not so recent results related to the computation of exact and approximate distances, and corresponding shortest, or almost shortest, paths in graphs. We consider many different settings and models and try to identify some remaining open problems.

We present a simple shortest path algorithm. If the input lengths are positive and uniformly distributed, the algorithm runs in linear time. The worst-case running time of the algorithm is O(m + n log C), where n and m are the number of vertices and arcs of the input graph, respectively, and C is the ratio of the largest and the smallest nonzero arc length.

We review shortest path algorithms based on the multi-level bucket data structure [6] and discuss the interplay between theory and engineering choices that leads to e#cient implementations. Our experimental results suggest that the caliber heuristic [17] and adaptive parameter selection give an e#cient algorithm, both on typical and on hard inputs, for a wide range of arc lengths.

Smoothed analysis combines elements over worst-case and average case analysis. For an instance x the smoothed complexity is the average complexity of an instance obtained from x by a perturbation. The smoothed complexity of a problem is the worst smoothed complexity of any instance. Spielman and Teng introduced this notion for continuous problems. We apply the concept to combinatorial problems and study the smoothed complexity of three classical discrete problems: quicksort, left-to-right maxima counting, and shortest paths. This opens a vast eld of nice analyses (using for example generating functions in the discrete case) which should lead to a better understanding of complexity landscapes of algorithms.

We consider Fibonacci heap style integer priority queues supporting insert and decrease key operations in constant time. We present a deterministic linear space solution that with n integer keys support delete in O(log log n) time. If the integers are in the range [0,N), we can also support delete in O(log log N) time. Even for the special case of monotone priority queues, where the minimum has to be non-decreasing, the best previous bounds on delete were O((log n) 1/(3−ε) ) and O((log N) 1/(4−ε)). These previous bounds used both randomization and amortization. Our new bounds a deterministic, worst-case, with no restriction to monotonicity, and exponentially faster. As a classical application, for a directed graph with n nodes and m edges with non-negative integer weights, we get single source shortest paths in O(m + n log log n) time, or O(m + n log log C) ifC is the maximal edge weight. The later solves an open problem of Ahuja, Mehlhorn, Orlin, and

We present an undirected all-pairs shortest paths (APSP) algorithm which runs on a pointer machine in time O(mnot(m, n)) while making O(ran log a(m, n)) compar-isons and additions, where m and n are the number of edges and vertices, respectively, and a(ra, n) is Tarjan's inverse-Ackermann function. This improves upon all previous com-parison & addition-based APSP algorithms when the graph is sparse, i.e., when m = o(n log n). At the heart of our APSP algorithm is a new single-source shortest paths algorithm which runs in time O(ma(m,n) + nloglogr) on a pointer machine, where r is the ratio of the maximum-to-minimum edge length. So long as r < 2 '~°(a) this algorithm is faster than any implemen-tation of Dijkstra's classical algorithm in the comparison-addition model. For directed graphs we give an O(ra + nlogr)-time comparison & addition-based SSSP algorithm on a pointer machine. Similar algorithms assuming integer weights or the RAM model were given earlier.

Abstract. We present a new scheme for computing shortest paths on real-weighted undirected graphs in the fundamental comparison-addition model. In an efficient preprocessing phase our algorithm creates a linear-size structure that facilitates single-source shortest path computations in O(m log α) time, where α = α(m, n) is the very slowly growing inverse-Ackermann function, m the number of edges, and n the number of vertices. As special cases our algorithm implies new bounds on both the all-pairs and single-source shortest paths problems. We solve the all-pairs problem in O(mnlog α(m, n)) time and, if the ratio between the maximum and minimum edge lengths is bounded by n (log n)O(1) , we can solve the single-source problem in O(m + nlog log n) time. Both these results are theoretical improvements over Dijkstra’s algorithm, which was the previous best for real weighted undirected graphs. Our algorithm takes the hierarchy-based approach invented by Thorup. Key words. single-source shortest paths, all-pairs shortest paths, undirected graphs, Dijkstra’s

We describe several implementations of the kinetic heap, a heap (priority queue) in which the key of each item, instead of being xed, is a linear function of time. The kinetic heap is a simple example of a kinetic data structure of the kind considered by Basch, Guibas, and Hershberger. Kinetic heaps have many applications in computational geometry, and previous implementations were designed to address these applications. We describe an additional application, to broadcast scheduling. Each of our kinetic heap implementations improves on previous implementations by being simpler or asymptotically faster for some or all applications.

We introduce the heap-on-top (hot) priority queue data structure that combines the multi-level bucket data structure of Denardo and Fox and a heap. We use the new data structure to obtain an O(m + n(log C) 1 3 +ffl ) expected time implementation of Dijkstra's shortest path algorithm, improving the previous bounds. We can implement hot queues even more efficiently in practice by using sorted lists to represent small priority queues. Our experimental results in the context of Dijkstra's algorithm show that this implementation of hot queues performs very well and is more robust than implementations based only on heap or multi-level bucket data structures. 1 Introduction A priority queue is a data structure that maintains a set of elements and supports operations insert, decrease-key, and extract-min. Priority queues are fundamental data structures with many applications. Typical applications include graph algorithms (e.g. [14]) and event simulation (e.g. [5]). An important subclass of...

We present an improvement of the multi-level bucket shortest path algorithm of Denardo and Fox [9] and justify this improvement, both theoretically and experimentally. We prove that if the input arc lengths come from a natural probability distribution, the new algorithm runs in linear average time while the original algorithm does not. We also describe an implementation of the new algorithm. Our experimental data suggests that the new algorithm is preferable to the original one in practice. Furthermore, for integral arc lengths that fit into a word of today's computers, the performance is close to that of breadth-first search, suggesting limitations on further practical improvements.