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.

This paper studies the dynamic single-source shortest paths SSSP in Erdos-Renyi random graphs generated by Gn,i¾?p model. In 2014, Ding and Lin AAIM 2014, LNCS 8546, 197---207 first considered the dynamic SSSP in general digraphs with arbitrary positive weights, and devised a nontrivial local search algorithm named DSPI which takes at most $$On\cdot \max \{1, n\log n / m\}$$Oni¾?max{1,nlogn/m} expected update time to handle a single weight increase, where n is the number of nodes and m is the number of edges in the digraph. DSPI also works on undirected graphs. This paper analyzes the expected update time of DSPI dealing with edge weight increases or edge deletions in Erdos-Renyi a.k.a., Gn,i¾?p random graphs. For weighted Gn,i¾?p random graphs with arbitrary positive edge weights, DSPI takes at most $$OhT_s$$OhTs expected update time to deal with a single edge weight increase as well as $$Opn^2 hT_s$$Opn2hTs total update time, where $$hT_s$$hTs is the height of input SSSP tree $$T_s$$Ts. For Gn,i¾?p random graphs, DSPI takes $$O\ln n$$Olnn expected update time to handle a single edge deletion as well as $$Opn^2 \ln n$$Opn2lnn total update time when $$20\ln n / n \le p \sqrt{2\ln n / n}$$p>2lnn/n. Specifically, DSPI takes the least total update time of $$On\ln n hT_s$$OnlnnhTs for weighted Gn,i¾?p random graphs with $$p = c\ln n / n, c > 1$$p=clnn/n,c>1 as well as $$On^{3/2}\ln n^{1/2}$$On3/2lnn1/2 for Gn,i¾?p random graphs with $$p = c\sqrt{\ln n / n}, c > \sqrt{2}$$p=clnn/n,c>2.

In this paper we consider the decremental single-source shortest paths (SSSP) problem, where given a graph G and a source node s the goal is to maintain shortest paths between s and all other nodes in G under a sequence of online adversarial edge deletions. In their seminal work, Even and Shiloach [JACM 1981] presented an exact solution to the problem with only O(mn) total update time over all edge deletions. Their classic algorithm was the best known result for the decremental SSSP problem for three decades, even when approximate shortest paths are allowed. The first improvement over the Even-Shiloach algorithm was given by Bernstein and Roditty [SODA 2011], who for the case of an unweighted and undirected graph presented an approximate (1+) algorithm with constant query time and a total update time of O(n2+O(1/√logn)). This work triggered a series of new results, culminating in a recent breakthrough of Henzinger, Krinninger and Nanongkai [FOCS 14], who presented a -approximate algorithm whose total update time is near linear O(m1+ O(1/√logn)). In this paper they posed as a major open problem the question of derandomizing their result. In fact, all known improvements over the Even-Shiloach algorithm are randomized. All these algorithms maintain some truncated shortest path trees from a small subset of nodes. While in the randomized setting it is possible to “hide” these nodes from the adversary, in the deterministic setting this is impossible: the adversary can delete all edges touching these nodes, thus forcing the algorithm to choose a new set of nodes and incur a new computation of shortest paths. In this paper we present the first deterministic decremental SSSP algorithm that breaks the Even-Shiloach bound of O(mn) total update time, for unweighted and undirected graphs. Our algorithm is (1 + є) approximate and achieves a total update time of O(n2). Our algorithm can also achieve the same bounds in the incremental setting. It is worth mentioning that for dense instances where m = Ω(n2 − 1/√log(n)), our algorithm is also faster than all existing randomized algorithms.

We study the 2-Disjoint Shortest Paths (2-DSP) problem: given a directed weighted graph and two terminal pairs (s₁,t₁) and (s₂,t₂), decide whether there exist vertex-disjoint shortest paths between each pair. Building on recent advances in disjoint shortest paths for DAGs and undirected graphs (Akmal et al. 2024), we present an O(mn log n)-time algorithm for this problem in weighted directed graphs that do not contain negative or zero weight cycles. This algorithm presents a significant improvement over the previously known O(m⁵n)-time bound (Berczi et al. 2017). Our approach exploits the algebraic structure of polynomials that enumerate shortest paths between terminal pairs. A key insight is that these polynomials admit a recursive decomposition, enabling efficient evaluation via dynamic programming over fields of characteristic two. Furthermore, we demonstrate how to report the corresponding paths in O(mn² log n)-time. In addition, we extend our techniques to a more general setting: given two terminal pairs (s₁, t₁) and (s₂, t₂) in a directed graph, find the minimum possible number of vertex intersections between any shortest path from s₁ to t₁ and s₂ to t₂. We call this the Minimum 2-Disjoint Shortest Paths (Min-2-DSP) problem. We provide in this paper the first efficient algorithm for this problem, including an O(m² n³)-time algorithm for directed graphs with positive edge weights, and an O(m+n)-time algorithm for DAGs and undirected graphs. Moreover, if the number of intersecting vertices is at least one, we show that it is possible to report the paths in the same O(m+n)-time. This is somewhat surprising, as there is no known o(mn) time algorithm for explicitly reporting the paths if they are vertex-disjoint, and is left as an open problem in (Akmal et al. 2024).

This paper presents the first Learning Automaton-based solution to the dynamic single source shortest path problem. It involves finding the shortest path in a single-source stochastic graph topology where there are continuous probabilistic updates in the edge-weights. The algorithm is significantly more efficient than the existing solutions, and can be used to find the "statistical" shortest path tree in the "average" graph topology. It converges to this solution irrespective of whether there are new changes in edge-weights taking place or not. In such random settings, the proposed learning automata solution converges to the set of shortest paths. On the other hand, the existing algorithms will fail to exhibit such a behavior, and would recalculate the affected shortest paths after each weight-change. The important contribution of the proposed algorithm is that all the edges in a stochastic graph are not probed, and even if they are, they are not all probed equally often. Indeed, the algorithm attempts to almost always probe only those edges that will be included in the shortest path graph, while probing the other edges minimally. This increases the performance of the proposed algorithm. All the algorithms were tested in environments where edge-weights change stochastically, and where the graph topologies undergo multiple simultaneous edge-weight updates. Its superiority in terms of the average number of processed nodes, scanned edges and the time per update operation, when compared with the existing algorithms, was experimentally established. The algorithm can be applicable in domains ranging from ground transportation to aerospace, from civilian applications to military, from spatial database applications to telecommunications networking.

We study the fully-dynamic all pairs shortest path problem for graphs with arbitrary non-negative edge weights. It is known for digraphs that an update of the distance matrix costs \(\ensuremath{{\cal \tilde O}}(n^{2.75})\) worst-case time [Thorup, STOC ’05] and \(\ensuremath{{\cal \tilde O}}(n^2)\) amortized time [Demetrescu and Italiano, J.ACM ’04] where n is the number of vertices. We present the first average-case analysis of the undirected problem. For a random update we show that the expected time per update is bounded by O(n 4/3 + ε) for all ε> 0.KeywordsDynamic graph algorithmsshortest pathsaverage-case analysisrandom graphs

Trees with matrix weights: Laplacian matrix and characteristic-like vertices

In order to solve the path planning problem of time-dependent road network(TDRN), an dynamic A* landmarks triangle algorithm(ALT) is proposed based on landmark-oriented technique and short-path tree(SPT). There are three main contributions: (1) constructing the shortest path tree in the preprocessing stage and calculating the distance between the landmark and other nodes; (2) using the dynamic shortest path tree to optimize the query in the point-to-point heuristic path planning process; (3) When the edge weight of the network changes, the shortest path tree is dynamically updated, and the structural characteristics of the tree are used to reduce the redundancy calculation. Experimental results indicate that the DALT algorithm not only outperforms the ALT implementation in point-to-point shortest path problem as the average query time is reduced by up to 51.71%, but also computes economically for updating shortest path tree compared with previous dynamic update algorithm as the average update times for increments are reduced by up to 9.90% with less modifications.

We present an algorithm which calculates a minimum cut and its weight in an undirected graph with nonnegative real edge weights, n vertices and m edges, in time O(max(log n, min(m/n,δG/e)) n2), where e is the minimal edge weight, and δG is the minimal weighted degree. For integer edge weights this time is further improved to O(δG n2) and O(λG n2). In both cases these bounds are improvements of the previously known best bounds of deterministic algorithms. These were O(nm + n2 log n) for real edge weights and O(nM + n2) and O(M + λG n2) for integer weights, where M is the sum of all edge weights.

We extend the well known bottleneck paths problem in two directions for directed unweighted graphs with positive real edge capacities. Firstly we narrow the problem domain and compute the bottleneck of the entire network in O(mlogn) time, where m and n are the number of edges and vertices in the graph, respectively. Secondly we enlarge the domain and compute the shortest paths for all possible bottleneck amounts. We present a combinatorial algorithm to solve the Single Source Shortest Paths for All Flows (SSSP-AF) problem in O(mn) worst case time, followed by an algorithm to solve the All Pairs Shortest Paths for All Flows (APSP-AF) problem in \(O(\sqrt{t}n^{(\omega+9)/4})\) time, where t is the number of distinct edge capacities and O(n ω) is the time taken to multiply two n-by-n matrices over a ring. We also discuss practical applications for these new problems.KeywordsShort PathAcceleration PhaseOpen Short Path FirstEdge CapacityCapacity MatrixThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

This study’s objective is to assess the performance of routing processing between Shortest Paths Tree (SPT) and Minimum Spanning Tree (MST). In this paper we propose and create software to calculate the efficiency path of routing processing in the network. Extensive simulations are being carried out with two different algorithms specific for Dijkistra’s algorithm and Kruskal’s algorithm. The network loads in the performance plots are characterized by two important parameters (a number of vertices) - 7 nodes and 10 nodes, more vertices could show good performance in the simulation results and showed that the performance of Kruskal’s algorithm is better than Dijkistra’s algorithm when the network loads are increased from 7 nodes to 10 nodes. In this simulation, Because of the total cost of distance matrix for Kruskal is less than Dijkistra when the number of routers or nodes is increased from 7 nodes to 10 nodes. This software namely Network Aids Design (NAD), is useful for calculation about the performance of routing processing in the network.

The single-source shortest paths problem (SSSP) is one of the classic problems in algorithmic graph theory: given a positively weighted graph G with a source vertex s , find the shortest path from s to all other vertices in the graph. Since 1959, all theoretical developments in SSSP for general directed and undirected graphs have been based on Dijkstra's algorithm, visiting the vertices in order of increasing distance from s . Thus, any implementation of Dijkstra's algorithm sorts the vertices according to their distances from s . However, we do not know how to sort in linear time. Here, a deterministic linear time and linear space algorithm is presented for the undirected single source shortest paths problem with positive integer weights. The algorithm avoids the sorting bottleneck by building a hierarchical bucketing structure, identifying vertex pairs that may be visited in any order.

Despite the numerous works related to the problem of finding the shortest paths (SP), attention to development of speed-efficient algorithms for constructing SP does not decrease. This is primarily due to the fact that in the overwhelming majority of cases such algorithms are often used to solve individual subtasks in many applications in various fields of natural science, and the time to solve the general optimization problem is largely determined by the time of constructing SP. Three groups of single-criterion algorithms are considered: network combinatorial algorithms; algebraic or matrix algorithms; algorithms based on methods for solving linear programming problems (LP-methods). The article presents an overview, analysis and classification of methods and algorithms for constructing the shortest paths on networks and graphs between given subsets of the network nodes (Single Source Shortest Path, SSSP) and between all pairs of nodes (Shortest Path Tree, SPT and All Pairs Shortest Paths, APSP). Estimates of the time complexity of the best known algorithms for solving SSST and APSP problems by combinatorial, matrix and LP methods for networks with non-negative arcs lengths and networks with negative arcs lengths and cycles of negative lengths are given. It is noted that for solving individual SSSP problems there are "almost optimal" algorithms in theory and practice, at the same time, for solving a wider class of problems, including APSP problem, there are prerequisites for improving existing algorithms. In recent years the evolution of methods for solving the problems of finding SP has been associated with development and further improvement of effective structures of abstract data types for representing objects of the problem and the creation of parallel algorithms for multiprocessor solving the problem. The main directions of further research on the development of effective methods and algorithms for solving the problems of finding the shortest paths are determined.

Graph-based approaches for simulating pedestrian dynamics in building models

On the K shortest path trees problem