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

Let G = (V, E) be a weighted undirected graph with |V | = n and |E | = m. An estimate ˆ δ(u, v) of the distance δ(u, v) between u, v ∈ V is said to be of stretch t iff δ(u, v) ≤ ˆ δ(u, v) ≤ t · δ(u, v). Computing distances of small stretch efficiently is a well-studied problem in graph algorithms. The most efficient algorithms known here are the approximate distance oracles of [16] and the three algorithms in [9] to compute all-pairs stretch t distances for t = 2, 7/3, and 3. We present faster algorithms for these problems. For any integer k ≥ 1, Thorup and Zwick in [16] gave an O(kmn 1/k) algorithm to construct a data structure of size O(kn 1+1/k) to answer approximate distance queries. For a query (u, v) ∈ V × V, the distance returned is of stretch at most 2k−1. The query answering time is O(k), which is essentially a constant since we are interested in small-stretch distances, or equivalently, small values of k. But for small values of k, the time to construct the oracle is rather high. The case k = 2 is particularly interesting and the Thorup-Zwick algorithm takes O(m √ n) time, which could be as large as Θ(n 5/2). Here we present an O(n 2 log n) algorithm to construct such a data structure of size O(kn 1+1/k) for all integers k ≥ 2. Our query answering time is O(k) for k> 2 and Θ(log n) for k = 2. We obtain these results with a new generic scheme for all-pairs approximate shortest paths. Using this scheme, we also design faster algorithms for all-pairs t-stretch distances for t = 2, 7/3, 3. 1.

Abstract. Let G(V, E) be an unweighted undirected graph on |V | = n vertices. Let δ(u, v) denote the shortest distance between vertices u, v ∈ V. An algorithm is said to compute all-pairs t-approximate shortestpaths/distances, for some t ≥ 1, if for each pair of vertices u, v ∈ V, the path/distance reported by the algorithm is not longer/greater than t · δ(u, v). This paper presents two randomized algorithms for computing allpairs nearly 2-approximate distances. The first algorithm takes expected O(m 2/3 n log n+n 2) time, and for any u, v ∈ V reports distance no greater than 2δ(u, v) + 1. Our second algorithm requires expected O(n 2 log 3/2) time, and for any u, v ∈ V reports distance bounded by 2δ(u, v) + 3. This paper also presents the first expected O(n 2) time algorithm to compute all-pairs 3-approximate distances. 1

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 study the problem of computing the diameter of a network in a distributed way. The model of distributed computation we consider is: in each synchronous round, each node can transmit a different (but short) message to each of its neighbors. We provide an ˜ Ω(n) lower bound for the number of communication rounds needed, where n denotes the number of nodes in the network. This lower bound is valid even if the diameter of the network is a small constant. We also show that a (3/2 − ε)approximation of the diameter requires ˜ Ω ( √ n) rounds. Furthermore we use our new technique to prove an ˜ Ω ( √ n) lower bound on approximating the girth of a graph by a factor 2 − ε. Contact author:

Given an undirected graph G with m edges, n vertices, and non-negative edge weights, and given an integer k ≥ 1, we show that for some universal constant c, a (2k − 1)approximate distance oracle for G of size O(kn 1+1/k) can be constructed in O ( √ km+kn 1+c/ √ k) time and can answer queries in O(k) time. We also give an oracle which is faster for smaller k. Our results break the quadratic preprocessing time bound of Baswana and Kavitha for all k ≥ 6 and improve the O(kmn 1/k) time bound of Thorup and Zwick except for very sparse graphs and small k. When m = Ω(n 1+c/ √ k) and k = O(1), our oracle is optimal w.r.t. both stretch, size, preprocessing time, and query time, assuming a widely believed girth conjecture by Erdős. 1

Shortest path problems can be solved very efficiently when a directed graph is nearly acyclic. Earlier results defined a graph decomposition, now called the 1-dominator set, which consists of a unique collection of acyclic structures with each single acyclic structure dominated by a single associated trigger vertex. In this framework, a specialised shortest path algorithm only spends delete-min operations on trigger vertices, thereby making the computation of shortest paths through non-trigger vertices easier. A previously presented algorithm computed the 1-dominator set in O(mn) worst-case time, which allowed it to be integrated as part of an O(mn + nr log r) time all-pairs algorithm. Here m and n respectively denote the number of edges and vertices in the graph, while r denotes the number of trigger vertices. A new algorithm presented in this paper computes the 1-dominator set in just O(m) time. This can be integrated as part of the O(m+r log r) time spent solving single-source, improving on the value of r obtained by the earlier tree-decomposition single-source algorithm. In addition, a new bi-directional form of 1-dominator set is presented, which further improves the value of r by defining acyclic structures in both directions over edges in the graph. The bi-directional 1-dominator set can similarly be computed in O(m) time and included as part of the O(m + r log r) time spent computing single-source. This paper also presents a new all-pairs algorithm under the more general framework where r is defined as the size of any predetermined feedback vertex set of the graph, improving the previous all-pairs time complexity from O(mn + nr 2) to O(mn + r 3).

This paper presents new algorithms for computing shortest paths in a nearly acyclic directed graph G = (V, E). The new algorithms improve on the worst-case running time of previous algorithms. Such algorithms use the concept of a 1-dominator set. A 1-dominator set divides the graph into a unique collection of acyclic subgraphs, where each acyclic subgraph is dominated by a single associated trigger vertex. The previous time for computing a 1dominator set is improved from O(mn) to O(m), where m = |E| and n = |V|. Efficient shortest...

In a weighted, directed graph an L-bounded leg path is one whose constituent edges have length at most L. For any fixed L, computing L-bounded leg shortest paths is just as easy as the standard shortest path algorithm. In this paper we study approximate distance oracles (and reachability oracles) for bounded leg path problems, where the leg bound L is not known in advance, but forms part of the query. Bounded-leg path problems are more complicated than standard shortest path problems because the number of distinct shortest paths between two vertices (over all leg bounds) could be as large as the number of edges in the graph. The bounded leg constraint models situations where there is some limited resource that must be spent when traversing an edge. For example, the size of a fuel tank or the life of a battery places a hard limit on how far a vehicle can travel in one leg before refueling or recharging. Someone making a long road trip may place a hard limit on how many hours they are willing to drive in any one day. Our main result is a nearly optimal algorithm for preprocessing a directed graph in order to answer approximate bounded leg distance and bounded leg shortest path queries. In particular, we can preprocess any graph in Õ(n3) time, producing a data structure with size Õ(n2) that answers (1 + ɛ)-approximate bounded leg distance queries in O(log log n) time. If the corresponding (1 + ɛ)-approximate shortest path has l edges it can be returned in O(l log log n) time. These bounds are all within polylog(n) factors of the best standard all-pairs shortest path algorithm and improve substantially the previous best bounded leg shortest path algorithm, whose preprocessing time and space are O(n 4) and Õ(n 2.5). We also consider bounded leg oracles in other situations. In the context of planar directed graphs we give a time-space tradeoff for answering bounded leg reachability queries. For any k ≥ 2 we can build a data structure with size O(kn 1+1/k) that answers reachability queries in time

Abstract. Let G = (V, E) be a weighted undirected graph having non-negative edge weights. An estimate ˆ δ(u, v) of the actual distance δ(u, v) between u, v ∈ V is said to be of stretch t iff δ(u, v) ≤ ˆ δ(u, v) ≤ t · δ(u, v). Computing all-pairs small stretch distances efficiently (both in terms of time and space) is a well-studied problem in graph algorithms. We present a simple, novel and generic scheme for all-pairs approximate shortest paths. Using this scheme and some new ideas and tools, we design faster algorithms for all-pairs t-stretch distances for a whole range of stretch t, and also answer an open question posed by Thorup and Zwick in their