Introduction A natural and well-studied problem in algorithmic graph theory and network optimization is that of computing a "shortest path" between two nodes, s and t, in a graph whose edges have "weights" associated with them, and we consider the "length" of a path to be the sum of the weights of the edges that comprise it. Efficient algorithms are well known for this problem, as briefly summarized below. The shortest path problem takes on a new dimension when considered in a geometric domain. In contrast to graphs, where the encoding of edges is explicit, a geometric instance of a shortest path problem is usually specified by giving geometric objects that implicitly encode the graph and its edge weights. Our goal in devising efficient geometric algorithms is generally to avoid explicit construction of the entire underlying graph, since the full induced graph may be very large (even exponential in the input size, or infinite). Computing an optimal

In this paper, we consider Dijkstra's algorithm for the single source single target shortest paths problem in large sparse graphs. The goal is to reduce the response time for online queries by using precomputed information. For the result of the preprocessing, we admit at most linear space. We assume that a layout of the graph is given. From this layout, in the preprocessing, we determine for each edge a geometric object containing all nodes that can be reached on a shortest path starting with that edge. Based on these geometric objects, the search space for online computation can be reduced significantly. We present an extensive experimental study comparing the impact of different types of objects. The test data we use are traffic networks, the typical field of application for this scenario.

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], ...

A new algorithm is proposed for calculating the approximate shortest path on a polyhedral surface. The method mainly uses Dijkstra’s algorithm and is based on selective refinement of the discrete graph of a polyhedron. Although the algorithm is an approximation, it has the significant advantages of being fast, easy to implement, high approximation accuracy, and numerically robust. The approximation accuracy and computation time are compared between this approximation algorithm and the extended Chen & Han (ECH) algorithm that can calculate the exact shortest path for non-convex polyhedra. The approximation algorithm can calculate shortest paths within 0.4 % accuracy to roughly 100-1000 times faster than the ECH algorithm in our examples. Two applications are discussed of the approximation algorithm to geometric modeling.

The single source shortest path (SSSP) problem lacks parallel solutions which are fast and simultaneously work-efficient. 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

Floats are ugly, but to everyone but theoretical computer scientists, they are the real thing. A linear time algorithm is presented for the undirected single source shortest paths problem with positive floating point weights. 1 Introduction The technical goal of this paper is to present a linear time solution to the undirected single source shortest paths problem (USSSP) where the weights are positive floating points, or just floats. On a more philosophical level, the goal is to draw attention to the problem of making efficient algorithms for floats. Suppose, for example, we have an algorithm for the max-flow problem whose running time includes a factor log C, where C is the maximal capacity. If we allow floating points, such an algorithm is not even polynomial, i.e. log C is the exponent of C, and the exponent is stored with log log C bits. Floating points are at least as used as integers, by everybody but theoretical computer scientists, who seem to prefer integers. To multiply two...

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.

In this paper we propose the first experimental study of the fully dynamic single source shortest paths problem on directed graphs with positive real edge weights. In particular, we perform an experimental analysis of three different algorithms: Dijkstra's algorithm, and the two output bounded algorithms proposed by Ramalingam and Reps in [31] and by Frigioni, Marchetti-Spaccamela and Nanni in [18], respectively. The main goal of this paper is to provide a first experimental evidence for: (a) the effectiveness of dynamic algorithms for shortest paths with respect to a traditional static approach to this problem; (b) the validity of the theoretical model of output boundedness to analyze dynamic graph algorithms. Beside random generated graphs, useful to capture the "asymptotic" behavior of algorithms, we also develope experiments by considering a widely used graph from the real world, i.e., the Internet graph. Work partially supported by the ESPRIT Long Term Research Project...

Many real world problems, e.g. in personnel scheduling and transportation planning, can be modeled naturally as Constrained Shortest Path Problems (CSPPs), i.e., as Shortest Path Problems with additional constraints. A well studied problem in this class is the Resource Constrained Shortest Path Problem. Reduction techniques