Faster algorithms for the shortest path problem (original) (raw)

A parallelization of Dijkstra's shortest path algorithm

Lecture Notes in Computer Science, 1998

The single source shortest path (SSSP) problem lacks parallel solutions which are fast and simultaneously work-e cient. We propose simple criteria which divide Dijkstra's sequential SSSP algorithm into a number of phases, such that the operations within a phase can be done in parallel. We give a PRAM algorithm based on these criteria and analyze its performance on random digraphs with random edge weights uniformly distributed in 0;1]. We use the G(n;d=n) model: the graph consists of n nodes and each edge is chosen with probability d=n. Our PRAM algorithm needs O(n 1=3 log n) time and O(n log n+dn) work with high probability (whp). We also give extensions to external memory computation. Simulations show the applicability of our approach even on non-random graphs. 1 Introduction Computing shortest paths is an important combinatorial optimization problem with numerous applications. Let G = (V; E) be a directed graph, jEj = m, jV j = n, let s be a distinguished vertex of the graph, and c be a function assigning a non-negative real-valued weight to each edge of G. The single source shortest path problem (SSSP) is that of computing, for each vertex v reachable from s, the weight dist(v) of a minimum-weight path from s to v; the weight of a path is the sum of the weights of its edges. The theoretically most e cient sequential algorithm on digraphs with nonnegative edge weights is Dijkstra's algorithm 8]. Using Fibonacci heaps its running time is O(n logn + m) 1. Dijkstra's algorithm maintains a partition of V into settled, queued and unreached nodes and for each node v a tentative distance tent(v); tent(v) is always the weight of some path from s to v and hence an upper bound on dist(v). For unreached nodes, tent(v) = 1. Initially, s is queued, tent(s) = 0, and all other nodes are unreached. In each iteration, the queued node v with smallest tentative distance is selected and declared settled and all edges (v; w) are relaxed, i.e., tent(w) is set to minftent(w); tent(v) + c(v; w)g. 1 There is also an O(n + m) time algorithm for undirected graphs 20], but it requires the RAM model instead of the comparison model which is used in this work.

Removing Sequential Bottleneck of Dijkstra's Algorithm for the Shortest Path Problem

arXiv (Cornell University), 2018

All traditional methods of computing shortest paths depend upon edge-relaxation where the cost of reaching a vertex from a source vertex is possibly decreased if that edge is used. We introduce a method which maintains lower bounds as well as upper bounds for reaching a vertex. This method enables one to find the optimal cost for multiple vertices in one iteration and thereby reduces the sequential bottleneck in Dijkstra's algorithm. We present four algorithms in this paper-SP1, SP2, SP3 and SP4. SP1 and SP2 reduce the number of heap operations in Dijkstra's algorithm. For directed acyclic graphs, or directed unweighted graphs they have the optimal complexity of O(e) where e is the number of edges in the graph which is better than that of Dijkstra's algorithm. For general graphs, their worst case complexity matches that of Dijkstra's algorithm for a sequential implementation but allows for greater parallelism. Algorithms SP3 and SP4 allow for even more parallelism but with higher work complexity. Algorithm SP3 requires O(n + e(max(log n, ∆))) work where n is the number of vertices and ∆ is the maximum in-degree of a node. Algorithm SP4 has the most parallelism. It requires O(ne) work. These algorithms generalize the work by Crauser, Mehlhorn, Meyer, and Sanders on parallelizing Dijkstra's algorithm.

Fibonacci heaps and their uses in improved network optimization algorithms

Journal of the ACM, 1987

In this paper we develop a new data structure for implementing heaps (priority queues). Our structure, Fibonacci heaps (abbreviated F-heaps ), extends the binomial queues proposed by Vuillemin and studied further by Brown. F-heaps support arbitrary deletion from an n -item heap in O (log n ) amortized time and all other standard heap operations in O (1) amortized time. Using F-heaps we are able to obtain improved running times for several network optimization algorithms. In particular, we obtain the following worst-case bounds, where n is the number of vertices and m the number of edges in the problem graph: O ( n log n + m ) for the single-source shortest path problem with nonnegative edge lengths, improved from O ( m log ( m/n +2) n ); O ( n 2 log n + nm ) for the all-pairs shortest path problem, improved from O ( nm log ( m/n +2) n ); O ( n 2 log n + nm ) for the assignment problem (weighted bipartite matching), improved from O ( nm log ( m/n +2) n ); O ( mβ ( m, n )) for the min...

An external memory data structure for shortest path queries

Discrete Applied Mathematics, 2003

We present results related to satisfying shortest path queries on a planar graph stored in external memory. Let N denote the number of vertices in the graph and sort(N ) denote the number of input=output (I=O) operations required to sort an array of length N :

Speed-Up Techniques for Shortest-Path Computations

Lecture Notes in Computer Science, 2007

During the last years, several speed-up techniques for Dijkstra's algorithm have been published that maintain the correctness of the algorithm but reduce its running time for typical instances. They are usually based on a preprocessing that annotates the graph with additional information which can be used to prune or guide the search. Timetable information in public transport is a traditional application domain for such techniques. In this paper, we provide a condensed overview of new developments and extensions of classic results. Furthermore, we discuss how combinations of speed-up techniques can be realized to take advantage from different strategies.

An O(mlog logD) algorithm for shortest paths

Discrete Applied Mathematics, 1983

A technique for implementing Dijkstra's shortest paths algorithm is proposed. This method runs in O(m log log D) time in the worst case, where m is the number of edges and D the length of the longest edge in the graph.

A new algorithm for the shortest-path problem

Networks, 2018

In this article we propose a new single‐source shortest‐path algorithm that achieves the same O(n · m) time bound as the Bellman‐Ford‐Moore algorithm but outperforms it and other state‐of‐the‐art algorithms in many cases in practice. Our claims are supported by experimental evidence.

Shortest Path Algorithms: Comparative Study and Analysis

shortest path problem is a fundamental technique in computer networking for route discovery. Utilizing the shortest path algorithms overall costs of setting the network is reduced. Many new technologies are implemented using the shortest path problem e.g. the road map system. Shortest path problem is an optimization technique [1] used in many applications. In this paper's different shortest path algorithms are studied i.e. Dijkstra's Algorithm, A* Search, FloydWarshall Algorithm, Johnson's Algorithm and Bellman-Ford Algorithm. We will study or analyze the behavior of different algorithms of shortest path in this paper. First we will study each algorithm to analyze its performance and then we will compare algorithms on the basis of their time complexity.

Speeding up shortest path algorithms

2012

Given an arbitrary, non-negatively weighted, directed graph G=(V,E) we present an algorithm that computes all pairs shortest paths in time O(m^* n + m n + nT_ψ(m^*, n)), where m^* is the number of different edges contained in shortest paths and T_ψ(m^*, n) is a running time of an algorithm to solve a single-source shortest path problem (SSSP). This is a substantial improvement over a trivial n times application of ψ that runs in O(nT_ψ(m,n)). In our algorithm we use ψ as a black box and hence any improvement on ψ results also in improvement of our algorithm. Furthermore, a combination of our method, Johnson's reweighting technique and topological sorting results in an O(m^*n + m n) all-pairs shortest path algorithm for arbitrarily-weighted directed acyclic graphs. In addition, we also point out a connection between the complexity of a certain sorting problem defined on shortest paths and SSSP.