Average Update Times for Fully-Dynamic All-Pairs Shortest Paths

Fully Dynamic Algorithms for Maintaining Shortest Paths Trees

We study the problem of maintaining the distances and the shortest paths from a source node in a directed graph with arbitrary arc weights, when weight updates of arcs are performed. We propose algorithms that work for any graph and require linear space and optimal query time. If a negative{length cycle is added during weight-decrease operations it is detected by the algorithms. The algorithms explicitly deal with zero{length cycles. We show that, if the graph has a k-bounded accounting function (as in the case of graphs with genus, arboricity, degree, treewidth or pagenumber bounded by k, and k-inductive graphs) the algorithms require O(k ċ n ċ log n) worst case time. In the case of graphs with n nodes and m arcs k = O(√m); this gives O(√m ċ n ċ log n) worst case time per operation, which is better for a factor of O(√m log n) than recomputing everything from scratch after each update. If we perform also insertions and deletions of arcs, then the above bounds become amortized.

In this paper we propose an experimental study model S3P2 of a fast fully dynamic programming algorithm design technique in finite directed graphs with few distinct nonnegative real edge weights. The Bellman-Ford’s approach for shortest path problems has come out in various implementations. In this paper the approach once again is re-investigated with adjacency matrix selection in associate least running time. The model tests proposed algorithm against arbitrarily but positive valued weighted digraphs introducing notion of Prograph that speeds up finding the shortest path over previous implementations. Our experiments have established abstract results with the intention that the proposed algorithm can consistently dominate other existing algorithms for Single Source Shortest Path Problems. A comparison study is also shown among Dijkstra’s algorithm, Bellman-Ford algorithm, and our algorithm.

We present a method for solving the transshipment problem - also known as uncapacitated minimum cost flow - up to a multiplicative error of $1 + \varepsilon$ in undirected graphs with non-negative edge weights using a tailored gradient descent algorithm. Using $\tilde{O}(\cdot)$ to hide polylogarithmic factors in $n$ (the number of nodes in the graph), our gradient descent algorithm takes $\tilde O(\varepsilon^{-2})$ iterations, and in each iteration it solves an instance of the transshipment problem up to a multiplicative error of $\operatorname{polylog} n$. In particular, this allows us to perform a single iteration by computing a solution on a sparse spanner of logarithmic stretch. Using a randomized rounding scheme, we can further extend the method to finding approximate solutions for the single-source shortest paths (SSSP) problem. As a consequence, we improve upon prior work by obtaining the following results: (1) Broadcast CONGEST model: $(1 + \varepsilon)$-approximate SSSP using $\tilde{O}((\sqrt{n} + D)\varepsilon^{-3})$ rounds, where $ D $ is the (hop) diameter of the network. (2) Broadcast congested clique model: $(1 + \varepsilon)$-approximate transshipment and SSSP using $\tilde{O}(\varepsilon^{-2})$ rounds. (3) Multipass streaming model: $(1 + \varepsilon)$-approximate transshipment and SSSP using $\tilde{O}(n)$ space and $\tilde{O}(\varepsilon^{-2})$ passes. The previously fastest SSSP algorithms for these models leverage sparse hop sets. We bypass the hop set construction; computing a spanner is sufficient with our method. The above bounds assume non-negative edge weights that are polynomially bounded in $n$; for general non-negative weights, running times scale with the logarithm of the maximum ratio between non-zero weights.

The distributed single-source shortest paths problem is one of the most fundamental and central problems in the message-passing distributed computing. Classical Bellman-Ford algorithm solves it in O(n) time, where n is the number of vertices in the input graph G. Peleg and Rubinovich, FOCS'99, showed a lower bound of Ω(D + √n) for this problem, where D is the hop-diameter of G.

We present an experimental study of the single source shortest path problem with non-negative edge weights (NSSP) on large-scale graphs using the Δ-stepping parallel algorithm. We report performance results on the Cray MTA-2, a multithreaded parallel computer. The MTA-2 is a high-end shared memory system offering two unique features that aid the efficient parallel implementation of irregular algorithms: the ability to exploit fine-grained parallelism, and low-overhead synchronization primitives. Our implementation exhibits remarkable parallel speedup when compared with competitive sequential algorithms, for low-diameter sparse graphs. For instance, Δ-stepping on a directed scale-free graph of 100 million vertices and 1 billion edges takes less than ten seconds on 40 processors of the MTA-2, with a relative speedup of close to 30. To our knowledge, these are the first performance results of a shortest path problem on realistic graph instances in the order of billions of vertices and edges.

Improved shortest path algorithms for nearly acyclic graphs

This article presents a novel shortest path algorithm for connected networks with nonnegative edge weights. The worst case running time of the single source shortest path version of the algorithm is O(max(m, )) where m is the number of edges of the input network and is the normalized eccentricity of the source vertex vs. The pseudo‐polynomial nature of the time complexity is overcome with a simple speed‐up technique. The proposed approach can be implemented on a wide class of shortest path problems. Approximate solutions can be easily maintained in the preprocessing phase. An experimental efficiency analysis shows that the proposed approach outperforms existing algorithms in total computing time. The proposed algorithm is efficient for all classes of networks and particularly for networks with small diameter.

Emerging automotive engineering solutions extensively rely on navigation tools. Shortest path evaluation is core competency of optimal path planning, one of the most critical component of any navigation application. Fibonacci heap variant of state-of-the-art Dijkstra’s algorithm solve single source shortest path problems in asymptotic O(E + V log V) worst-case time. In spite Fibonacci heap is theoretically dominant in time efficiency, it might not work much better empirically with real-world data, because although large and intricate, the real-world road network graphs are sparse and the graph topology greatly affects the performance of the algorithms. SGO algorithm, a more efficient approch to address single source shortest path problem, is applied to solve optimal path planning problem in automotive navigation applications. Each road segment of the road graph leads to a particular location thus will hold unique distance values all the time. The SGO calculates the total distance from start location to the end of the each road segment and evaluates shortest path based on these calculations. The SGO algorithm and the Fibonacci and Binary heap variants of Dijkstra’s algorithm were tested on real-world intercity and intra-city road network graphs to evaluate running time efficiency of the algorithms in automotive navigation systems. The experimental results show that the SGO algorithm outperformed both the variants. The empirical superiority of the SGO algorithm suggests its usefulness in automotive navigation systems.

We study the behavior of a Max-Min Ant System (MMAS) on the stochastic single-destination shortest path (SDSP) problem. Two previous papers already analyzed this setting for two slightly different MMAS algorithms, where the pheromone update fitness-independently rewards edges of the best-so-far solution.The first paper showed that, when the best-so-far solution is not reevaluated and the stochastic nature of the edge weights is due to noise, the MMAS will find a tree of edges successfully and efficiently identify a shortest path tree with minimal noise-free weights. The second paper used reevaluation of the best-so-far solution and showed that the MMAS finds paths which beat any other path in direct comparisons, if existent. For both results, for some random variables, this corresponds to a tree with minimal expected weights.In this work we analyze a variant of MMAS that works with fitness-proportional update on stochastic-weight graphs with arbitrary random edge weights from [0,1]. For δ such that any suboptimal path is worse by at least δ than an optimal path, then, with suitable parameters, the graph will be optimized after O(n3 ln n/δ over δ3 iterations (in expectation).In order to prove the above result, the multiplicative and the variable drift theorem are adapted to continuous search spaces.

One of the most famous and most studied problems of operations research is the traveling salesman problem. Despite its simple formulation, it has found application in many different fields and to this day is the subject of active research, both related to the development of new methods and approaches to its solution and the creation of generalized problem statements and new mathematical models for their formalization. This paper is devoted to the study of the influence of two types of additional constraints on the speed of the Gurobi and CPLEX programs when solving a special class of routing problems. Formulations of problems of finding the shortest cycle and path that visits a given number of vertices from the graph clusters are presented. Mathematical models of mixed integer linear programming for their solution based on Miller, Tucker and Zemlin constraints and on Gavish and Graves constraints are described. The results of computational experiments are presented, which demonstrate the impact of additional constraints on the speed of solving problems using these models.

We present an algorithm for computing the closest point, transform to an explicitly described manifold on a rectilinear grid in low dimensional spaces. The closest point transform finds the closest point on a manifold and the Euclidean distance to a manifold for the points in a grid. We consider manifolds composed of simple geometric shapes, such as, a set of points, piecewise linear curves or triangle meshes. The algorithm solves the eikonal equation |∇u| = 1 with the method of characteristics. For many problems, the computational complexity of the algorithm is linear in both the number of grid points and the complexity of the manifold. Many query problems can be aided by using orthogonal range queries (ORQ). There are several standard data structures for performing ORQ's in 3-D, including kd-trees, octrees, and cell arrays. We develop additional data structures based on cell arrays. We study the characteristics of each data structure and compare their performance. We present a new algorithm for solving the single-source, non-negative weight, shortest-paths problem. Dijkstra's algorithm solves this problem with computational complexity O ((E + V)log V) where E is the number of edges and V is the number of vertices. The new algorithm, called Marching with a Correctness Criterion (MCC), has computational complexity O (E + RV), where R is the ratio of the largest to smallest edge weight. Sethian's Fast Marching Method (FMM) may be used to solve static Hamilton-Jacobi equations. It has computational complexity O (N log N), where N is the number of grid points. The FMM has been regarded as an optimal algorithm because it is closely related to Dijkstra's algorithm. The new shortest-paths algorithm discussed above can be used to develop an ordered, upwind, finite difference algorithm for solving static Hamilton-Jacobi equations. This algorithm requires difference schemes that difference not only in coordinate directions, but in diagonal directions as well. It has computational complexity O(RN), where R is the ratio of the largest to smallest propagation speed and N is the number of grid points.

The problem of processing shortest pa th queries in graphs arises in application areas such as intelligent t ranspor ta t ion system (ITS), geographic information system (GIS), and robotics. In this paper, we present an efficient algorithmic solution for processing shortest pa th queries in undirected planar graphs with non-negative edge weights. Previous algorithms for this problem on planar graphs all have a tradeoff between the query t ime and the da ta structure space used by the solutions. The previously best known trade-off on an n-vertex planar graph G in the worst case is O(v/-r) t ime for a pa th length query and O(v/-r + L) t ime for report ing an actual shortest path, with a da ta structure of O(n2/x/~) space, where r is an integer parameter with 1 < r _< n and L is the number of edges on the output shortest path. We present a new scheme, called frame search, that exploits the graph planari ty in a novel fashion. Wi th this scheme, we build an improved da ta structure of O(n + pv/-r + p2/r) space (in O(n + p2/v/~ + pr 3/4) time), where p is the minimum cardinality of a face-covering of the planar embedding of G with 1 < p < O(n), and r is an integer parameter with 1 < r < p. This da ta structure enables us to process each length query in O(v/-rlog r + a(n)) t ime and report an actual shortest path in an addit ional O(L) time, where a(n) is the inverse of Ackermann's function. In the worst case, our approach reduces the previously best query t ime by a factor of up to O(n 1/4) if the same amount of space is used. Our technique can also be applied to improve the previous query algorithms for some geometric shortest pa th problems on the plane.

Solving all-pairs shortest path by single-source computations: Theory and practice

We address the problem of finding a polynomial-time approximation scheme for shortest bounded-curvature paths in the presence of obstacles. Given an arbitrary environment $\mathcal{E}$ consisting of polygonal obstacles, two feasible configurations, a length l, and an approximation factor e, our algorithm either (i) verifies that every feasible bounded-curvature path joining the two configurations is longer than l or (ii) constructs such a path Π whose length is at most (1 + e) times the length of the shortest such path. The run time of our algorithm is polynomial in n (the total number of obstacle vertices and edges in $\mathcal{E}$), m (the bit precision of the input), e -1, and l. For general polygonal environments, there is no known upper bound on the length, or description, of a shortest feasible bounded-curvature path as a function of n and m. Furthermore, even if the length and description of a shortest path are known to be linear in n and m, finding such a path is known to be NP-hard [14]. Previous results construct (1 + e) approximations to the shortest e-robust bounded-curvature path [11,3] in time that is polynomial in n and e -1. (Intuitively, a path is e-robust if it remains feasible when simultaneously twisted by some small amount at each of its environment contacts.) Unfortunately, e-robust solutions do not exist for all problem instances that admit bounded-curvature paths. Furthermore, even if a e-robust path exists, the shortest bounded-curvature path may be arbitrarily shorter than the shortest e-robust path. In effect, these earlier results confound two distinct sources of problem difficulty, measured by e -1 and l. Our result is not only more general, but it also clarifies the critical factors contributing to the complexity of bounded-curvature motion planning.