Let G = (V; E) be an unweighted undirected graph on n vertices. A simple argument shows that computing all distances in G with an additive one-sided error of at most 1 is as hard as Boolean matrix multiplication. Building on recent work of Aingworth, Chekuri and Motwani, we describe g) time algorithm APASP 2 for computing all distances in G with an additive one-sided error of at most 2. The algorithm APASP 2 is simple, easy to implement, and faster than the fastest known matrix multiplication algorithm. Furthermore, for every even k ? 2, we describe an g) time algorithm APASP k for computing all distances in G with an additive one-sided error of at most k.

We investigate the all-pairs shortest paths problem in weighted graphs. We present an algorithm---the Hidden Paths Algorithm---that finds these paths in time O(m* n+n² 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 log n) 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 effective in this more general setting.

We first consider the problem of partitioning the edges of a graph G into bipartite cliques such that the total order of the cliques is minimized, where the order of a clique is the number of vertices in it. It is shown that the problem is NP-complete. We then prove the existence of a partition of small total order in a sufficiently dense graph and devise an efficient algorithm to compute such a partition. It turns out that our algorithm exhibits a trade-off between the total order of the partition and the running time. Next, we define the notion of a compression of a graph G and use the result on graph partitioning to efficiently compute an optimal compression for graphs of a given size. An interesting application of the graph compression result arises from the fact that several graph algorithms can be adapted to work with the compressed representation of the input graph, thereby improving the bound on their running times, particularly on dense graphs. This makes use of the trade-off ...

. Koml'os has devised a way to use a linear number of binary comparisons to test whether a given spanning tree of a graph with edge costs is a minimum spanning tree. The total computational work required by his method is much larger than linear, however. We describe a linear-time algorithm for verifying a minimum spanning tree. Our algorithm combines the result of Koml'os with a preprocessing and table look-up method for small subproblems and with a previously known almost-linear-time algorithm. Additionally, we present an optimal deterministic algorithm and a linear-time randomized algorithm for sensitivity analysis of minimum spanning trees. 1. Introduction. Suppose we wish to solve some problem for which we know in advance the size of the input data, using an algorithm from some well-defined class of algorithms. For example, consider sorting n numbers, when n is fixed in advance, using a binary comparison tree. Given a sufficient amount of preprocessing time and storage space, we ca...

We present two new algorithms for solving the All Pairs Shortest Paths (APSP) problem for weighted directed graphs. Both algorithms use fast matrix multiplication algorithms. The first algorithm solves...

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 show that the All Pairs Shortest Paths (APSP) problem for undirected graphs with integer edge weights taken from the range f1; 2; : : : ; Mg can be solved using only a logarithmic number of distance products of matrices with elements in the range f1; 2; : : : ; Mg. As a result, we get an algorithm for the APSP problem in such graphs that runs in ~ O(Mn ! ) time, where n is the number of vertices in the input graph, M is the largest edge weight in the graph, and ! ! 2:376 is the exponent of matrix multiplication. This improves, and also simplifies, an ~ O(M (!+1)=2 n ! ) time algorithm of Galil and Margalit. 1. Introduction The All Pairs Shortest Paths (APSP) problem is one of the most fundamental algorithmic graph problems. The APSP problem for directed or undirected graphs with real weights can be solved using classical methods, in O(mn + n 2 log n) time (Dijkstra [4], Johnson [10], Fredman and Tarjan [7]), or in O(n 3 ((log log n)= log n) 1=2 ) time (Fredman [6], ...

We present two new algorithms for solving the All Pairs Shortest Paths (APSP) problem for weighted directed graphs. Both algorithms use fast matrix multiplication algorithms. The first algorithm solves the APSP problem for weighted directed graphs in which the edge weights are integers of small absolute value in ~ O(n 2+ ) time, where satisfies the equation !(1; ; 1) = 1 + 2 and !(1; ; 1) is the exponent of the multiplication of an n \Theta n matrix by an n \Theta n matrix. The currently best available bounds on !(1; ; 1), obtained by Coppersmith and Winograd, and by Huang and Pan, imply that ! 0:575. The running time of our algorithm is therefore O(n 2:575 ). Our algorithm improves on the ~ O(n (3+!)=2 ) time algorithm, where ! = !(1; 1; 1) ! 2:376 is the usual exponent of matrix multiplication, obtained by Alon, Galil and Margalit, whose running time is only known to be O(n 2:688 ). The second

In the first part of the paper, we reexamine the all-pairs shortest paths (APSP) problem and present a new algorithm with running time O(n 3 log 3 log n / log 2 n), which improves all known algorithms for general real-weighted dense graphs. In the second part of the paper, we use fast matrix multiplication to obtain truly subcubic APSP algorithms for a large class of “geometrically weighted ” graphs, where the weight of an edge is a function of the coordinates of its vertices. For example, for graphs embedded in Euclidean space of a constant dimension d, we obtain a time bound near O(n 3−(3−ω)/(2d+4)), where ω < 2.376; in two dimensions, this is O(n 2.922). Our framework greatly extends the previously considered case of small-integer-weighted graphs, and incidentally also yields the first truly subcubic result (near O(n 3−(3−ω)/4) = O(n 2.844) time) for APSP in real-vertex-weighted graphs, as well as an improved result (near O(n (3+ω)/2) = O(n 2.688) time) for the all-pairs lightest shortest path problem for small-integer-weighted graphs. 1

The following algorithm solves the distance version of the all-pairs-shortest-path problem for undirected, unweighed n-vertex graphs in time O(&f(rJ) log n), where M(n) denotes the time necessary to multiply two n x n matrices of small integers (which is currently known to be o(n2376)): Input: n x n O-1 matrix A, the adjacency matrix of undirected, connected graph G’ Output: n x n integer matrix D, with dij the length of a shortest path joining vertices i and j in G function APD(A: n x n O-1 matrix) : n x n integer matrix let Z=A. A let B be an n x n O-1 matrix, where bij = 1 iff i # j and (aij = 1 or ~tj> O) if bij = 1 for all i # j then return n x n matrix D = 2B – A let T = APD(B) let X=T. A 2tij if Zij ~ tij. degree(j) return n x n matrix D, where dij = Zt ij – 1 if Xij < tij. degree(j) We also address the problem of actually finding a shortest path between each pair of vertices and present a randomized algorithm that matches APD() in its simplicity and in its expected running time. 1. Computing All Dktances In the following let G be an undirected, unweighed, connected graph with vertex set {1, 2,..., n} and adja-cency matrix A, and let dij denote the number of edges on a shortest path joining vertices i and j in G. In this section we show that the function APD() computes all dij correctly within the claimed time bound. Claim 1 Let Z = A oA. There is a path of length 2 in G between vertices i and j iff ~ij>0. Proofi There is a length 2 path joining i and j iff there is a vertex k adjacent to both i and j, which is exactly ‘he Cme ‘f ‘ij = ~l<k~n aikakj>0- ❑ “Supported by NSF Presidential Young Investigator Award