An Efficient Algorithm for All Pair Shortest Paths

International Journal of Computer Applications, 2010

In this paper, we present an algorithm to compute all pairs optimized shortest paths in an unweighted and undirected graph with some additive error of at most 2.This algorithm can be extended for weighted graph also but it will not work for directed graph due to absence of commutative property. The algorithm runs in n 5/2) times, where n is the number of vertices in the graph. This algorithm is much simpler than the existing algorithms. A study of upper bounds on the size of a maximal independent set of such graphs has been performed.

International Journal of Computer Applications, 2012

Floyd Warshall's Algorithm is a simple and widely used algorithm to compute shortest path between all pairs of vertices in an edge weighted directed graph. It can also be used to detect the presence of negative cycles. Many researchers have given many other approaches for finding all pair shortest path but they reduced the complexity by using complex data structures. In this paper, we suggests a technique for finding shortest path based on Floyd Warshall's algorithm with reduced time complexity and also by not using complex data structures. We present an O(n ) 3 (   ) time algorithm for finding all pair shortest paths. Our proposed algorithm is an improvement on the previous algorithm whose best result was O(n 3 )

2009

Given a simple connected unweighted undirected graph G = (V (G), E(G)) with |V (G)| = n and |E(G)| = m, we present a new algorithm for the all-pairs shortest-path (APSP) problem. The running time of our algorithm is in O(n2 log n). This bound is an improvement over previous best known O(n2.376) time bound of Raimund Seidel (1995) for general graphs. The algorithm presented does not rely on fast matrix multiplication. Our algorithm with slight modifications, enables us to compute the APSP problem for unweighted directed graph in time O(n2 log n), improving a previous best known O(n2.575) time bound of Uri Zwick (2002).

2013

In 1985, Moffat-Takaoka (MT) algorithm was developed to solve the all pairs shortest path (APSP) problem. This algorithm manages to get time complexity of O(n² log n) expected time when the end-point independent model of probabilistic assumption is used. However, the use of a critical point introduced in this algorithm has made the implementation of this algorithm quite complicated and the running time of this algorithm is difficult to analyze. Therefore, this study introduces a new deterministic algorithm for the APSP that provides an alternative to the existing MT algorithm. The major advantages of this approach compared to the MT algorithm are its simplicity, intuitive appeal and ease of analysis. Moreover, the algorithm was shown to be efficient as the expected running time is the same O(n² log n). Performance of a good algorithm depends on the data structure used to speed up the operations needed by the algorithm such as insert, delete-min and decrease-key operations. In this s...

Algorithmica, 1995

The essential subgraph H of a weighted graph or digraph G contains an edge (v, w) if that edge is uniquely the least-cost path between its vertices. Let s denote the number of edges of H. This paper presents an algorithm for solving all-pairs shortest paths on G that requires O(ns + n 2 log n) worst-case running time. In general the time is equivalent to that of solving n single-source problems using only edges in H. For general models of random graphs and digraphs G, s = O(n log n) almost surely. The subgraph H is optimal in the sense that it is the smallest subgraph sufficient for solving shortest-path problems in G. Lower bounds on the largest-cost edge of H and on the diameter of H and G are obtained for general randomly weighted graphs. Experimental results produce some new conjectures about essential subgraphs and distances in graphs with uniform edge costs.

Siam Journal on Computing, 1993

We investigate the all-pairs shortest paths problem in weighted graphs. We present an algorithm|the Hidden Paths Algorithm|that nds these paths in time O(m n+n 2 log n), where m is the number of edges participating in shortest paths. Our algorithm is a practical substitute for Dijkstra's algorithm. We argue that m is likely to be small in practice, since m = O(n logn) with high probability for many probability distributions on edge weights. We also prove an (mn) lower bound on the running time of any path-comparison based algorithm for the all-pairs shortest paths problem. Path-comparison based algorithms form a natural class containing the Hidden Paths Algorithm, as well as the algorithms of Dijkstra and Floyd. Lastly, we consider generalized forms of the shortest paths problem, and show that many of the standard shortest paths algorithms are e ective in this more general setting. real interval 0; 1] or the uniform distribution on the range f1; : : :; n 2 g. The Hidden

Journal of Network and Computer Applications, 2018

We describe a new forward-backward method for an all-pairs shortest-paths (APSP) algorithm. While most APSP algorithms only scan edges forward, the algorithm proposed here also scans all edges backward because it assumes that edges in the outgoing and incoming adjacency lists of the vertices appear with the same importance. The running time of the algorithm on a directed graph with n vertices, and m edges and positive real-valued edge weights in a deterministic way is O(nδ 2 2 log δ (n−1)−1), and the space complexity is O(nδ 2 log δ (n−1)−1), where δ = m/n is the density of the graph. Simulations on graphs with up to 10000 vertices with real, positive weights show that our FB-APSP algorithm, using additional working space less than 75% of space used by Speed-Up Floyd-Warshall algorithm, is faster on large sparse graphs, particularly planar graphs.

Journal of Computer and System Sciences, 1997

The upper bound on the exponent, ω, of matrix multiplication over a ring that was three in 1968 has decreased several times and since 1986 it has been 2.376. On the other hand, the exponent of the algorithms known for the all pairs shortest path problem has stayed at three all these years even for the very special case of directed graphs with uniform edge lengths. In this paper we give an algorithm of time O n ν log 3 n , ν = (3 + ω)/2, for the case of edge lengths in {−1, 0, 1}. Thus, for the current known bound on ω, we get a bound on the exponent, ν < 2.688. In case of integer edge lengths with absolute value bounded above by M , the time bound is O (M n) ν log 3 n and the exponent is less than 3 for M = O(n α ), for α < 0.116 and the current bound on ω.

arXiv (Cornell University), 2021

The Floyd-Warshall algorithm is the most popular algorithm for determining the shortest paths between all pairs in a graph. It is very a simple and an elegant algorithm. However, if the graph does not contain any negative weighted edge, using Dijkstra's shortest path algorithm for every vertex as a source vertex to produce all pairs shortest paths of the graph works much better than the Floyd-Warshall algorithm for sparse graphs. Also, for the graphs with negative weighted edges, with no negative cycle, Johnson's algorithm still performs significantly better than the Floyd-Warshall algorithm for sparse graphs. Johnson's algorithm transforms the graph into a non-negative one by using the Bellman-Ford algorithm, then, applies the Dijkstra's algorithm. Thus, in general the Floyd-Warshall algorithm becomes very inefficient especially for sparse graphs. In this paper, we show a simple improvement on the Floyd-Warshall algorithm that will increases its performance especially for the sparse graphs, so it can be used instead of more complicated alternatives.

Discrete Applied Mathematics, 1982

A new algorithm to find the shortest paths between all pairs of nodes is presented. This algorithm makes use of a dual cost transformation and of a particular data structure. Its worst case time complexity is of the order of the third power of the number of nodes, and its space complexity is linear with the number of arcs. A comparison with existing algorithms is presented.