Abstract
We provide new tradeoffs between approximation and running time for the decremental all-pairs shortest paths (APSP) problem. For undirected graphs with m edges and n nodes undergoing edge deletions, we provide four new approximate decremental APSP algorithms, two for weighted and two for unweighted graphs. Our first result is -APSP with total update time (when for any constant ). Our second result is -APSP with total update time , where the second term is an additive stretch with respect to , the maximum weight on the current shortest path from u to v. Prior to our work the fastest algorithm for weighted graphs with approximation at most 3 had total update time for -APSP (Bernstein [11], SICOMP 2016). Our third result is -APSP for unweighted graphs in update time, which for sparse graphs () is the first subquadratic -approximation. Our last result for unweighted graphs is -APSP, for , with total update time. For comparison, in the special case of -approximation, this improves over the state-of-the-art algorithm by Henzinger et al. [2], SICOMP 2016 with total update time of . All of our results are randomized, work against an oblivious adversary, and have constant query time.
Keywords: All-pairs shortest paths, Distance oracle, Decremental graph algorithm, Approximate shortest paths
Introduction
The dynamic algorithms paradigm is becoming increasingly popular for studying algorithmic questions in the presence of gradually changing inputs. A natural goal in this area is to design algorithms that process each change to the input as fast as possible to adapt the algorithm’s output (or a data structure for querying the output) to the current state of the input. The time spent after an update to perform these computations is called the update time of the algorithm. In many cases, bounds on the update time are obtained in an amortized sense as an average over a long enough sequence of updates. Among dynamic graph problems, the question of maintaining exact or approximate shortest paths has received considerable attention in the past two decades [1–22]. The main focus usually lies on maintaining a distance oracle that answers queries for the distance between a pair of nodes. For this problem, we call an algorithm fully dynamic if it supports both insertions and deletions of edges, and partially dynamic if it supports only one type of updates; in particular we call it decremental if it only supports edge deletions (which is the focus of this paper), and incremental if it only supports edge insertions.
The running times of partially dynamic algorithms are usually characterized by their bounds on the total update time, which is the accumulated time for processing all updates in a sequence of at most m deletions (where m is the maximum number of edges ever contained the graph). A typical design choice, which we also impose in this paper, is small (say polylogarithmic) query time. In particular, our algorithms will have constant query time. While fully dynamic algorithms are more general, the restriction to only one type of updates in partially dynamic algorithms often admits much faster update times. In particular, some partially dynamic algorithms have a total update time that almost matches the running time of the fastest static algorithm, i.e., computing all updates does not take significantly more time than processing the graph once.
Decremental shortest paths. For the decremental single-source shortest paths problem, conditional lower bounds [10, 23] suggest that exact decremental algorithms have an bottleneck in their total update time (up to subpolynomial factors). On the other hand, this problem admits a -approximation (also called stretch) with total update time in weighted, undirected graphs [1, 6, 8, 14, 18], which exceeds the running time of the state-of-the art static algorithm by only a subpolynomial factor. Hence for the single-source shortest paths problem on undirected graphs we can fully characterize for which multiplicative stretches the total update time of the fastest decremental algorithm matches (up to subpolynomial factors) the running time of the fastest static algorithm.
Obtaining a similar characterization for the decremental all-pairs shortest paths (APSP) problem is an intriguing open question. Conditional lower bounds [10, 24] suggest an bottleneck in the total update time of decremental APSP algorithms with (a) any finite stretch on directed graphs and (b) with any stretch guarantee with a multiplicative term of and an additive term of with on undirected graphs. This motivates the study of decremental -approximate APSP algorithms such that , i.e., with a multiplicative stretch or an additive stretch .
Apart from two notable exceptions [2, 25], all known decremental APSP algorithms fall into one of two categories. They either (a) maintain exact distances or have a relatively small multiplicative stretch of or (b) they have a stretch of at least 3. The space in between is largely unexplored in the decremental setting. This stands in sharp contrast to the static setting where for undirected graphs approximation guarantees different from multiplicative or “3 and above” have been the focus of a large body of works [24, 26–36]. The aforementioned exceptions in dynamic algorithms [2, 25], concern unweighted undirected graphs and maintain -approximations that simultaneously have a multiplicative error of and an additive error of 2, which implies a purely multiplicative -approximation. The algorithms run in 1 and total update time respectively. In the next section, we will detail how our algorithms improve over this total update time and generalize to weighted graphs.
Concerning the fully dynamic setting, Bernstein [5] provided an algorithm for -APSP which takes time per update. That is, it cannot be directly compared to total update time; for example it takes time for a series of m updates. Although we are not aware of any lower bounds, it seems to be hard to beat this: no improvements have been made since. The lack of progress in the fully-dynamic setting motivates the study in a partially dynamic setting, where we obtain improvements for the decremental case.
Our Results
In this paper, we provide novel decremental APSP algorithms with approximation guarantees that previously were mostly unexplored in the decremental setting. For an overview of our results, see Table 1. Our algorithms are randomized and we assume an oblivious adversary, i.e., the sequence of updates is fixed at the start and thus independent of the random choices in the algorithm. For each pair of nodes, we can provide not only the distance estimate, but also a shortest path of this length in time using standard techniques, see e.g. [22]. In all our algorithms, we maintain an APSP distance oracle, that is, a data structure that answers APSP-queries in constant time, see Sect. 2.1 for details on the model. In this section, we assume to be a constant and hence can hide factors in our asymptotic notation. Update times with as a parameter, and hence containing factors, can be found in our technical sections.
Table 1.
An overview of our results and the closest related work
| Approximation | Total update time | ||
|---|---|---|---|
| Weighted | nm | [11] | |
| Theorem 1.1 | |||
| Theorem 1.2 | |||
| [20] | |||
| Unweighted | or | [2, 25] | |
| Theorem 1.3 | |||
| Theorem 1.4 | |||
| [7] |
We use the simplifying assumptions: (a) subpolynomial factors are omitted from the total update time; (b) the ratio W between the maximum and minimum weight is polynomial in n; and (c) is a constant. The combination of (a) and (c) means that factors are not displayed in the total update time here
-APSP for weighted graphs. Our first contribution is a Las Vegas algorithm for maintaining a -approximation in weighted, undirected graphs.
Theorem 1.1
Given a graph G with positive, integer weights and a constant , there is a decremental data structure that maintains a -approximation of APSP. The algorithm has constant query time and works against an oblivious adversary. The total update time is w.h.p.
if and for an arbitrary small constant ,
if for any constant ,
otherwise,
where W is the ratio between the maximum and minimum weight.
The fastest known algorithm with an approximation ratio at least as good as ours is the -approximate decremental APSP algorithm by Bernstein [11] with total update time . With our -approximation, we improve upon this total update time when , for any . Furthermore, the fastest known algorithm with a larger approximation ratio than our algorithm is the -approximate decremental distance oracle by Ła̧cki and Nazari [20] with total update time . Our result also has to be compared to the fully dynamic algorithm of Bernstein [5] for maintaining a -approximation that takes amortized time per update. Note that in unweighted graphs, -approximate decremental APSP algorithm can be maintained with total update time (which is implied by the results of Abraham and Chechik [25] and Henzinger et al. [2]). Our approach improves upon this bound for most densities, and matches it for .
-APSP for unweighted and -APSP for weighted graphs. Our second contribution is a faster algorithm with an additional additive error term of 1 for unweighted graphs, which in turn can be used to obtain our unweighted -APSP result. The corresponding generalization to weighted graphs can be formulated as follows.
Theorem 1.2
Given a graph G with positive, integer weights and a constant , there is a decremental data structure that maintains a -approximation for APSP, where is the maximum weight on a current shortest path from u to v. The algorithm has constant query time and works against an oblivious adversary. The total update time is w.h.p. if , and otherwise, where W is the ratio between the maximum and minimum weight.
Here, W is a global parameter, while is local and depends on u and v.
-APSP for unweighted graphs. We obtain this result by a general reduction from mixed approximations to purely multiplicative approximations, which might be of independent interest beyond the dynamic setting. See Theorem 3.1 for the statement. We can then combine this with Theorem 1.2 to obtain a fast algorithm for non-dense unweighted graphs.
Theorem 1.3
Given an undirected unweighted graph G, there is a decremental data structure that maintains a -approximation for APSP with constant query time. The algorithm works against an oblivious adversary. W.h.p. the total update time is bounded by if , and otherwise.
Note that for this gives the first subquadratic decremental -approximate APSP algorithm. For , this approach is faster than our weighted result, Theorem 1.1, which was already beating the unweighted state-of-the-art [2, 25].-APSP for unweighted graphs. Our fourth contribution is an algorithm for unweighted, undirected graphs that maintains, for any , a (,)-approximation, i.e., a distance estimate that has a multiplicative error of and an additive error of .
Theorem 1.4
Given an undirected unweighted graph G, a constant and an integer , there is a decremental data structure that maintains -approximation for APSP with constant query time. The algorithm works against an oblivious adversary. The expected total update time is bounded by where .
Note that for small values of k and if for a constant , we get total update time of , and otherwise we have an extra factor. In addition, in the special case of , we get a near-quadratic update time of . The state-of-the-art for a purely multiplicative -approximation is the algorithm of Roditty and Zwick with total update time .2 It was shown independently by Abraham and Chechik [25] and by Henzinger et al. [2] how to improve upon this total update time bound at the cost of an additional small additive error term: a -approximation can be maintained with total update time . This has been generalized by Henzinger et al. [7] to an additive error term of and total update time . We improve upon this tradeoff in two ways: (1) our additive term is independent of and linear in k and (2) our algorithm profits from graphs being sparse.
Static follow-up work. Interestingly, our techniques inspired a new algorithm for a static 2-approximate distance oracle [37], giving the first such distance oracle algorithm with subquadratic construction time for sparse graphs. Moreover, for they match conditional lower bounds [38, 39].
Related Work
Static algorithms. The baseline for the static APSP problem are the exact textbook algorithms with running times of and , respectively. There are several works obtaining improvements upon these running times by either shaving subpolynomial factors or by employing fast matrix multiplication, which sometimes comes at the cost of a -approximation instead of an exact result. See [40] and [41], and the references therein, for details on these approaches. For the regime of stretch 3 and more in undirected graphs, a multitude of algorithms have been developed with the distance oracle of Thorup and Zwick [42] arguably being the most well-known construction. In the following, we focus on summarizing the state of affairs for approximate APSP with stretch between and 3.
In weighted, undirected graphs, Cohen and Zwick [27] obtained a 2-approximation with running time . This running time has been improved to by Baswana and Kavitha [28]. Employing fast matrix multiplication, Kavitha [30] provided an algorithm for -APSP that takes time. Subsequently, Dory et al. [37] provided two algorithms for -APSP, for dense graphs: and sparse graphs: . In addition, efficient approximation algorithms for stretches of [27] and [30] have been obtained. These results have recently been generalized by Akav and Roditty [36] who presented an algorithm with stretch and running time for any . Moreover, Cohen and Zwick [27] obtained an -time algorithm that outputs an APSP approximation , which for any two vertices and any u-v path satisfies , where is the i-th heaviest edge on .
In unweighted, undirected graphs, a (1, 2) -approximate APSP algorithm with running time has been presented by Aingworth, Chekuri, Indyk and Motwani [26]. This has been improved by Dor, Halperin, and Zwick [24] that showed a (1, 2)-approximation with running time . They also show a generalized version of the algorithm that gives stretch (1, k) and running time for every even . Recently, faster (1, k)-approximation algorithms based on fast matrix multiplication techniques were developed [43–45], here as well the fastest (1, 2)-approximation runs in time [44]. This was extended to a -approximation in time [37]. In addition, recently Roditty [46] extended the approach of [24] to obtain a combinatorial (2, 0)-approximation for APSP in time in unweighted undirected graphs. Using fast matrix multiplication, this running time was improved to [37, 45].
Berman and Kasiviswanathan [29] showed how to compute a (2, 1) -approximation in time . Subsequent works [28, 31–34] have improved the polylogarithmic factors in the running time and the space requirements for such nearly 2-approximations. Recently, slightly subquadratic algorithms have been given: an algorithm with stretch by Akav and Roditty [35], and an algorithm with stretch (2, 3) by Chechik and Zhang [47].
Decremental algorithms. The fastest algorithms for maintaining weighted, exact APSP under edge deletions have total update time [3, 19, 48]. There are several algorithms that are more efficient at the cost of returning only an approximate solution. In particular, a -approximation can be maintained in total time [4, 11, 15]. If additionally, an additive error of 2 is tolerable, then a -approximation can be maintained in total time in unweighted, undirected graphs [2, 25]. Note that such a -approximation directly implies a -approximation because the only paths of length 1 are edges between neighboring nodes. All of these decremental approximation algorithms are randomized and assume an oblivious adversary. Deterministic algorithms with stretch exist for unweighted, undirected graphs with running time [2], for weighted, undirected graphs with running time [18] and for weighted, directed graphs with running time [16].
Decremental approximate APSP algorithms of larger stretch, namely at least 3, have first been studied by Baswana, Hariharan, and Sen [49]. After a series of improvements [4, 6, 8, 12], the state-of-the-art algorithms of [13, 20] maintain -approximate all-pairs shortest paths for any integer and in total update time with query time and O(k) respectively. All of these “larger stretch” algorithms are randomized and assume an oblivious adversary.
Deterministic decremental algorithms have been developed by Chuzhoy and Saranurak [21] and by Chuzhoy [17], which have even been improved and generalized to fully dynamic algorithms. For example, Haeupler, Long, and Saranurak[50] provide worst update time for any constant and constant stretch. As observed by Mądry [51], decremental approximate APSP algorithms that are deterministic – or more generally work against an adaptive adversary – can lead to fast static approximation algorithms for the maximum multicommodity flow problem via the Garg-Könemann-Fleischer framework [52, 53]. Similarly, decremental Single Source Shortest Paths (again, deterministic or against an adaptive adversary) play a role in the recent fast min cost flow algorithms [18, 54, 55]. The above upper bounds for decremental APSP have recently been contrasted by conditional lower bounds [56] stating that constant stretch cannot be achieved with subpolynomial update and query time under certain hardness assumptions on 3SUM or (static) APSP.
Fully dynamic algorithms. Next, we discuss the related work on fully dynamic shortest paths. We would like to point out that all “combinatorial” algorithms discussed in the following (i.e., algorithms that do not rely on “algebraic” techniques like dynamic matrix inverse) are internally employing decremental algorithms.
The reference point in fully dynamic APSP with subpolynomial query time is the exact algorithm of Demetrescu and Italiano [57] with update time (with log-factor improvements by Thorup [58]) and constant query time for weighted directed graphs.. Subsequently, researchers have developed algorithms with subcubic worst-case update time and constant query time [59, 60] with some of them being deterministic [61, 62]. Note that one can construct a simple update sequence for which any fully dynamic algorithm maintaining the distance matrix or the shortest-path matrix explicitly needs to perform changes to this matrix per update. Algorithms breaking the barrier at the cost of large query time have been obtained in unweighted directed graphs [23, 63, 64] and sparse weighted directed graph [65].
In addition to exact algorithms, combinatorial and algebraic algorithms have also been developed for the low stretch regime of -approximation. In particular, Roditty and Zwick [4] obtained the following trade-off with a combinatorial algorithm: update time and query time O(t) for any and . Subsequently, for , a deterministic variant was developed [66] and it was generalized to weighted directed graphs [11]. Furthermore, by a standard reduction (see e.g. [67]) using a decremental approximate single-source shortest paths algorithm [8, 18], one obtains a combinatorial deterministic algorithm with update time and query time O(t) for any , for the fully dynamic all-pairs problem in weighted undirected graphs. Algebraic approaches can achieve subquadratic update time and sublinear query time, namely worst-case update time and query time in weighted directed graphs [68], or worst-case update time and query time in unweighted undirected graphs [69]. In directed graphs, van den Brand and Karczmarz [70] provided explicit APSP with worst case update time for unweighted graphs.
Several fully dynamic distance oracles have been developed that obtain a larger stretch of . In particular, Bernstein [5] developed a distance oracle with update time and query time in weighted undirected graphs. It can be made deterministic using the deterministic approximate single-source shortest path algorithm by Bernstein, Probst Gutenberg, and Saranurak [18]. The only conditional lower bound in this regime that we are aware of states that no algorithm can maintain a -approximation with update time and query time for any , unless the OMv conjecture fails [10].
In the regime of stretch at least 3, the following trade-offs between stretch and update time have been developed: Abraham, Chechik, and Talwar [12] designed an algorithm for unweighted undirected graphs with stretch , update time , and query time , where is a freely chosen parameter and . Forster, Goranci, and Henzinger [71] designed an algorithm for weighted undirected graphs with stretch , update time , and query time , where is an arbitrary integer parameter. Further, we note that any algorithm whose update time depends on the sparsity of the graph (possibly also a static one) can be run on a spanner of the input graph maintained by a fully dynamic spanner algorithm [72]. Finally, recent works [50, 73] have developed deterministic fully dynamic distance oracles. In particular, the work of Kyng, Meierhans, and Probst Gutenberg [73] achieves an approximation ratio with worst-case update time and polylogarithmic query time. Meanwhile, the work of Haeupler, Long, and Saranurak [50] provides a constant-factor approximation with arbitrarily low polynomial worst-case update time and polylogarithmic query time.
Outline
We give an overview of the notation, terminology, and various decremental tools we use in Sect. 2. Next, we give a high-level overview of our techniques and provide an intuition for our algorithms in Sect. 3. Then follow three technical sections. In Sect. 4, we prove Theorem 1.1. Then we prove Theorem 1.2 and 1.3 in Sect. 5. Lastly, we prove Theorem 1.4 in Sect. 6.
Preliminaries
Notation and Terminology
Throughout this paper, neighbors of a node v are denoted by N(v). We denote by the distance between u and v in the graph G. If G is clear from the context, we use the notation d(u, v). When G is a weighted graph, we allow for positive, integer weights. We denote by W the ratio between the maximum and minimum weight of the graph. Moreover, we denote by the maximum weight on a shortest path from u to v. In particular, and hence additive approximations in terms of can be tighter than in terms of W.
We are interested in designing dynamic graph algorithms for shortest path problems, which support both update and query operations. In particular, we look at decremental algorithms, which support weight increases and edge deletions. This is opposed to fully dynamic algorithms, which also support weight decreases and edge insertions. To be concrete, we support the following three operations:
Delete(u, v): delete the edge from the graph;
Update(): increase the weight of an edge to , i.e., ;
Distance(u, v): return a distance approximation between the nodes u and v in the current graph G.
We assume that we have an oblivious adversary, i.e., that the sequence of updates is fixed from the start. This is as opposed to the adaptive adversary, which can use the random choices made by the algorithm to determine the next update. More formally, let denote the state of the algorithm after update t and let be the random bits used in this update step. An oblivious adversary chooses the entire update sequence before execution begins, and hence purely based on the algorithm’s description and independent of the algorithm’s states and random bits . An adaptive adversary selects each input sequentially based on the algorithm’s description, the history of the algorithm’s past states , and the used random bits . Since an adversary can determine future states of a deterministic algorithm, any correct deterministic algorithm holds against an adaptive adversary.
Edge weights can be positive integers bounded by W, for some parameter . We say that returns -approximate distances, denoted by , if for all . Moreover we denote -approximate by -approximate. Throughout, we denote for the output of our algorithms, and (potentially with subscript) for approximate distances used internally.
In all our algorithms, we maintain a distance oracle rather than explicit APSP. This means that we maintain a data structure that can answer distance queries for any . The time to answer a distance query is called the query time. All our algorithms use constant query time. Further, we give the total update time, which is the time needed to process a sequence of up to m edge deletions or weight increases, where m is the number of edges before the first deletion.
For any object, value, or data structure x that changes over time, we use a superscript to specify its state at time t, i.e., is x after processing t updates.
Bunches and Clusters
We start by reviewing the concepts of bunch and cluster as defined in the seminal distance oracle construction of Thorup and Zwick [42]. Given a parameter , called the cluster sampling rate, we let A be a set of sampled nodes, where each node is sampled uniformly at random with probability p. Then we define the pivot of a node v to be the closest node in A, i.e., . Since our algorithms contain only one level of sampling, and thus A we will be fixed throughout, we omit the subscript A henceforth. The bunch B(v) of a node v is the set and the clusters are . Hence bunches and clusters are inverses of each other: if and only if .
Thorup and Zwick showed how to compute bunches and clusters in the static setting in time [42]. However, it is challenging to maintain them exactly under deletions: for starters, we cannot compute exact distances from the pivots efficiently. In the static setting, we can compute such distances in time, by running Dijkstra’s algorithm from every pivot. In the decremental setting, we only have efficient exact shortest path computation (through ES-trees, defined in Sect. 2.4) when we restrict to bounded depth, which is not sufficient for our applications. It is possible to maintain approximate bunches that can deal with these challenges. We note that Roditty and Zwick [4] provide an algorithm that is efficient for maintaining decremental bunches exactly, but again only up to bounded depth, see Lemma B.1. So, this is too expensive for our purpose. Instead we use another type of approximate bunches proposed by Łącki and Nazari [20]. We start by relaxing the definition of the pivot: the approximate pivot of a node v does not have to be the closest node in A, but just within a factor of it:
Next, we define an approximate bunch , which rather than containing the exact bunch B(v) contains all nodes that are at least a factor closer than the exact pivot p(v). More precisely, for our analysis, our approximate bunch needs to contain all nodes . More precisely, in the stretch analysis of Theorem 1.1 (see Lemma 4.8), we need that if , that , i.e., that nodes not in the bunch are far enough away. Since we can lose a factor in our distance estimates, we do not need that the nodes are actually farther away than the pivot (this would mean that the entire bunch ), but it suffices that all nodes sufficiently closer than the pivot are in there. It can also contain additional nodes. For efficiency purposes, we still want the approximate bunch to remain small, say only polylogarithmically larger than the exact bunch B(v).
Finally, for every node and every node , we need to maintain a distance estimate . Here also an approximate distance will suffice:
The following lemma provides these approximate objects. It is implicitly proven by Łącki and Nazari [20], but for completeness we sketch a proof in Appendix B. The lemma outputs: approximate pivots, approximate bunches, and a distance estimate for and .
Lemma 2.1
Let be a decremental graph, and let and be parameters, let be a sampling probability, and let be a set of sampled nodes, where each element of V is sampled uniformly at random with probability p. There exists an algorithm that maintains for each : (i) an approximate pivot ; (ii) an approximate bunch ; and (iii) distance estimates for every . These objects satisfy:
;
;
is monotone (non-decreasing over updates);
for any : ; and
with high probability, .
The algorithm has total update time .
The approximate cluster is the reverse of the approximate bunch: .
In our algorithms for balancing out different terms in the running time we set the parameter depending on the graph density so that . Hence for graphs with edges, we can set to be a constant and for sparser graphs we can set . For simplicity of our statements in the introduction (Sect. 1) and the overview (Sect. 3) we assume is a constant, and thus we hide factors in when c is constant, or in when .
Decremental Multi-Source Shortest Paths
We will use the following lemma from Łącki and Nazari [20] to maintain -approximate distances for , for S some given set of sources.
Lemma 2.2
([20]) There is a data structure which given a weighted, undirected graph explicitly maintains -approximate distances from a set of sources S in G under edge deletions, where is a parameter. After each update, the algorithm returns all nodes for which the distance estimate has changed. During the execution of the algorithm, nodes can be added to S. We write s for the final size of S. Assuming that and , the total update time is w.h.p. . If or , then the total update time is .
Here the factor again simplifies to for constant .
ES-Trees
An Even-Shiloach tree (ES-tree) is a central data structure for maintaining distances in a decremental setting. It maintains the exact distances from a source s under edge deletions, giving the following.
Lemma 2.3
([74–76]) There is a data structure called ES-tree that, given an integer-weighted directed graph G undergoing deletions and edge weight increases, a root node s, and a depth parameter d, maintains, for every node v a value such that if and if . It has constant query time and a total update time of , where m is the number of edges in G.
A monotone ES-tree is a generalization of ES-tree studied in [2, 8, 14, 77] that handles edge insertions. This is a data structure that maintains distances from a source s in a graph undergoing deletions, insertions and edge weight increases. Note that when edges are inserted to the graph, it can potentially decrease some distances in the graph. However, the data structure ignores such decreases, and maintains distance estimates from s to any other node, that can only increase during the algorithm. In particular, these distance estimates are not necessarily the correct distances in the graph, and when using this data structure the goal is to prove that these estimates still provide a good approximation for the current distances. We call the level of v in the monotone ES-tree rooted at s.
We next describe the main properties of monotone ES-trees that we use in our algorithms. A pseudo-code appears in Appendix A. The following lemma follows from [2] and from the pseudo-code.
Lemma 2.4
The following holds for a monotone ES-tree of a graph H rooted at s, that is maintained up to distance d:
At the beginning of the algorithm, for all nodes v where .
It always holds that .
The level of a node v never decreases.
When the level increases to a value that is at most d, we have .
Lemma 2.5
([2]) For every , the total update time of a monotone ES-tree up to maximum level d on a graph H undergoing edge deletions, edge insertions, and edge weight increases is , where is the total number of edges ever contained in H and is the total number of updates to H.
Near-Additive Decremental APSP
In [7], the authors show an algorithm that obtains near-additive approximations for decremental APSP. This result will be used to handle certain cases in Sect. 6.
Theorem 2.6
(Theorem 1.3 in [7]) For any constant and integer , there is a -approximation algorithm for decremental APSP with constant worst-case query time and expected total update time of .
Notation Overview and Choice of Parameters
To guide the reader, we give an overview of how notation is used in this paper. Whenever we deviate from these assumptions, this is clearly stated in the text.
Generally, superscripts are used to denote a value or object at time step t. For readability, this superscript is omitted when it is not necessary. We denote the exact distance from u to v by d(u, v). As defined in Sect. 2.4, denotes the level of v in the (monotone) ES-tree rooted at s. Hence maintains the exact distance. We denote any -approximate distance estimate by . It can be equipped with a subscript to denote the origin of the approximation. Given some value w, we write to denote a approximation that changes at most times. Formally, this is achieved by setting . Similarly, is a -approximate distance that only changes times. Finally, we denote the approximate APSP that the algorithm outputs by , e.g., a -approximation of APSP.
High-Level Overview
In this section we provide a high-level overview of our algorithms. First we describe our -APSP algorithms for weighted graphs, by giving a simpler static version first. Then we describe our -APSP algorithm, where we introduce a notion of bunch overlap threshold to overcome the challenge of dynamically maintaining a well-known static adaptive sampling technique [78] (see Sect. 3.2). We give a reduction from mixed approximations to purely multiplicative approximations, which together with the previous result gives our -APSP algorithm for unweighted graphs. Finally, we describe our -APSP algorithm for any in unweighted graphs.
As in Sect. 1, we assume to be a constant in this section. Hence, we can hide factors in our asymptotic notation. Update times with as a parameter, and hence containing factors, can be found in our technical sections. In all cases, these factors are inherited from the use of decremental single source shortest path (SSSP) algorithms (see, e.g., [79]), and hence do not form a critical part of our paper.
-APSP for Weighted Graphs
We first present a warm-up static algorithm that we later turn into a dynamic algorithm.
Static 2-APSP
We consider the bunches and clusters of the well-known distance oracles of Thorup and Zwick [42], as introduced in Sect. 2.2. In particular, we consider sampling probability p, set of sampled nodes A, and bunches B(v) and clusters C(v) for . We store the distances , together with the clusters and bunches of each node. Moreover, we store the distances d(u, v) for all and . With this information, we can query 3-approximate distances for any pair . At a high-level, this works as follows. We either have and so we explicitly have stored their distance, or we can get a 3-approximate estimate by computing , since
where the first step follows by the triangle inequality and the second step by the fact that if . In the following, we explain that in some special cases we can directly use the estimate to obtain a 2-approximation for a pair u, v. In other cases, we can store more information depending on how B(u) and B(v) overlap and use this to obtain a 2-approximation to d(u, v).
Let us assume that for all nodes v we have computed B(v) and have access to all the distances from v to each node . Also assume that we have computed the distances from the set A to all nodes. We now describe how using this information we can get a 2-approximate estimate of any pair of nodes u, v in the first case. In another case we will discuss what other estimates we need to precompute. Let be a shortest path between u and v. We consider two cases depending on how the bunches B(u) and B(v) interact with . A similar case analysis was used in [80, 81] in distributed approximate shortest paths algorithms.
There exists such that (left case in Fig. 1): Since w is on the shortest path , we either have or . Suppose . We observe that by definition , hence we obtain , where the first step follows by the triangle inequality and the second step by the fact that . The case that is analogous, and hence by computing we get a 2-approximation.
There exists no such that . In other words, and hence there exists at least one edge on where and (right case in Fig. 13): in this case we can find the minimum over estimates obtained through all such pairs , i.e. by computing . We note that this case includes the arguably easier situation that the bunches overlap, i.e., (not reflected in the picture).
Fig. 1.

Possible scenarios for the overlap between the bunches B(u), B(v) and a shortest path from u to v
If we had access to all the above distances for the bunches and the pivots, we could then use them to query 2-approximate distances between any pair . As we will see, in our algorithms we only have approximate bunches and pivots which lead to -approximate queries.
Running time. We can compute bunches and clusters in time [42]. We need to compute shortest paths from the set of pivots A for the estimates in Case 1. This takes time using Dijkstra’s algorithm. Finally, we consider Case 2. A straight-forward approach is to consider each pair of vertices u, v, and all and . This takes time.
We use an intermediate step that computes the distance between and v if there is an edge such that . For each node , we consider all , for which we consider all neighbors and compute the estimate (and replace current minimum if it is smaller). Since , we can compute these estimates for all in time.
Next, for each pair , we take the minimum over the distances for all in the bunch B(u) using the precomputed distances from the previous step in time , by iterating over all pairs , and all . So in total the adjacent case takes time . Hence the total running time of the algorithm will be . By setting we obtain the total update time .
There are several subtleties that make it more difficult to maintain these estimates in decremental settings. Not only do distances change, but also which nodes are part of a bunch change due to the updates. Moreover, which bunches are adjacent to each other changes. We next discuss how these intricacies can be handled. We obtain a total update time that matches the stated static running time (up to subpolynomial factors).
Dynamic Challenges
Maintaining bunches and pivots. First, we need to dynamically maintain bunches efficiently as nodes may join and leave a bunch throughout the updates using an adaptation of prior work. One option would be maintaining the clusters and bunches using the [4] framework, however using this directly is slow for our purposes. Hence we maintain approximate clusters and bunches using hopsets of Łącki and Nazari [20]. This algorithm also maintains approximate pivots, i.e. pivots that are within -approximate distance of the true closest sampled node. These estimates let us handle the first case (up to approximation). One subtlety is that the type of approximate bunches used in [20] is slightly different from the type of approximate bunches we need for other parts of our algorithm. Specifically, we need to bound the number of times nodes in a bunch can change. Roughly speaking, we can show this since the graph is decremental and the estimates obtained from the algorithm of [20] are monotone. Hence we perform lazy bunch updates, where we only let a bunch grow if the distance to the pivot grows by at least a factor . This means a bunch grows at most times. In addition, these approximate bunches need to be taken into account in our stretch analysis.
We note that -approximate decremental SSSP takes total update time. However, we use the multi-source shortest path result from [20], where the -term vanishes when applied with polynomially many sources, giving us a total update time of .
Maintaining estimates for Case 2. When we are in Case 2, we need more tools to keep track of estimates going through these nodes since both the bunches and the distances involved are changing. In particular, we explain how by using heaps in different parts of our algorithm we get efficient update and query times. Moreover, note that we have an additional complication: there are two data structures in this step, where one impacts the other. We need to ensure that an update in the original graph does not lead to many changes in the first data structure, which all need to be processed for the second data structure.
To be precise, we need intermediate data structures that store approximate distances for and v of the form for each such that , as explained for the static algorithm. The static algorithm used the exact distance , while here we use an estimate: throughout this section (Sect. 3.1.2), denotes -approximate distances in our dynamic data structures. Also as opposed to the static algorithm, we do not only keep the minimum, but instead maintain a min-heap, from which the minimum is easily extracted.
However, this approach has a problem: might change many times, and for each such change we need to update at most heaps. To overcome this problem, we use another notion of lazy distance update: we only update a bunch if the estimate of a node changes by at least a factor . Combining this with the fact that, due to the lazy bunch update, nodes only join a cluster at most times, and thus there is only an overhead in maintaining these min-heaps dynamically due to bunch updates. Note that at this stage, it is not relevant which node is declared the pivot: only the distance to the pivot influences the bunch.4
Similarly, might change many times, which has an impact for every . Since this can be many nodes, we need to use an additional trick so that an adversary cannot increase our update time to mn. Again the solution is a lazy update scheme: instead of we use , which can only change times. This comes at the cost of a approximation factor.
We note that our bunches are approximate bunches in three different ways. We have one notion of approximation due to the fact that we are using hopsets (that implicitly maintain bunches on scaled graphs). We have a second notion of approximation due to our lazy bunch update, which only lets nodes join a bunch a bounded number of times. We have a third notion of approximation due to the lazy distance update, which only propagates distance changes times. We need to carefully consider how these different notions of approximate bunch interact with each other and with the stretch of the algorithm.
Next, we want to use the min-heaps to maintain the distance estimates for (see again the right case in Fig. 1). We construct min-heaps , for each pair u, v with entries for . Here is the minimum from the intermediate data structure .
An entry in has to be updated when either or change. We have to make sure we do not have to update these entries too often. For the first part of each entry, we bound updates to the distance estimates by the lazy distance updates. One challenge here is that when the distance estimates in a bunch change we need to update all the impacted heaps i.e. if inside a bunch B(u) changes, we must update all the heaps such that there exists with . For this purpose one approach is the following: for each we keep an additional data structure that stores for which we have with . This means that given a change in , we can update each of the heaps in logarithmic time.
For the second part of the entry, which is the distance estimate from the first data structure, this is more complicated. Another subtlety for our decremental data structures is the fact that may also decrease due to a new node being added to B(v). However, our lazy bunch update ensures that can only decrease times. Further, we use lazy distance increases in between such decreases. Hence in total we propagate changes to at most times, and thus our decremental algorithm has overhead compared to the static algorithm.
-APSP for Weighted Graphs
For a moment, let us go back to the first static algorithm. It turns out, that if instead of computing an estimate for two ‘adjacent’ bunches, we keep an estimate for bunches that overlap in at least one node, we obtain a -approximation, where is the maximum weight on a shortest path from u to v.
We fix an arbitrary shortest path from u to v denoted by . The stretch analysis comes down to the following cases:
There exists no (the left and right case in Fig. 2).
There exists such that (the middle case in Fig. 2).
The crucial observation here is that the distance estimate via the pivot (Case 1 in the previous section) already gives a -approximation for the adjacent case (the right case in Fig. 2), see Sect. 5.1 for the details. So if we maintain an estimate for d(u, v) if there exists such that (the ‘overlap case’), then we obtain a -approximation in total.
Fig. 2.

Possible scenarios for the overlap between the bunches B(u) and B(v) and a shortest path from u to v
Here we need to create a min-heap for the overlap case, later we show we can maintain it in time, where is the size of the largest cluster. First we focus on the challenge of bounding .
Efficiency challenge. While the bunches are small, there is no bound on the size of the clusters. To overcome this issue in the static case, Thorup and Zwick developed an alternative way to build the bunches and clusters, that guarantees that the clusters are also small [78]. At a high-level, their approach is to adaptively change (grow) A by sampling big clusters into smaller clusters using a sampling rate proportional to the cluster size and adding these nodes to the set of pivots A. In total, in time we obtain bunches and clusters, both of size . This idea was developed in the context of obtaining compact routing schemes, and later found numerous applications in static algorithms for approximating shortest paths and distances (see e.g., [28, 35, 36, 82]).
Using this trick, the static algorithm has running time , for or for .
However, the adaptive sampling procedure does not seem to be well-suited to a dynamic setting. The reason is that the sampling procedure is adaptive in such a way that when the bunches/clusters change, the set of sampled nodes can also change. Although (a dynamic adaptation of) the algorithm can guarantee that the set of sampled nodes is small at any particular moment, this would require to both add nodes to and remove nodes from A at any time. This would add a significant amount of computation necessary to propagate these changes to other parts of the algorithm. A possible solution is to enforce A to only grow, by never letting nodes leave A. This would require us to bound the total number of nodes that would ever be sampled, which seems impossible with the current approach. In that approach, we could only bound the number of new nodes for a single deletion, which can become too larger after many deletions. To overcome this issue, we next suggest a new approach that gives us a set that is only increasing in size, but remains bounded. For simplicity, we first present this in a static setting.
Introducing bunch overlap thresholds. Our proposed approach is to divide the nodes into two types depending on the number of bunches they appear in. In particular, we consider a threshold parameter and we define a node to be a heavy node if it is in more than bunches (equivalently its cluster contains more than nodes), and otherwise we call it a light node. In other words, for the set of light nodes we have . This threshold introduces a second type of ‘pivot’ for each node u, which we denote by q(u) that is defined to be the closest heavy node to u. In particular, instead of computing all distance estimates going through nodes , we only compute them for the case that w is light, and otherwise it is enough to compute the minimum estimates going through the closest heavy node, i.e. . We emphasize that although the heavy nodes fullfill a similar role to the pivots, they are not a subset of our pivots . Moreover, heavy nodes have a different behavior in bounding the running time than the pivots. As we will see later, introducing these thresholds is crucial in efficiently obtaining the estimates required for Case 2 as we can handle the light and heavy case separately.
Stretch of the algorithm with bunch overlap thresholds. As discussed above, the stretch analysis was divided into two cases. In the new variant of the algorithm we add a third case, where we look at the distance estimates going through the closest heavy node, i.e. . The main idea is that now we only need to consider the difficult case, Case 2, if the relevant node is light, which allows us to implement the algorithm efficiently.
If the relevant node in Case 2 is heavy, we obtain a 2-approximation through the closest heavy node: we get that , since . W.l.o.g. say . Then , hence .
Maintaining estimates through heavy nodes. For the stretch analysis above, we need to maintain a shortest path tree from each heavy node. We ensure a bunch grows at most times. Hence by a total load argument we get that the total number of nodes in all bunches over all updates is at most . This implies there cannot be too many heavy nodes in total, hence we can enforce that only grows by keeping in all nodes that were once heavy (for details see Lemma 5.1). As a consequence, we can maintain multi-source approximate distances from all heavy nodes efficiently: we can compute shortest paths from this set to all other nodes in time.
Running time of the algorithm with bunch overlap thresholds. Summarizing, we compute bunches and clusters in O(m/p) time, compute distances from A to V in time, and we can compute shortest paths from the heavy nodes in time.
Finally, we consider Case 2. For each node , we consider every light node , and then all nodes . Since w is light, we have , so this takes time .
Hence, in the total update time, we obtain . Setting and gives a total update time of . We provide the details in Sect. 5.1.
Again, for a decremental algorithm, we need to combine this new idea with the subtleties we had in the previous section: the bunches, their overlaps, and the heavy nodes keep on changing over the updates. We obtain a total update time that matches the stated static running time (up to subpolynomial factors) for the algorithm using bunch overlap thresholds.
-APSP for Unweighted Graphs
We observe that in unweighted graphs mixed approximation can always be turned into a multiplicative approximation – at the cost of a blow-up in the number of vertices. More precisely, we prove the following reduction.
Theorem 3.1
Let be an algorithm that provides a -approximation for APSP in time, for any unweighted -node -edge graph , and any constants and . Given an unweighted graph on n nodes and m vertices, we can compute -APSP in time.
If is a dynamic algorithm, then each update takes time. The query time remains the same (up to a constant factor).
This reductions allows for as well. However, for our applications the update time of will depend on , so we only apply this reduction for . Theorem 1.3 is obtained by splitting every edge into k edges, by introducing new nodes on the edge. Now a path corresponding to a approximation cannot take a non-trivial detour. We combine this result with Theorem 1.2 to obtain a -approximation for unweighted graphs in total update time. For details, see Sect. 5.2.
-APSP for Unweighted Graphs
In this section, we describe our near-additive APSP algorithm. Our work is inspired by a classic result of Dor, Halperin, and Zwick [24], that presented a static algorithm that computes purely additive approximation for APSP in time in unweighted graphs. Our goal is to obtain similar results dynamically. More concretely, we obtain decremental -approximate APSP in total update time in unweighted graphs.
-APSP
To explain the high-level idea of the algorithm, we first focus on the special case that , and that we only want to approximate the distances between pairs of nodes at distance at most d from each other, for a parameter d. In this case, we obtain a -additive approximation in time. This case already allows to present many of the high-level ideas of the algorithm. Later we explain how to extend the results to the more general case. We start by describing the static algorithm from [24], and then explain the dynamic version. At a high level, we compute exact distances for some nodes , and then use this to obtain approximate distances for all other nodes . The static version of the data structure is as follows. See also the pseudocode in Algorithm 1.
Let . Let be the set of heavy nodes: . Also let be the set of light edges, i.e. edges with at least one endpoint with degree less than .
Node set . Construct a hitting set of neighborhoods of nodes in . This means that every node has a neighbor in . The size of is .
Edge set . Let be a set of size O(n) such that for each , there exists such that .
Computing distances from . Store distances by running a BFS from each on the input graph G.
Computing distances from . For each store a shortest path tree, denoted by rooted at u by running Dijkstra on , where is the set of weighted edges corresponding to distances in computed in the previous step.

Dynamic data structure. The static algorithm computes distances in two steps. First, it computes distances from by computing BFS trees in the graph G. This step can be maintained dynamically by using Even-Shiloach trees (ES-trees) [74], a data structure that maintains distances in a decremental graph. Maintaining the distances up to distance O(d) takes time. The more challenging part is computing distances from the remaining nodes . Here the static algorithm computes distances in the graphs . Note that the graphs change dynamically in several ways. First, in the static algorithm, the set is the set of light edges. To keep the correctness of the dynamic algorithm, every time that a node v no longer has a neighbor in , we should add all its adjacent edges to . Second, when an edge in is deleted from G, we should replace it by an alternative edge if such an edge exists. Finally, the weights of the edges in can change over time, when the estimates change. This means that other than deletions of edges, we can also add new edges to the graphs or change the weights of their edges. Because of these edge insertions we can no longer use the standard ES-tree data structure to maintain the distances, because that only works in a decremental setting.
To overcome this, we use monotone ES-trees, a generalization of ES-trees proposed by [2, 7]. In this data structure, to keep the algorithm efficient, when new edges are inserted, the distance estimates do not change. In particular, when edges are inserted, some distances may decrease, however, in such cases the data structure keeps an old larger estimate of the distance. The main challenge in using this data structure is to show that the stretch analysis still holds. In particular, in our case, the stretch analysis of the static algorithm was based on the fact that distances from the nodes are computed in the graphs , where in the dynamic setting, we do not have this guarantee anymore.
Stretch analysis. The high-level idea of the stretch analysis uses the special structure of the graphs . To prove that the distance estimate between u and v is at most , we distinguish between two cases: 1) ; and 2) .
In the first case, an edge of the form is in for some , and since we maintain correctly the distances from , we can prove that we get an additive stretch of at most 2 in this case.
In the second case, all the edges adjacent to v are in , and here we can use an inductive argument on the length of the path to prove that we get an additive stretch of at most 2. Note that the estimate that we get can be larger compared to the distance between u and v in the graph , but we can still show that the additive approximation is at most 2 as needed. For a detailed stretch analysis, see Sect. 6.1.2.
Update time. Our update time depends on the size of the graphs . While in the static setting it is easy to bound the number of edges in and , in the decremental setting, as new edges are added to these sets, we need a more careful analysis. For example, in the static setting , as any node only adds one adjacent edge to the set , where in the decremental setting, we may need to add many different edges to this set because the previous ones got deleted. However, we can still prove that even if a node needs to add to edges to all its adjacent neighbors in during the algorithm, the size of is small enough as needed. A detailed analysis of the update time appears in Sect. 6.1.3, where we show that the total update time is in expectation, this matches the static complexity up to the factor d.
Handling large distances. The algorithm described above is efficient if d is small, to obtain an efficient algorithm for the general case, we combine our approach with a decremental near-additive APSP algorithm. More concretely, we use an algorithm from Henzinger et al. [7] that computes -approximate APSP in a total update time that depends on . For , their total update time is bounded by . Now we set , and distinguish between two cases. For pairs of nodes at distance at most d from each other, we get a -additive approximation as discussed above, in time. For pairs of nodes at distance larger than d, the near-additive approximation is already a -approximation by the choice of the parameter d. For such pairs, the additive term becomes negligible, as their distance is . Overall, we get a -approximation for APSP in time. In fact, if the graph is dense enough (), the term is replaced by a poly-logarithmic term. For more details see Sect. 6.2.4.
General k
We can extend the algorithm to obtain a -approximate APSP in total update time, by adapting the general algorithm of [24] to the dynamic setting. At a high-level, instead of having one hitting set , we have a series of hitting sets , such that the set hits nodes of degree . We compute distances from in appropriate graphs , that are sparser when the set is larger. Balancing the parameters of the algorithm leads to the desired total update time. For full details and proofs see Sect. 6.2.
Limitations of previous approaches
We next explain why approaches used in previous decremental algorithms cannot be generalized to obtain our near-additive results. First, the unweighted -approximate APSP algorithm that takes time [2], is inspired by static algorithms for -additive emulators, sparse graphs that preserve the distances up to a -additive stretch. The main idea is to maintain a sparse emulator of size , and exploit its sparsity to obtain a fast algorithm taking time. This construction however is specific for the case, and cannot be generalized to a general k. Note that the update time of the algorithm crucially depends on the size of the emulator, and to obtain a better algorithm for a general k, we need to be able to construct a sparser emulator for a general k. However, a beautiful lower bound result by Abboud and Bodwin [83] shows that for any constant k and , a purely additive emulator should have edges. This implies that dynamic algorithms that are based on purely additive emulators with edges seem to require time, and we cannot get running time arbitrarily close to . An alternative approach is to build a near-additive emulator. This is done in [7], where the authors show a -approximation algorithm for decremental APSP with expected total update time of . Here the running time indeed gets closer to , but this comes at a price of a much worse additive term of . While in the static setting there are also other bounds obtained for near-additive emulators, such as emulators of size [84–87], in all of the constructions the additive term depends on , and the dependence on is known to be nearly tight for small k by lower bounds from [86]. Hence this approach cannot lead to small constant additive terms that do not depend on .
-Approximate APSP for Weighted Graphs
Given an undirected, weighted graph , where w takes positive, integer values, our goal is to maintain -approximate all-pairs distances in G, denoted by . We provide an algorithm
with parameters , and that gives a -approximation of APSP for weighted graphs, with ratio between the maximum and minimum weight W. Overall, the total update time scales with , for an exact statement see Lemma 4.7, which explicitly states the dependency on , W, and . The algorithm has a constant query time.
We recommend the reader to first read Sect. 3.1, where we provide a static version of the algorithm and we discuss the challenges and techniques of making this dynamic. This section starts with our high-level dynamic algorithm in Sect. 4.1, we provide further details and parametrized update time analysis of each step in Sect. 4.2, and we provide the stretch analysis in Sect. 4.3. In Sect. 4.4, we combine these and set the parameter p appropriately to obtain our final result.
Decremental Data Structures
We will make use of the -approximate5 bunches and clusters that are introduced in Sect. 2.2. However, for efficiency purposes, we do not use these bunches themselves, but instead look at bunches with some additional approximation. The goal is to ensure that the bunches do not increase too often.
Let A be a set of nodes sampled with probability . Recall that, for each node v, the pivot p(v) is the closest node in A to v.
Lemma 2.1 gives us an approximate pivot , together with a distance estimate , such that . Further, we have -approximate bunches: , and distance estimate such that for all .
We now define our final approximate bunch, which we denote by B(v).6
Definition 1
We need the following notions related to bunches and clusters:
For all , we keep track of a -approximate bunch radius r(v), which is a -approximation of the approximate distance to the approximate pivot, i.e., of . We denote by the bunch radius at time t. Initially, we set . We update whenever , if so then we set .
Initially, we set . Whenever , we set , otherwise we set .
The cluster of a node is the set .
Note that these bunches B(v) increase at most times by construction. Next, let us investigate the sizes of these sets.
Lemma 4.1
At any given time
-
(i)
With high probability, A has size ;
-
(ii)
With high probability, each bunch B(v) has size ;
Proof
-
(i)Since A is created by sampling each element of V with probability , we have , so . By Chernoff bounds, for any :
Setting gives , so with high probability . -
(ii)
This holds trivially as , and at any moment in time due to Lemma 2.1.
Now, we give a description of the algorithm in Algorithm 2, which is a dynamic version of the static algorithm given in Sect. 3.1.1. Next, we give a proof of correctness and show how to implement each of the steps. We provide a separate initialization procedure, as for some steps it will turn out that the initialization step and the update steps are quite different.
Throughout the algorithm, we set whenever we want a distance estimate to update at most times. Note that we can always maintain such a with only a constant multiplicative factor in the total update time. Moreover, it is clear that . Below we define the functions Initialization(), and functions used after each edge update : Delete(u, v), Update(u, v, w(u, v)). Finally we have the Query() function that returns a final estimate over different data structures maintained.
Algorithm 1.

APSP()
Update bunches and heaps (Update Step (2)). Now let us look more closely at how we maintain the bunches and clusters, and how these effect the heaps. We maintain the approximate bunches for all by Lemma 2.1. From here maintain the additional approximate bunches B(v) for all as given in Definition 1, i.e., If there is a change to , do the following two things:
We check if , and if so we set and we set . If not, we set and .
Let be a node for which there is a change to the bunch involving a node . Such a change can be: (i) w can leave the bunch of (ii) the distance estimate of w to can change while w stays within the bunch, or (iii) w can join the bunch of . We formalize this as follows, using to denote which case we are in.
-
(i)
and , we set to indicate that w is no longer in .
-
(ii)
and with an increased distance estimate , we set to be the new distance.
-
(iii)
and , we set to be the distance.
Next, we do the following.
-
Nbr-BunchChange() to update the corresponding entries in the data structures for every . If this changes the minimal entry in for some , we check whether we need to update , if so we run the procedure
Adj-MinHeapChange().
UpdateAdjacent() to update the corresponding entries in the data structures for every .
Further Details and Time Analysis
In this section, we add further details of the procedures described and analyze the total update time. Considering the sampling of A in the algorithm, we note that A remains unchanged throughout the algorithm, hence it is only sampled once at the initialization. This takes O(n) time. To maintain distances from A, we use the decremental shortest path algorithm from Lemma 2.2 together with Lemma 4.1, which bounds the size of A, to obtain the following lemma.
Lemma 4.2
With high probability, we can maintain -approximate SSSP from each node in A, providing us with for and . We can do this in time if and , and in time otherwise.
Bunches and clusters. We have approximate bunches and pivots by Lemma 2.1, now we maintain the bunch radii r(v) and approximate bunches B(v) and clusters C(v) according to Definition 1. As before, we simply set . It is immediate that these extra steps do not incur more than a constant factor in the update time with respect to Lemma 2.1, so we obtain the following result.
Lemma 4.3
We can maintain -approximate bunch radii r(v) with respect to the approximate pivots . With high probability, we can maintain approximate bunches B(v) and clusters C(v), and distance estimates for , for all nodes . Moreover, we can maintain , a -approximation of that updates at most times. This takes total update time , for some arbitrarily small constant , if , and otherwise.
Neighboring bunch data structure. To maintain , we maintain an auxiliary data structure, which is another Min-Heap . This data structure consists of the following ingredients. We say B(v) is a neighboring (approximate) bunch of x if there exists an edge from x to B(v). For every node x, and every neighboring bunch B(v) our goal is to store all neighbors y such that together with , which allows us to find the neighbor y minimizing this sum for each neighboring bunch.7 Later, we will combine this with the distance estimate for to get a distance estimate from u to v, which will be stored in . To make sure we do not have to update the entries in , we do not maintain the minimum of exactly, but instead we maintain an additional approximation, denoted that only changes at most a polylogarithmic number of times.
Lemma 4.4
With high probability, we can maintain the data structures for all in total update time . Moreover, in the same total update time, we can maintain an approximation of the minimum entry of that only changes at most times for each pair (x, v).
Proof
This data structure is initialized as follows:
Iterate over every vertex , and over all . Then iterate over all neighbors of y and add an entry to the data structure with key . This takes initialization time, since there are n options for v, it has bunch size , so options for y, which has at most n neighbors.
We need to facilitate two types of updates for an entry of corresponding to an edge : increases in the weight and increases in the distance estimates . We define the functions Nbr-EdgeChange(a)nd Nbr-BunchChange(r)espectively.
Next, we consider how to update this data structure. Suppose a value changed for some due to an update to the bunches (Lemma 4.3), then we would need to change the corresponding entries in . Lemma 4.3 gives us y, v, and the new distance , which we need to update in all data structures for which . To do this efficiently, we maintain a set for each edge that stores for which there is an entry in and a pointer to where in that data structure it appears. We equip this set with the structure of a self-balancing binary search tree, so we have polylogarithmic insertion and removal times. We update this every time the appearance or location in changes. Now if changes due to an update, we can efficiently change the corresponding places in for all relevant .
Moreover, for the changes in the distances from the bunches, we maintain a set for each that stores for which there is an entry in and a pointer to where in that data structures it appears. We equip this set with the structure of a self-balancing binary search tree, so we have polylogarithmic insertion and removal times. We update this every time the appearance or location in changes. Now if changes due to an update, we can efficiently change the corresponding places in for all relevant .
We define the function Nbr-EdgeChange(), where , and is the new value , or if the edge is deleted. Depending on , we do one of the following:
-
(i)If , we update the corresponding estimates:
- For each entry , update the corresponding entry in and update the entry in accordingly.
-
(ii)If , we remove the corresponding estimates:
- For each entry , remove the corresponding entry in .
Concerning the total update time of Nbr-EdgeChange(,) we recall that . This means that each weight gets updated at most times, giving total update time .
We define the function Nbr-BunchChange(), where y is an element of and/or , and is the new value , or if y is no longer in B(v). Nbr-BunchChange(d)oes one of three things:
-
(i)If , , and , we add the corresponding new estimates:
- We initialize to be empty.
- For all neighbors of y, we add to and store x together with its location in in .
-
(ii)If , , and , we update the corresponding estimates:
- For each entry , update the corresponding entry in and update the entry in accordingly.
-
(iii)If , , and , we remove the corresponding estimates:
- For each entry , remove the corresponding entries from and from .
Moreover, if one of these three actions change the minimum of , this has an impact on the data structures . We run Adj-MinHeapChange(), which is defined and analyzed in Lemma 4.5, to propagate this change. Here is the minimum of . The total update time of Adj-MinHeapChange(i)s included in Lemma 4.5, and not in this lemma.
As can change at most times, and for each time we need at most time to update the data structure, we get total update time for the pair (y, v). Now note that there are at most such pairs, since there are n options for v, with options for . So we get total update time .
Further, we maintain , which is a -approximation of the minimal entry of , defined by . Note that is not monotone over time, so it is not trivial how often the estimate changes. However, note that increases at most times in a row. It can only decrease times, since the values are non-decreasing, except if new vertices are considered. This is only the case when the bunch grows, which happens at most times by Lemma 4.3.
Adjacent data structure. Using , we construct the required Min-Heap for each pair . For every pair of nodes our goal is to store all edges such that and , together with the distance .
Lemma 4.5
With high probability, we can maintain the data structures for all in total update time .
Proof
This data structure is initialized as follows:
Iterate over all nodes u, all , and all neighboring bunches B(v) of x and add an entry for x to with key . As there are at most n bunches in total, this takes time.
Again, we maintain additional data structures to facilitate updates: for each , we maintain which shows for which there is an entry in and a pointer to where in that data structure it appears. We update this every time the appearance or location in changes. Now if changes due to an update, we can efficiently change the corresponding places in .
We define Adj-BunchChange(a)nalogously to Nbr-BunchChange(.) Adj-BunchChange() does one of the following three things:
-
(i)If , , and , we add the corresponding new estimates:
- We initialize to be empty.
- For all nodes with non-empty , we add to and store v together with its location in in .
-
(ii)If , , and , we update the corresponding estimates:
- For each entry , update the corresponding entry in and update the entry in accordingly.
-
(iii)If , , and , we remove the corresponding estimates:
- For each entry , remove the corresponding entries from and from .
As updates in bunches/distance estimates in bunches happen times, see Definition 1, we get total update time .
We also define the function Adj-MinHeapChange(t)o process changes in . The function Adj-MinHeapChange() does one of the following three things:
-
(i)If and the distance estimate from x to v is new,, we add the corresponding new estimates:
- We initialize to be empty.
- For all , we add to and store u together with its location in in .
-
(ii)If and there already was a distance estimate from x to v,, we update the corresponding estimates:
- For each entry , update the corresponding entry in and update the entry in accordingly.
-
(iii)If and there is no longer a distance estimate from x to v,, we remove the corresponding estimates:
- For each entry , remove the corresponding entries from and from .
Since each updates at most times by Lemma 4.4, we get total update time for this operation.
Together, Nbr-BunchChange(a)nd Adj-BunchChange(f)orm the function UpdateAdjacent(.) To be precise, we define UpdateAdjacent(a)s follows:
UpdateAdjacent():
Nbr-BunchChange()
Adj-BunchChange()
This means we obtain total update time
Query time. Finally, we observe that the query is relatively straightforward and can be done in constant time.
Lemma 4.6
has constant query time.
Proof
A query consists of the minimum over four values. The first two can be computed in constant time, as the components are all maintained explicitly. The last two are maintained explicitly. This gives us constant query time in total.
We summarize this section in the following lemma.
Lemma 4.7
With high probability, the algorithm
has total update time if , , and for an arbitrarily small constant . If , we have total update time . Otherwise we have total update time .
Proof
We inspect the total update times from all components of Algorithm 2, using that . First of all, we can perform the sampling of A in O(n) time. By Lemma 4.2, we can maintain distances from A in total update time if and , or in total update time otherwise. By Lemma 4.3, we can maintain the bunches and clusters in total update time, for some arbitrarily small constant , if , or in total update time otherwise. Moreover, by Lemma 4.4, we can maintain our neighboring bunch data structure in total update time. Finally, by Lemma 4.5, we can maintain our adjacent data structure in total update time.
In total, this means for the case that and , we have total update time
If we furthermore assume that , i.e., for some arbitrarily small , then we obtain the simplified version
For other choices of m, n, and p, we obtain
Stretch Analysis
We can now follow the same structure as outlined in the high-level overview to prove the stretch in different cases for each pair . In our analysis we also discuss how maintaining approximate bunches and distances impacts the final stretch.
Lemma 4.8
For all , the distance estimate returned by a query to
is a -approximation of the distance d(u, v).
Proof
Let . We will show that at any time t, if Query(u, v) returns , then we have . Since we look at all data structures at the same time t, we omit the superscripts in the remainder of this proof.
First, let us note that consists of different distance estimates that all correspond to actual paths in G, hence we clearly have . Heaps do not contain ‘old’ entries, entries that correspond to paths that are no longer in G at the time of query, since the update functions Nbr-BunchChange(,) Nbr-EdgeChange(,) Adj-MinHeapChange(,) and Adj-BunchChange(t)ake such entries out as soon as they are no longer relevant.
Next, we do a case distinction as follows. Let denote the shortest path from u to v.
- There exists such that (the left case in Fig. 1). Since , we have , so . Similarly . Since , we have either or . Without loss of generality, assume , then by Query Step (a) in the algorithm we have:
where in the last step we use . - There is no such that (the right case in Fig. 1). This means there has to be a direct edge from the cluster of u to the cluster of v: the shortest path consists of a path from u to , for some , an edge , for some , and a path from to v (see the right case in Fig. 1). Note that in particular this includes the cases where or , or more general when , since we do not require , , , or . By Query Step (b) we have
where in the last step we use , and .
Putting Everything Together
In this section we combine our lemmas in the following theorem. To obtain this result, we pick p to balance the different terms in the total update time.
Theorem 1.1Given a graph G with positive, integer weights and a constant , there is a decremental data structure that maintains a -approximation of APSP. The algorithm has constant query time and works against an oblivious adversary. The total update time is w.h.p.
if and for an arbitrary small constant ,
if for any constant ,
otherwise,
where W is the ratio between the maximum and minimum weight.
Proof
This follows from Lemma 4.7 and 4.8, by picking p to minimize . This gives , implying . Note that whenever and , this choice of p indeed satisfies the other requirements of Lemma 4.7: . Since we now assume that and are constants, the factor simplifies to O(1).
When , we obtain an extra factor in the total update time, which simplifies to for constant . And when , we obtain the extra factor and , where the latter again simplifies to O(1) for constant and .
-APSP for Weighted Graphs and Unweighted 2-APSP
In this section, we show that an adapted version of the algorithm from Sect. 4 returns -approximate distances with improved update time, where is the maximum weight on a shortest path from u to v. This result follows by the fact that in this case we do not need to handle the adjacent bunch case, but instead can consider an overlap bunch case (see the middle case in Fig. 2), which leads to an improved total update time.
To make this efficient, there are some additional complications. We introduce a parameter , the bunch overlap threshold, which bounds the cluster size. For nodes with cluster smaller than , we can compute the estimate in the overlap case efficiently. If all nodes in the overlap have larger clusters, we obtain an estimate by computing shortest paths from the heavy nodes.
We recommend the reader to first read the static version of this algorithm in Sect. 3.2. We then present the details of the dynamic version in Sect. 5.1. Moreover, in Sect. 5.2, we show our general reduction from mixed APSP to purely multiplicative APSP for unweighted graphs. We use this reduction to obtain our unweighted -APSP result.
-APSP for Weighted Graphs
We use the same structure as in Sect. 4: we have bunches, and clusters exactly as before. We introduce the parameter to be set later. Now we define nodes to be heavy or light based on their cluster size.
We call a node u heavy if it is or ever was contained in at least approximate bunches B(v), i.e., u is heavy at time t if for some . If a node is not heavy, we call it light.
We denote for the set of heavy nodes, and for the light nodes. By definition of heavy nodes, a light node can become heavy, but a heavy node can never become light.
Suppose we have a distance estimate for all . For each node , q(u) is the closest node in to u according to the distance estimate .
We can show that the size of is bounded.
Lemma 5.1
At any given time, with high probability, has size .
Proof
Let and denote the bunch of v and the cluster of w respectively at time t. Since bunch radius r(v) increases by at least a factor if the bunch changes, we have at most different bunch radii. Until the bunch radius increases, the bunch can only lose vertices, which does not contribute to the total size. Since each bunch is of size with high probability by Lemma 4.1, we obtain that the total size of a bunch over the course of the algorithm is bounded by . Hence we have
Thus .
Now we are ready to present our new algorithm, see Algorithm 3.
Algorithm 2.

APSP()
Updating bunches and heaps. For completeness, we recall how we update the bunches and clusters. We now maintain different heaps. Again, we maintain the approximate bunches for all by Lemma 2.1. From here maintain the additional approximate bunches B(v) for all as given in Definition 1, i.e., If there is a change to , do the following two things:
We check if , and if so we set and we set . If not, we set and .
Let be a node for which there is a change to the bunch involving a node . Such a change can be: (i) w can leave the bunch of (ii) the distance estimate of w to can change while w stays within the bunch, or (iii) w can join the bunch of . We formalize this as follows, using to denote which case we are in.
-
(i)
and , we set to indicate that w is no longer in .
-
(ii)
and with an increased distance estimate , we set to be the new distance.
-
(iii)
and , we set to be the distance.
Next, we do the following. If we are in Case (iii), we check the cluster size of w: if , then we add w to and we initialize a SSSP approximation, denoted by . Moreover, for each in we do the following:
UpdateOverlap() to remove the corresponding entries from the data structures for all . Here stores exactly those such that there is an entry for w in . The details on can be found together with the definition and total update time of UpdateOverlap(a)re given in Lemma 5.3.
If we are in Case (iii) but , or we are in Case (i) or (ii), then we do the following
UpdateOverlap() to update the corresponding entries in the data structures for all .
Distances from . First, we note that a node is heavy if it is contained in at least bunches, or equivalently, if . Hence by Lemma 4.3, we can easily keep track when nodes become heavy and should join .
Next, we use the shortest path algorithm from Lemma 2.2, which we combine with Lemma 5.1, which states that might be growing over time, but its size is always bounded by . Moreover, we maintain the closest heavy nodes q(v) by maintaining a Min-Heap for each node v, with all nodes as entries with key . Throughout, we will use that we can extract the minimum entry of a Min-Heap in constant time, that we can insert entries in time, and that we can edit or delete entries in time, given that we know either the key or have a pointer to their location in the Min-Heap.
This clearly does not incur more than a constant factor in the update time, so together we obtain the following lemma.
Lemma 5.2
With high probability, we can maintain -SSSP from each node in , providing us with for and . Further, for all , we can maintain the closest heavy nodes q(v) if . We can do this in total update time if and , and otherwise.
Overlap data structure. Now we provide the details of how we maintain the data structure for all , which has entries for all nodes .
Lemma 5.3
With high probability, we can maintain the data structures for all in total update time .
Proof
Conceptually, we initialize a Min-Heap for each pair . In practice, we only create the Min-Heap if the first entry is about to be added. This avoids a initialization time. Now fix , and consider the moment we add a node w to B(v). For this data structure, we only need to consider , hence w is part of at most bunches. When we add w to to B(v), we know it is part of at most other bunches B(u). For each such tuple (u, w, v), we add an entry to the Min-Heap for (u, v), which stores w with as key the distance estimate . For the total time, notice that for each , we have at most different for which we store at most distances, hence we have total initialization time .
Next, we consider how to update this data structure. Suppose a value changed for some due to an update to the bunches (Lemma 4.3), then we would need to change the corresponding entries in . Lemma 4.3 gives us u, w, and the new distance , which we need to update in all data structures for which . Clearly, checking all possible v and looking through the entire is too slow. Instead, we keep an additional data structure for each node : a set that shows for which it appears in and a pointer to where in it appears. We equip this set with the structure of a self-balancing binary search tree, so we have polylogarithmic insertion and removal times. We update this every time the appearance or location in changes. Now, if changes due to an update, we can efficiently change the corresponding places in as follows.
We define the function UpdateOverlap(), where w is an element of and/or , and is the new value , or if w is no longer in . Note that we will only call this function for light w.8UpdateOverlap(d)oes one of three things:
-
(i)If , and . We add the new estimates:
- We initialize to be empty.
- For each , we add to and store v together with its location in as entries in and .
-
(ii)If , and . We update the estimates:
- For each entry of v in , update in and update the entries in and accordingly.
-
(iii)If , then and . We remove the corresponding estimates:
- For each entry of v in , remove from and remove the corresponding entries from and .
For the total update time, notice that in total at most nodes get added to a bunch, see Lemma 4.1. Since we only call this function when the added node w is light at that time, we have and thus step (i) takes total update time. For step (ii), note that the distance can be updated at most times and therefore this step has total update time . Further nodes get deleted from bunches at most as often as they get added, so the total update time of step (iii) is dominated by step (i). We obtain total update time .
We summarize the update times in the following lemma.
Lemma 5.4
With high probability, the algorithm
has total update time if , , , and . Otherwise we have total update time .
Proof
We inspect the total update times from all components of Algorithm 3. First of all, we can perform the sampling of A in O(n) time. By Lemma 4.2, we can maintain distances from A in total update time if and , or in total update time otherwise. By Lemma 4.3, we can maintain the bunches and clusters in total update time, for some arbitrarily small constant , if , or in total update time otherwise. Moreover, by Lemma 5.2, we can maintain distances from in total update time if and , or in total update time otherwise. Finally, by Lemma 5.3, we can maintain our overlap data structure in total update time.
In total, this means for the case that , , and , we have total update time
using that is a constant. If we furthermore assume that , i.e., for some arbitrarily small , then we obtain the simplified version
For other choices of m, n, p, and , we obtain
Theorem 1.2Given a graph G with positive, integer weights and a constant , there is a decremental data structure that maintains a -approximation for APSP, where is the maximum weight on a current shortest path from u to v. The algorithm has constant query time and works against an oblivious adversary. The total update time is w.h.p. if , and otherwise, where W is the ratio between the maximum and minimum weight.
Proof
This result follows from exchanging the adjacent data structure for the overlap data structure as described in this section.
By Lemma 5.4, we have a total update time scaling with . To balance out these terms, we set , hence . We set , hence . Note that for , this choice for and also satisfies the additional constraints of Lemma 5.4, so in this case we obtain total update time , where the last equality holds for constant . If , we obtain , where again the equality holds for constant .
Stretch analysis. It remains to show that is a -approximation of the distance d(u, v). We do a similar case distinction as in Lemma 4.8. Case 1 is exactly the same, since we maintain the relevant estimate through the pivots. For the remainder, we know there is no such that , hence the two bunches are adjacent. We know create cases depending on whether the bunches overlap, and if so, if the node in the overlap is heavy or light.
-
Case 2:(the right case in Fig. 2). Hence consists of a path from u to , the edge with , and a path from to v. Since , we have , so . Similarly, we have . Combining this, we obtain . Without loss of generality, assume that . By Query Step (a) we have:
-
Case 3:There exists such that and (the middle case in Fig. 2). By Query Step (c), we have
-
Case 4:There exists such that and (See Fig. 3). If then by Query Step (b), we have . If , the argument is analogous. If , then by definition of q(u) and q(v) we obtain and . So we have , hence either or . Without loss of generality, assume . Combining this with the triangle inequality, we obtain
Query time. A query consists of the minimum over three values. The first two can be computed in constant time, as the components are all maintained explicitly. The last one is maintained explicitly. This gives us constant query time in total.
Fig. 3.

Possible scenario for the overlap between the bunches B(u) and B(v) and the shortest path from u to v where the estimate can be obtained using the closest heavy node and
In particular, this means we get -approximate APSP for unweighted graphs.
Reduction and Unweighted -APSP
Next, we provide a reduction that transforms -APSP to -APSP on unweighted graphs. This reductions allows for as well. However, for our applications the update time of will depend on , so we only apply this reduction for .
Intuitively, we split every edge into edges to form . Then we compute (2, k)-APSP on , divide the result by , and round down to the nearest integer. Because the additive error k is not enough to reach a new node in G, we can simply ignore this part of the path. In the following theorem we make this formal.
Theorem 3.1Let be an algorithm that provides a -approximation for APSP in time, for any unweighted -node -edge graph , and any constants and . Given an unweighted graph on n nodes and m vertices, we can compute -APSP in time.
If is a dynamic algorithm, then each update takes time. The query time remains the same (up to a constant factor).
Proof
We construct the auxiliary graph as follows.
Clearly this graph has vertices and edges. We compute -APSP on in time using algorithm , and denote the output by . We set for all .
We now show that gives -approximate APSP on G. Let . We remark that for all . Which we will use twice.
First, we show that . This follows from .
Second, we show that . This follows from
Now if , then is an integer, hence . If , then can be bigger than 1 – if it is not, we are done by the same argument. If , then
Hence we obtain
For the claim about dynamic algorithms, note that any update to an edge in G, corresponds to updating edges in . The query consists of computing , which requires a query to the distance in plus constant time operations.
In particular, this can give fast algorithms for sparse graphs. For the decremental case, we obtain the following result.
Theorem 1.3Given an undirected unweighted graph G, there is a decremental data structure that maintains a -approximation for APSP with constant query time. The algorithm works against an oblivious adversary. W.h.p. the total update time is bounded by if , and otherwise.
Proof
We apply the theorem above with the -APSP of this paper, Theorem 1.2. This takes time if , and time otherwise.
Approximate APSP with Additive Factors
In this section we give our last result, which is maintaining approximate APSP on unweighted graphs with a mixed additive and multiplicative stretch. First, we provide a decremental -APSP algorithm as a warm-up in Sect. 6.1. In Sect. 6.2, we generalize our techniques to provide an efficient decremental -APSP algorithm.
Warm-up: -APSP
Our goal in this section is to use a simpler algorithm based on [24] that let us maintain -APSP in total update time of in unweighted undirected graphs with edges. Such an algorithm would outperform the approach in Sect. 4 when , and it also gives a better near-additive approximation. We focus on obtaining an algorithm that can maintain -additive approximate distances for pairs within distance d in total update time . This approach can be combined with Theorem 2.6 to get our desired bounds.
Dynamic Data Structure
In Sect. 3.3, we described the static algorithm of [24]. We next describe the dynamic version of the algorithm. As mentioned above, we first focus on maintaining a data structure for pairs of nodes at distance at most d from each other. The algorithm is a variant of the static algorithm. At a high-level, we use ES-trees to maintain distances from nodes in in the graph G, giving us exact distances for these nodes. For the remaining nodes , we use monotone ES-trees to maintain distances in the graph , giving us approximate distances. The algorithm is summarized as follows.
Node set . We define a random set by sampling each node to with probability for and a constant of our choice.
Edge set . For each node v that has at least one neighbor in , we add one edge to , where u is an arbitrarily chosen neighbor of v in .9
Edge set . For each node v that does not have a neighbor in , we add all the adjacent edges to v to the set .
Maintaining ES-trees from nodes in . For every , we maintain an ES-tree rooted at u up to distance in the graph G.
Maintaining monotone ES-trees from nodes in . For each node , we maintain a monotone ES-tree rooted at u up to distance in the graph , where are all the edges of the form where . The weight of an edge is , the level of u in the ES-tree rooted at v computed in the previous step.
Maintaining the monotone ES-trees. Next, we give more details about maintaining the monotone ES-trees from nodes .
Initially, we construct a shortest path tree from in the original graph , up to distance .
Each time the distance estimate between u and a node increases, we update the weight of the edge . Note that we can maintain these distances exactly (up to distance ) as we compute them in the ES-tree rooted at . We also update the monotone ES-tree rooted at u according to the weight change of .
Each time an edge between a node and is deleted from the graph G, we distinguish between two cases. If v still has a neighbor , we first add a new edge to the set and then delete the edge . Otherwise, we add to all the edges incident to v in the current graph G, and then delete the edge .
If an edge is deleted, we delete it from .
There are several challenges in maintaining the monotone ES-trees. First, during the algorithm there are insertions to the graph , as new edges are added to and , and our goal is to show that our distance estimates still give a good approximation to the actual distances. In the static version of the algorithm, the algorithm computes the exact distances in the graphs and this provides a good approximation for the distances. However, in our case, the monotone ES-trees are not guaranteed to keep the actual distances in because they ignore distance decreases that come from edge insertions, and we should prove that this does not affect the stretch of the algorithm.
In addition, in the static version of the algorithm it is easy to argue that the graphs are sparse. For example, is a set of at most O(n) edges, since each node v added at most one edge. In our case, as changes dynamically, we need to prove that the total number of edges added to it is small. In particular, as each time that an edge in gets deleted, we replace it by another edge, it could be the case that overall in the algorithm we add many different edges to which can affect the total update time of the algorithm. In addition, each time that a node v no longer has a neighbor in , we add all its adjacent edges to , and we should argue that the number of edges added to is small. We will discuss these issues in more detail later, and show that we can implement the monotone ES-trees efficiently. Next, we provide the stretch analysis of the algorithm.
Stretch Analysis
For any pair of nodes u, v, we denote by the level of v in the ES-tree or monotone ES-tree rooted at u. We start with the following simple observation.
Claim 6.1
For any such that , we have that
Proof
As , we maintain the exact distances from x up to distance in the ES-tree rooted at x. Hence, we have . If , the same argument holds also for . If , in Step 2 of the algorithm for maintaining the ES-tree we make sure that we also maintain the correct distance between u and x in the monotone ES-tree rooted at u, hence . Note that as the edge always appears in , and by part (4) of Lemma 2.4 we always maintain the exact distance estimate in this case.
Claim 6.2
For any such that , we have that
Proof
If , this already follows from Claim 6.1. Hence we focus on the case that . The left side of the inequality follows as , using part (2) of Lemma 2.4, and since the distances in can only increase compared to distances in G. This holds as the edges in are either edges in G or have a weight that is at least the weight of the shortest path between the corresponding endpoints in G. We next show that . We prove the claim by double-induction. First, on the time in the algorithm, and second on the distance .
Base Case. At the beginning of the algorithm, this follows from the correctness of the static algorithm, we give the details for completeness. Note that at the beginning of the algorithm, from part (1) of Lemma 2.4, we have that as long as , and we show that this is indeed the case when .
- v has a neighbor in . In this case there is an edge such that . Note that as x is a neighbor of v it holds that . As and , the graph has an edge with weight , and it also has the edge . Hence, at the beginning of the algorithm, we have
Now, by the triangle inequality
Hence, overall, we get that . Note that we get the , which implies that the distance is indeed maintained correctly in the monotone ES-tree. - v does not have a neighbor in . In this case, all the edges adjacent to v are in . Let be the edge adjacent to v in the shortest path between u and v in G. Then, . From the induction hypothesis, we have that . Since the edge exists in , we get that
As , we indeed maintain the value correctly in the monotone ES-tree.
Induction Step. Assume now that the claim holds after edge deletions, and we will prove it holds after t edge deletions. We prove it by induction on the length of the path between u and v in the current graph G. In the base case that it trivially holds. First, if the value did not change after the t-th edge deletion, then the claim follows from the induction hypothesis (as the distance can never decrease). Hence, we focus on the case that changed. By parts (3) and (4) of Lemma 2.4, when the level is changed it is necessarily increased, and the new value is equal to .
When the value increases, v has a neighbor in . By Step 3 of the algorithm for maintaining the ES-tree, it is guaranteed that there is an edge . Also, by Claim 6.1 and since , as x is a neighbor of v. Hence, when we update the value , the new value is at most The exact same proof that we used in the base case, shows that . Hence, , as needed. Again, as this value is bounded by it is maintained correctly.
- When the value increases, v does not have a neighbor in . It follows from Step 3 of the algorithm for maintaining the ES-tree that all the edges adjacent to v are in . Let x be the neighbor of v in the shortest path in G. By the induction hypothesis, . Hence,
this value is again at most , hence it is maintained correctly, completing the proof.
Time Complexity
To analyze the time complexity of the algorithm, we first bound the total number of edges added to and in the algorithm.
Claim 6.3
The total number of edges added to during the algorithm is bounded by with high probability.
Proof
By definition, the edges in are the edges adjacent to all nodes that do not have a neighbor in . We show that as long as the degree of a node v is then with high probability it has a neighbor in . This follows as is obtained by sampling each node with probability . Hence, as long as the degree of v is at least , the probability that none of its neighbors is in is at most . It follows that with high probability each node adds less than edges to , proving the claim.
Claim 6.4
The expected number of edges to ever be present in is .
Proof
Recall that each node is added to the set with probability . Hence, in expectation each node v has neighbors in the set , where is the degree of v at the beginning of the algorithm. These edges are candidates to be added to the set , and in the worst case all of them are added to during the algorithm. Summing over all nodes, the expected number of edges added to is bounded by
Lemma 6.5
The total update time of the algorithm is in expectation.
Proof
Computing the set takes O(n) time by sampling each node to the set independently with probability .
Maintaining the sets and is done as follows. At the beginning of the algorithm, each node v scans its neighbors until it finds the first neighbor u in the set if exists, and it adds the edge to the set . If there is no such u, then v adds all its adjacent edges to the set . During the algorithm, when the edge is deleted, v continues scanning its neighbors until it finds the next neighbor w in the set if exists. If w exists it adds the edge to , and otherwise it adds all its adjacent edges to . Note that in the whole algorithm, v only needs to scan its neighbors once to find all the edges it adds to . Hence, overall maintaining the sets and takes O(m) time. We can also keep a list of the new edges added to and after a deletion, to help maintaining the monotone ES-trees.
We maintain the ES-trees from nodes as follows. Every time that an edge is deleted we delete it from all the trees. In addition, every time that a level increases for , we update the weight of the edge in the graph , and update it in the monotone ES-tree rooted at v. Maintaining the ES-trees from nodes in takes time by Lemma 2.3. By the definition of , this equals
in expectation, when
We maintain the monotone ES-trees rooted at nodes as follows. After an edge e is deleted, we update the weights of the edges when their weights are increased in the ES-trees rooted at nodes , as described above. In addition, we add to all the edges that were added to and after the deletion of the edge e (we kept them in a list as described above), and finally we delete the edge e from the monotone ES-tree. By Lemma 2.5, the total update time for maintaining the monotone ES-tree rooted at the node u is , where is the total number of edges ever contained in and is the total number of updates to . There are O(n) edges in and each of them is updated O(d) times, as the distance estimates only increase and can have O(d) values. This adds O(nd) term to the complexity of one tree, and summing up over all trees. The edges in and are only added and removed once in the algorithm. The total number of edges in is with high probability from Claim 6.3. Summing up over all trees these edges add term to the complexity. The total number of edges in is bounded by in expectation from Claim 6.4. Summing up over all trees they add term to the complexity, completing the proof.
Claim 6.6
The query time of the algorithm is O(1).
Proof
To answer a distance query for a pair of nodes u, v, we just return the value . This can be done in O(1) time if we keep for each node u an array of the values which is updated each time a distance estimate change.
In conclusion, we get the following.
Theorem 6.7
Given an undirected unweighted graph G, there is a decremental data structure that maintains -additive approximation for APSP for pairs of nodes at distance at most d from each other. The expected total update time is bounded by , and the query time is constant.
To get rid of the d term in the complexity, we can combine our approach with Theorem 2.6. This would lead to a -approximation and replace the d term in the complexity by an term (which simplifies to for constant . We will provide full details of the approach when we describe our general algorithm in the next section (see in particular Sect. 6.2.4). The high-level idea is to use our algorithm with a parameter , and combine it with Theorem 2.6 for computing -approximation for large distances. For an appropriate choice of the parameters, we will get a -approximation for the distances between pairs of nodes at distance greater than d from each other, and a approximation for pairs of nodes at distance at most d from each other.
-APSP
With this warm-up we can move on to the more general algorithm based on [24] that leads to a larger stretch but a smaller update time. Our goal is to obtain a -approximation in time. The algorithm works in unweighted undirected graphs. As before, we start by describing a data structure that maintains the approximate distances for pairs of nodes at distance at most d from each other, and then in Sect. 6.2.4 we combine it with Theorem 2.6 to handle the general case.
Dynamic Data Structure
The algorithm is summarized as follows.
Node sets . We define a series of sets such that for , the set is a random set obtained by sampling each node with probability , for , and a constant for our choice. If a node is sampled to several different sets we keep it only in the set with minimum index i among them. Finally, we define Note that by definition, each node is in exactly one set .
Indices for all . For a node , we denote by the minimum index i such that v has a neighbor in .
Edge set . For each node v, we add one edge to , where x is an arbitrary neighbor of v in .
Edge sets . The edges are all the edges where . In other words, it is all the edges adjacent to nodes that do not have a neighbor in for .
- Maintaining monotone ES-trees. The algorithm maintains monotone ES-trees as follows.
- For every , we maintain an ES-tree rooted at u up to distance in the graph G.
- For every , we maintain a monotone ES-tree rooted at u up to distance in the graph , where are all the edges , where for . The weight of the edge is equal to the value in the monotone ES-tree rooted at v.
Note that we maintain the monotone ES-trees up to distance . As we show in the stretch analysis, this is needed in order to guarantee that we maintain correct estimates for any pair of nodes at distance at most d from each other. Intuitively, as the distance estimate we maintain is at most , we would like to maintain correct estimates for pairs of nodes at distance from each other. Another k term comes from the inductive argument of the stretch analysis. For more details, see Sect. 6.2.2.
In Sect. 6.2.3, we explain in detail how to maintain the data structures efficiently. When we maintain the graphs we make sure that the following holds (for a proof, see Sect. 6.2.3).
Claim 6.8
Let . Throughout the updates, it always holds that v either has an edge , where for , or all the edges adjacent to v are in .
We are in the first case of the claim when , and we are in the second case when .
Stretch Analysis
We need the following claims. First, from part (1) of Lemma 2.4 we have the following.
Claim 6.9
At the beginning of the algorithm, for any , and any v at distance at most from u in , we have
We next show the following.
Claim 6.10
Let such that , then .
Proof
The claim follows as we always have an edge with weight in the graph , and the value is monotonically increasing during the algorithm. Hence, and from part (4) of Lemma 2.4, every time that the estimate changes it always changes to a value that is at most .
We next prove the stretch guarantee of the algorithm.
Lemma 6.11
For any node , and any node where , throughout the updates we have .
Proof
First, the left inequality holds since , where the first inequality follows from the definition of , and the second follows from part (2) of Lemma 2.4. We prove the right inequality by triple-induction, on the value i, on the time in the algorithm, and on the distance . For , the claim follows as we maintain ES-trees up to distance from the nodes of in the graph G. We next assume that it holds for any , and prove that it holds for i. The proof is by induction on the time in the algorithm and on the distance .
Base Case. We first show that the claim holds at the beginning of the algorithm. From Claim 6.9, at the beginning of the algorithm, for any u, v where , we have that Hence, our goal is to show that . Note that if this holds, then since , we get that , hence the distance is maintained in the monotone ES-tree as needed. The proof is by induction on .
- . In this case, there is an edge such that for . Note that since , and w is a neighbor of v, then we have . Hence, we can use the induction hypothesis on w and u. From the induction hypothesis and Claim 6.9, we have (note that this value is smaller than , so we can indeed use Claim 6.9). Hence, we get that
We have, . Hence, we get, , as needed. - . In this case, by definition, all the edges adjacent to v are in . Let w be the neighbor of v on the shortest path. From the induction hypothesis, . So we have
Induction Step. We assume that the claim holds after edge deletions, and show that it holds after t edge deletions. The proof is by induction on the distance . If , the claim trivially holds. If the estimate did not change after the t’th edge deletion, then the claim holds from the induction hypothesis. Note that an edge deletion can potentially lead to several changes of the value . It is enough to prove that the stretch guarantee holds in the last time the value increases, as the value stays the same afterwards. We divide into cases based on Claim 6.8.
- When the value increases in the last time, there is an edge such that for . From part (4) of Lemma 2.4, when changes, it gets the value , assuming this value is at most , and we will show that this is indeed the case. Hence,
Here we use Claim 6.10 and the fact that for (note that since , and w is a neighbor of v, it follows that , so we can indeed use the induction hypothesis). It also holds that . Hence, overall, we have , as needed. Note that this value is indeed smaller than , hence we maintain the correct estimate in the monotone ES-tree. - When the value increases in the last time, all the adjacent edges to v are in the graph . Let w be the neighbor of v on the shortest path. When the distance estimate of v changes we have
where we use the induction hypothesis on w and part (4) of Lemma 2.4. Note that it follows that the values are smaller than , hence they are maintained correctly in the monotone ES-tree.
Time Complexity
We next analyze the time complexity of the algorithm. We start by showing that the first steps of the algorithm can be maintained efficiently.
Claim 6.12
The first 4 steps of the algorithms can be maintained in time.
Proof
Step 1. Computing the sets takes O(kn) time, by just sampling each node to the set with probability . For each node v, we can stop the sampling after the first time v is sampled to one of the sets. This is only done once at the beginning of the algorithm. For each node v, we keep the index i such that . For each i, we create a list of all the nodes in the set . Creating all these lists takes O(n) time by scanning the nodes.
Steps 2 and 3. The indices and the set are maintained dynamically in the algorithm, as follows. At the beginning, each node v scans its neighbors to find the minimum index i such that v has a neighbor in , it also saves the name of an edge to the first neighbor of v in , this edge is added to set . In the algorithm, if the edge is deleted, then v goes over its next neighbors, and finds the next neighbor if exists. If such a neighbor exists, then is added to . Otherwise, the value increases, and v scans its neighbors again to determine the new index and adds the first edge from v to a neighbor in to . Note that overall in the algorithm each node needs to scan its neighbors O(k) times, because as long as the value stays the same, we just need to go over the neighbors once during the whole algorithm to determine all the edges added to . Overall these steps take O(mk) time.
Step 4. Maintaining the sets is done as follows. Initially, we add to all the edges adjacent to nodes v where . During the algorithm, every time that the value of a node v changes, say from j to , then for all , we add the edges adjacent to v to the set . We also keep a list of all the newly added edges in after a deletion of an edge, so that we can update them in all the relevant monotone ES-trees. The time complexity for maintaining the set is proportional to the number of edges added to during the algorithm, which can trivially be bounded by O(m), hence this step takes at most O(mk) time.
Maintaining the monotone ES-trees. The main challenge in the algorithm is maintaining the monotone ES-trees in Step 5 of the algorithm. Before analyzing the time complexity of the algorithm, we start by describing the algorithm in more detail. Note that each time an edge is deleted it can lead to many changes, including edge insertions and weight changes in all the trees we maintain. We next explain in detail in which order we make these changes in order to maintain the correctness of the algorithm. We use the algorithms for ES trees and monotone ES trees described in Sect. 2.4.
ES-trees rooted at nodes of . First, for any node , we start by creating an ES-tree rooted at u in the graph G, maintained up to distance . After creating this tree, for any for , we add an edge with weight to the set of edges . During the algorithm, every time an edge is deleted, we delete it from the ES-tree and update it accordingly. For any v where has increased after the deletion and where for , we update the corresponding edge in , and save it in a list of edges in that were updated after the deletion. This completes the description for .
Monotone ES-trees rooted at nodes of . For for larger values of i, we maintain the monotone ES-trees according to the order of the index i, from 2 to k. We work as follows. Initially, we create a monotone ES-tree rooted at u up to distance in the graph , with the edges at the beginning of the algorithm, and with the edges that were obtained when creating the monotone ES-trees in previous levels. Note that all these edges of are of the form where for , so we indeed already created the monotone ES-tree rooted at the relevant nodes v. After creating the tree, for any node for , we add a new edge to the set with weight . During the algorithm, when an edge e is deleted, we update the monotone ES-trees in several steps as follows, again we work according to the order of the index i.
First step: adding the new edges of and to . The deletion of the edge e can lead to adding new edges to or in steps 3 and 4 of the algorithm. As explained in these steps, we maintain the newly added edges, and can add them to a list of newly added edges (to and to separately). When we update the monotone ES-tree rooted at , we start by adding all these newly added edges that were added to and to .
Second step: updating the edges in . Next, there are possibly edges in that their weight is increased after the deletion. This is already observed when we update the monotone ES-tree rooted at v, and if it happens, we add the edge with new weight to a list of edges that were updated in . When we update the monotone ES-tree rooted at u, we update the weights of all these edges (we already have their list after we finish maintaining the ES-trees in previous levels).
Third step: deleting the edge e. Lastly, we delete the edge e that was deleted in this step from the monotone ES-tree.
Note that the weight increases and deletion can increase the levels of some nodes in the tree. For any v in for such that increases, when the value increases, we add an edge with the new weight to the list of newly updated edges in . This completes the description of the algorithm. From the above description, we can now prove Claim 6.8.
Proof of Claim 6.8
Let . At the beginning of the algorithm, if , then there exists an edge where for . Otherwise, , and all the edges adjacent to v are in . During the algorithm, every time an edge e of the form is deleted, then if after the deletion, we add a new edge to for for , and if , we add all the edges adjacent to v to . In the algorithm, we first add these new edges to , and only then delete the edge e, which proves the claim.
To bound the time complexity, we need the following useful claims that bound the total number of edges added to the sets and during the algorithm.
Claim 6.13
For , the total number of edges added to during the algorithm is bounded by with high probability.
Proof
The edges are all the edges adjacent to nodes v where . We show that at the first time in the algorithm that , the degree of v is at most with high probability. This implies that each node v adds at most edges to the set , proving the claim. To bound the degree of v, note that by definition the set is obtained by sampling each node with probability , all these nodes are added to the set , unless they are already part of a set for . As long as the degree of v is at least , the probability that none of the neighbors of v is sampled to is at most . Hence, with high probability v has a neighbor sampled to , implying that as long as . From union bound, this holds for all nodes with high probability. This proves that the total number of edges added to in the algorithm is bounded by . Note that the proof assumes that we have an oblivious adversary and that the order in which edges are deleted does not depend on the random choices of the algorithm.
Claim 6.14
In expectation, the total number of edges added to the set in the algorithm is bounded by
Proof
We analyze the number of edges v adds to the set when for all i. First, when , then in the worst case v adds to edges to all its neighbors in . By the definition of , each node is added to with probability . Hence, in expectation v has neighbors in , where is the degree of v at the beginning of the algorithm. When we sum up over all v, this adds at most edges in expectation, where the last equality follows from the definition of .
When for , as we proved in Claim 6.13, with high probability the degree of v is at most . Note that each one of the neighbors of v is added to with probability . Hence, in expectation, v has neighbors in . In the worst case, it adds edges to all of them during the algorithm. In total, the expected number of edges added by all nodes to in the case that is bounded by . By the definition of , we have that . Hence, in total the expected number of edges added is bounded by
Next, we prove the complexity of the algorithm.
Lemma 6.15
Maintaining the ES-trees takes time in expectation.
Proof
Maintaining the ES-trees rooted at nodes in takes time by Lemma 2.3. Since in expectation, and by the choice of , this adds term to the complexity, when .
From Lemma 2.5, maintaining a monotone ES-tree rooted at takes time, where is the total number of edges ever contained in and is the total number of updates to . To complete the proof, we should analyze these values. Recall that . Note that has at most edges, that are updated O(d) times during the algorithm, as we maintain distances up to distance , hence these edges add O(nd) term to the complexity of maintaining one tree, and for all n trees. The edges in and are only added and removed once from a tree during the algorithm. From Claim 6.13, the total number of edges added to during the algorithm is bounded by with high probability. Since these edges are part of all the ES-trees rooted at nodes in , maintaining these edges adds term to the complexity. This equals
following the same calculations done in Claim 6.14 (but with an extra nd term). Summing over all k adds another multiplicative k term to the complexity. From Claim 6.14, the total number of edges added to is bounded by in expectation. Summing over all n trees, it adds another term to the complexity, completing the proof.
Claim 6.16
The query complexity of the algorithm is constant.
Proof
To answer a distance query for a pair of nodes u, v, we work as follows. If , and , our distance estimate is , otherwise our distance estimate is . Note that it is easy to maintain the values in a way that the query time is constant. For example, we can maintain for each node u an array with the values , and update the value in constant time each time it was changed in the algorithm.
Putting Everything Together
In the last sections we showed an algorithm that for any pair of nodes at distance at most d maintains a -additive approximation in time. To get our final result, we combine it with Theorem 2.6 to handle large distances, proving the following.
Theorem 1.4Given an undirected unweighted graph G, a constant and an integer , there is a decremental data structure that maintains -approximation for APSP with constant query time. The algorithm works against an oblivious adversary. The expected total update time is bounded by where .
Note that for small values of k and if for a constant , we get a complexity of , where in the general case we have an extra term.
Proof
We maintain simultaneously our dynamic data structure to handle short distances of at most d, and the data structure from Theorem 2.6 to handle large distances of more than d, for a parameter d which we specify next. We run the algorithm from Theorem 2.6 with parameters , and to be specified later. Recall that this algorithm gives a -approximation for . We define .
To answer a distance query for a pair of nodes u, v, we return the minimum between the values obtained in both algorithms. As in both algorithms the query time is constant, we get a constant query time.
For the stretch analysis, if , then by Lemma 6.11, we get an additive stretch of at most . If , then the distance estimate we get from the -approximation algorithm is at most
Hence, overall we get a -approximation, as needed.
We now analyze the time complexity. From Lemma 6.15, the time complexity of our algorithm (for small distances) is , and from Theorem 2.6 the time complexity of the near-additive approximation algorithm is . We distinguish between two choices for the value . First we choose , where . In this case, the complexity of both expressions is bounded by , as , and .
Second, we choose . In this case, . Similarly, , where the last equality follows since we assume to be a constant. Hence, in total we get a complexity of , when .
Conclusion
We presented new tradeoffs for decremental approximate APSP in undirected graphs. For weighted graphs, we obtained a -approximation with total update time and a faster -approximation with total update time . For unweighted graphs, we obtained a -approximation with total update time , yielding the first subquadratic algorithm for sufficiently sparse graphs, as well as a family of -approximation algorithms with total update time . These results demonstrate that approximation guarantees between and 3, which have been extensively studied in the static setting [26–28, 35, 37, 45, 46], can also be exploited to obtain substantially faster decremental APSP algorithms.
Despite this progress, the landscape of decremental APSP remains far from fully understood. One of the central open questions is to characterize for which approximation guarantees the total update time of a decremental APSP algorithm can match, up to subpolynomial factors, the running time of the best corresponding static algorithm. For single-source shortest paths, a remarkably complete picture has emerged through a long line of work culminating in near-linear update times for a wide range of approximation guarantees [1, 7, 8, 14, 18, 20, 74]. In contrast, for APSP there remain substantial gaps. For example, our -approximate weighted algorithm achieves total update time , matching the classical static construction of Cohen and Zwick [27] up to polylogarithmic factors. However, since then faster static 2-approximations have been developed: Baswana and Kavitha [28] give an algorithm for 2-APSP taking time. For dense graphs, Dory et al. [37] give -APSP in time and a distance oracle for 2-APSP taking time. Determining whether these gaps between decremental and static can be closed, or whether they reflect inherent barriers, remains an open question.
A second major direction concerns robustness against stronger adversaries and deterministic computation. Most of the fastest decremental APSP algorithms, including ours, rely on randomization and are analyzed against an oblivious adversary [2, 4, 13]. On the other hand, substantial progress has been made in the deterministic setting for large-stretch approximations and related shortest-path problems [16–18, 21, 50, 73, 77, 89].
Nevertheless, no deterministic or adaptive-adversary decremental APSP algorithms are known with update times comparable to those achieved in the oblivious-adversary setting for approximation guarantees around . Closing these gaps would represent a major advance in dynamic graph algorithms.
Finally, the fully dynamic setting remains largely unexplored in the approximation regime considered in this paper. Fully dynamic APSP has a long history, beginning with exact algorithms [48, 57, 58, 75, 76] and continuing with approximate algorithms [5, 12, 22]. However, the best known fully dynamic -approximate APSP algorithms still require roughly amortized update time per operation [5], and there has been comparatively little progress toward achieving the kinds of improvements that are now known in the decremental setting. It remains open whether approximation guarantees between 2 and 3 admit substantially faster fully dynamic algorithms and whether techniques such as approximate bunches or hopsets can be extended to support insertions efficiently.
We hope that the techniques introduced in this work—particularly the dynamic maintenance of approximate bunches and the use of bunch-overlap thresholds—provide useful tools for addressing these questions and for further narrowing the gap between static, decremental, and fully dynamic shortest-path algorithms.
Monotone ES-tree
Algorithm 4 provides pseudocode for the monotone ES-tree algorithm, this is taken from [8].
Algorithm 3.

Monotone ES-tree
Maintaining Bunches and Clusters
In this section we give a sketch of the algorithm of Łącki and Nazari [20] that allows us to maintain bunches and clusters needed for the decremental algorithm in Sect. 4. One tool used is a decremental algorithm by Roditty and Zwick [4] that maintains Thorup-Zwick clusters up to a bounded depth. This result can be summarized as follows:
Lemma B.1
([4]). Let and be parameters. Given a dynamic graph , that has edge deletions, weight increases, and edge insertions that do not decrease distances, we can maintain clusters (with sampling probability p) and bunches up to depth d in total update time . Moreover, we maintain distances from each node to its cluster and its bunch, and these distances are monotone (non-decreasing).
This time dependence on d is too expensive for many applications, and thus [20] improve the time for maintaining approximate bunches and clusters by maintaining a hopset, combined with a well-known scaling tool.
Hopsets. Hopsets, originally introduced by Cohen and Zwick [27] in the context of parallel algorithms, are widely used in faster algorithms in decremental settings. We briefly define this concept and sketch its application.
Definition 2
Let be a weighted undirected graph, and let be a parameter. A -hopset is a graph such that for each we have , where denotes the length of the shortest path between u and v in that uses at most hops. We say is the hopbound of the hopset and is the stretch of the hopset.
Theorem B.2
([20]) Let be parameters. We can maintain a -hopset H for with hopbound in total update time . Moreover, we can assume that the distances incurred by the additional edges of the hopset are monotone. Further we have that H is of size .
By setting , we can maintain a hopset with hopbound in amortized time. We often choose this parameter setting when the graph is sparse for balancing the hopset maintenance time with the shortest path computation time. By setting to a constant, we can maintain a hopset of polylogarithmic hopbound in time . We often use this parameter setting when we are maintaining distances from many sources and the graph is slightly denser (e.g. ).
Scaling. The following scaling technique of Klein and Subramanian [90] changes a bounded hop distance problem into a bounded depth distance problem on a scaled graph. Similar ideas have been widely used in dynamic algorithms, see e.g., [5, 6, 8, 20]. As we will see, the bounded depth works well together with the cluster and bunch maintaining algorithm of Roditty and Zwick [4]
Lemma B.3
([90]) Let be a weighted undirected graph. Let , , be parameters. We define a scaled graph to be a graph , such that . Then for any path in G such that has at most d hops and weight we have: 1) , and 2) .
Hence given a hopset, we can ‘cover’ the entire graph by scaled graphs, by considering separate scaled graphs for the distance scale for . In order to combine this with a hopset algorithm, we need to scale the graph after adding edges corresponding to a sequence of -restricted hopsets, i.e. a graph that satisfies the hopset condition only for pairs within distance at most . Slightly more formally, we define a scaled graph as follows: , where is a -restricted hopset. The final hopsets of [20] are the union of all these restricted hopsetes, however for maintaining distances efficiently we need to run the algorithm in Lemma B.1 on all these scaled graphs simultaneously and take the minimum estimate over all the scales. Importantly, to handle edge insertions they use monotone ES trees which implies that the distances obtained from this algorithm is monotone. This is important for us in bounding the running time of our decremental data structures.
The following lemma shows that using the specific hopsets by [20], we can maintain approximate single-source distances.
Lemma 2.1Let be a decremental graph, and let and be parameters, let be a sampling probability, and let be a set of sampled nodes, where each element of V is sampled uniformly at random with probability p. There exists an algorithm that maintains for each : (i) an approximate pivot ; (ii) an approximate bunch ; and (iii) distance estimates for every . These objects satisfy:
;
;
is monotone (non-decreasing over updates);
for any : ; and
with high probability, .
The algorithm has total update time .
Proof sketch
First, using the algorithm of [20], we can maintain a -hopset H of size in update time with hopbound , which consists of a sequence of -restricted hopsets . We then use the framework of [20] to maintain approximate clusters and hence approximate bunches on the scaled graphs. Since for all in there is a path with -hops that with length at most , they show that it is enough to maintain -hop bounded bunches/clusters on scaled graphs . We consider -bounded bunches where is the closest sampled node in and . The scaling ensures that for each node v there exists such that satisfies the property . Let d be the distances obtained by scaling back the estimates corresponding to . There exists i such that satisfies . Also by choosing the appropriate error parameters (to account for the scaling and hopset errors) in Theorem 14 of [20] we can ensure that for any we have . Consider any . We have . Hence we can see that the bunch and thus contains all the nodes in .
Finally since the algorithm of [20] (that is based on [4]) maintains bunches of size on scaled graphs, we also have the bound on the size of the bunch.
Author Contributions
All authors contributed equally.
Funding
Open access funding provided by Graz University of Technology. This work was supported by The Israel Science Foundation (Grant No. 2829/25). This work was supported in part by funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No. 853109), and the Swiss National Foundation (project grant 200021-184735). This project has received funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 947702). This research was funded in whole or in part by the Austrian Science Fund (FWF) https://doi.org/10.55776/P36280, https://doi.org/10.55776/P32863, and https://doi.org/10.55776/I6915. For open access purposes, the author has applied a CC BY public copyright license to any author-accepted manuscript version arising from this submission.
Data Availability
No datasets were generated or analysed during the current study.
Declarations
Conflict of interest
The authors have no conflict of interest to declare.
Consent to Publication
Consent to Publish declaration: not applicable.
Ethical Approval
Ethics and Consent to Participate declarations: not applicable.
Footnotes
In the introduction, we make two simplifying assumptions: (a) is a constant and (b) the ratio W between the maximum and minimum weight is polynomial in n. Unless otherwise noted, the cited algorithms have constant or polylogarithmic query time. Throughout we use notation to omit factors that are polylogarithmic in n.
Note that the algorithms of Roditty and Zwick [4] for unweighted, undirected graphs precede the more general algorithm of Bernstein [11] for weighted, directed graphs.
Although the picture implies B(u) and B(v) are disjoint, this also includes the case where they overlap, or even where or .
The actual pivot only matters when a distance is queried, where we can use our explicitly maintained approximate pivots. See Sect. 4 for details.
We write each approximation with its own . In the end, we set for all i, which gives us -APSP.
In the high-level overview B(v) has been used for the exact bunches. Since exact bunches do not occur in our actual algorithm, B(v) will denote these approximate bunches from here on, following conventions in prior work [1, 8, 88]
Recall that we denote for .
If w becomes heavy we remove all the corresponding estimates.
In Sect. 4 and 5.1 we needed the distance between nodes v and their closest node in , called the pivot. In this section, we only need an edge between v and an arbitrary neighbor .
This work was partially conducted while Michal Dory was a postdoc at ETH Zurich.
This work was partially conducted while Yasamin Nazari was a postdoc at University of Salzburg.
This work was partially conducted while Tijn de Vos was a PhD student at the University of Salzburg.
Publisher's Note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
References
- 1.Bernstein, A., Chechik, S.: Deterministic decremental single source shortest paths: beyond the bound. In Daniel Wichs and Yishay Mansour, editors, Proceedings of the 48th Annual ACM SIGACT Symposium on Theory of Computing (STOC 2016), pages 389–397, (2016)
- 2.Henzinger, M., Krinninger, S., Nanongkai, D.: Dynamic approximate all-pairs shortest paths: breaking the barrier and derandomization. SIAM J. Comput. 45(3), 947–1006 (2016). (Announced at FOCS 2013) [Google Scholar]
- 3.Baswana, S., Hariharan, R., Sen, S.: Improved decremental algorithms for maintaining transitive closure and all-pairs shortest paths. J. Algorithms 62(2), 74–92 (2007). (Announced at STOC 2002) [Google Scholar]
- 4.Roditty, L., Zwick, U.: Dynamic approximate all-pairs shortest paths in undirected graphs. SIAM J. Comput. 41(3), 670–683 (2012). (Announced at FOCS 2004) [Google Scholar]
- 5.Bernstein, A.: Fully dynamic approximate all-pairs shortest paths with fast query and close to linear update time. In Proceedings of the 50th Annual IEEE Symposium on Foundations of Computer Science, FOCS 2009, pages 693–702. IEEE Computer Society, (2009)
- 6.Bernstein, A., Roditty, L.: Improved dynamic algorithms for maintaining approximate shortest paths under deletions. In Dana Randall, editor, Proceedings of the Twenty-Second Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2011, pages 1355–1365. SIAM, (2011)
- 7.Henzinger, M., Krinninger, S., Nanongkai, D.: A subquadratic-time algorithm for decremental single-source shortest paths. In Proceedings of the Twenty-Fifth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2014, pages 1053–1072. SIAM, (2014)
- 8.Henzinger, M., Krinninger, S., Nanongkai, D.: Decremental single-source shortest paths on undirected graphs in near-linear total update time. J. ACM 65(6), 36:1-36:40 (2018). (Announced at FOCS 2014) [Google Scholar]
- 9.Abboud, A., Williams, V. V.: Popular conjectures imply strong lower bounds for dynamic problems. In Proceedings of the 55th IEEE Annual Symposium on Foundations of Computer Science (FOCS 2014), pages 434–443 (2014)
- 10.Henzinger, M., Krinninger, S., Nanongkai, D., Saranurak, T.: Unifying and strengthening hardness for dynamic problems via the online matrix-vector multiplication conjecture. In Proceedings of the Forty-Seventh Annual ACM on Symposium on Theory of Computing (STOC 2015), pages 21–30, (2015)
- 11.Bernstein, A.: Maintaining shortest paths under deletions in weighted directed graphs. SIAM J. Comput. 45(2), 548–574 (2016). (Announced at STOC 2013) [Google Scholar]
- 12.Abraham, I., Chechik, S., Talwar, K.: Fully dynamic all-pairs shortest paths: Breaking the o(n) barrier. In Proceedings of the 17th International Workshop on Approximation Algorithms for Combinatorial Optimization Problems (APPROX 2014) and the 18th International Workshop on Randomization and Computation (APPROX/RANDOM 2014), pages 1–16 (2014)
- 13.Chechik, S.: Near-optimal approximate decremental all pairs shortest paths. In Mikkel Thorup, editor, Proceedings of the 59th IEEE Annual Symposium on Foundations of Computer Science (FOCS 2018), pages 170–181, (2018)
- 14.Bernstein, A.: Deterministic partially dynamic single source shortest paths in weighted graphs. In Proceedings of the 44th International Colloquium on Automata, Languages, and Programming, (ICALP 2017), pages 44:1–44:14, (2017)
- 15.Karczmarz, A., Łącki, J.: Reliable hubs for partially-dynamic all-pairs shortest paths in directed graphs. In Proceedings of the 27th Annual European Symposium on Algorithms (ESA 2019), pages 65:1–65:15, (2019)
- 16.Karczmarz, A., Łącki, J.: Simple label-correcting algorithms for partially dynamic approximate shortest paths in directed graphs. In Proceedings of the 3rd Symposium on Simplicity in Algorithms (SOSA 2020), pages 106–120, (2020)
- 17.Chuzhoy, J.: Decremental all-pairs shortest paths in deterministic near-linear time. In Samir Khuller and Virginia Vassilevska Williams, editors, Proceedings of the 53rd Annual ACM SIGACT Symposium on Theory of Computing (STOC 2021), pages 626–639. ACM, (2021)
- 18.Bernstein, A., Gutenberg, M. P., Saranurak, T.: Deterministic decremental SSSP and approximate min-cost flow in almost-linear time. In Proceedings of the 62nd IEEE Annual Symposium on Foundations of Computer Science (FOCS 2021), pages 1000–1008, (2021)
- 19.Evald, J., Fredslund-Hansen, V., Gutenberg, M. P., Wulff-Nilsen, C.: Decremental APSP in unweighted digraphs versus an adaptive adversary. In Proc. of the 48th International Colloquium on Automata, Languages, and Programming, (ICALP 2021), pages 64:1–64:20, (2021)
- 20.Łącki, J., Nazari, Y.: Near-Optimal Decremental Hopsets with Applications. In: 49th International Colloquium on Automata, Languages, and Programming (ICALP 2022). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, (2022)
- 21.Chuzhoy, J., Saranurak, T.: Deterministic algorithms for decremental shortest paths via layered core decomposition. In Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms (SODA 2021), pages 2478–2496, (2021)
- 22.Forster, S., Goranci, G.: Bootstrapping dynamic distance oracles. In: Proceedings of the 31th Annual European Symposium on Algorithms (ESA 2023), (2023). (Yasamin Nazari, and Antonis Skarlatos)
- 23.Roditty, L., Zwick, U.: On dynamic shortest paths problems. Algorithmica 61(2), 389–401 (2011). (Announced at ESA 2004) [Google Scholar]
- 24.Dor, D., Halperin, S., Zwick, U.: All-pairs almost shortest paths. SIAM J. Comput. 29(5), 1740–1759 (2000). (Announced at FOCS 1996) [Google Scholar]
- 25.Abraham, I., Chechik, S.: Dynamic decremental approximate distance oracles with (, ) stretch. CoRR, arXiv:abs/1307.1516, (2013)
- 26.Aingworth, D., Chekuri, C., Indyk, P., Motwani, R.: Fast estimation of diameter and shortest paths (without matrix multiplication). SIAM J. Comput. 28(4), 1167–1181 (1999). (Announced at SODA (1996)) [Google Scholar]
- 27.Cohen, E., Zwick, U.: All-pairs small-stretch paths. J. Algorithms 38(2), 335–353 (2001). (Announced at SODA 1997) [Google Scholar]
- 28.Baswana, S., Kavitha, T.: Faster algorithms for all-pairs approximate shortest paths in undirected graphs. SIAM J. Comput. 39(7), 2865–2896 (2010). (Announced at FOCS 2006) [Google Scholar]
- 29.Berman, P., Kasiviswanathan, S. P.: Faster approximation of distances in graphs. In Frank K. H. A. Dehne, Jörg-Rüdiger Sack, and Norbert Zeh, editors, Proceedings of the 10th International Workshop on Algorithms and Data Structures (WADS 2007, pages 541–552, (2007)
- 30.Kavitha, T.: Faster algorithms for all-pairs small stretch distances in weighted graphs. Algorithmica 63(1–2), 224–245 (2012). (Announced at FSTTCS 2007) [Google Scholar]
- 31.Baswana, S., Goyal, V., Sen, S.: All-pairs nearly 2-approximate shortest paths in time. Theoret. Comput. Sci. 410(1), 84–93 (2009). (Announced at STACS 2005) [Google Scholar]
- 32.Patrascu, M., Roditty, L.: Distance oracles beyond the thorup-zwick bound. SIAM J. Comput. 43(1), 300–311 (2014). (Announced at FOCS 2010) [Google Scholar]
- 33.Sommer, C.: All-pairs approximate shortest paths and distance oracle preprocessing. In Proceedings of the 43rd International Colloquium on Automata, Languages, and Programming, (ICALP 2016), volume 55, pages 55:1–55:13, (2016)
- 34.Knudsen, M. B. T.: Additive spanners and distance oracles in quadratic time. In Proceedings of the 44th International Colloquium on Automata, Languages, and Programming, (ICALP 2017), pages 64:1–64:12, (2017)
- 35.Akav, M., Roditty, L.: An almost 2-approximation for all-pairs of shortest paths in subquadratic time. In Proceedings of the 2020 ACM-SIAM Symposium on Discrete Algorithms, (SODA 2020), pages 1–11, (2020)
- 36.Akav, M., Roditty, L.: A unified approach for all pairs approximate shortest paths in weighted undirected graphs. In Proceedings of the 29th Annual European Symposium on Algorithms (ESA 2021), volume 204, pages 4:1–4:18, (2021)
- 37.Dory, M., Forster, S., Kirkpatrick, Y., Nazari, Y., Williams, V. V., de Vos, T.: Fast 2-approximate all-pairs shortest paths. In Proc. of the 2024 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 4728–4757. SIAM (2024)
- 38.Patrascu, M., Roditty, L., Thorup, M.: A new infinity of distance oracles for sparse graphs. In: Proc. of the 53rd Annual IEEE Symposium on Foundations of Computer Science (FOCS 2012), pages 738–747. IEEE Computer Society, (2012)
- 39.Abboud, A., Bringmann, K., Fischer, N.: Stronger 3-sum lower bounds for approximate distance oracles via additive combinatorics. In: Proc. of the 55th Annual ACM Symposium on Theory of Computing, (2023). (STOC 2023)
- 40.Zwick, U.: Exact and approximate distances in graphs - A survey. In: Proceedings of the 9th Annual European Symposium on Algorithms (ESA 2001), volume 2161, pages 33–48, (2001)
- 41.Ryan Williams, R.: Faster all-pairs shortest paths via circuit complexity. SIAM J. Comput. 47(5), 1965–1985 (2018). (Announced at STOC 2014) [Google Scholar]
- 42.Thorup, M., Zwick, U.: Approximate distance oracles. J. ACM (JACM) 52(1), 1–24 (2005) [Google Scholar]
- 43.Deng, M., Kirkpatrick, Y., Rong, V., Williams, V. V., Zhong, Z.: New additive approximations for shortest paths and cycles. In Mikolaj Bojanczyk, Emanuela Merelli, and David P. Woodruff, editors, 49th International Colloquium on Automata, Languages, and Programming, ICALP 2022, July 4-8, 2022, Paris, France, volume 229 of LIPIcs, pages 50:1–50:10. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, (2022)
- 44.DüDürr, A.: Improved bounds for rectangular monotone min-plus product and applications. Inf. Process. Lett. 181, 106358 (2023) [Google Scholar]
- 45.Saha, B., Ye, C.: Faster approximate all pairs shortest paths. In: Proceedings of the 2024 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 4758–4827. SIAM (2024)
- 46.Roditty, L.: New algorithms for all pairs approximate shortest paths. In Barna Saha and Rocco A. Servedio, editors, Proceedings of the 55th Annual ACM Symposium on Theory of Computing, STOC 2023, Orlando, FL, USA, June 20-23, 2023, pages 309–320. ACM, (2023)
- 47.Chechik, S., Zhang, T.: Nearly 2-approximate distance oracles in subquadratic time. In Proc. of the 2022 ACM-SIAM Symposium on Discrete Algorithms, SODA 2022, pages 551–580. SIAM, (2022)
- 48.Demetrescu, C., Italiano, G.F.: Fully dynamic all pairs shortest paths with real edge weights. J. Comput. Syst. Sci. 72(5), 813–837 (2006). (Announced at FOCS 2001) [Google Scholar]
- 49.Baswana, S., Hariharan, R., Sen, S.: Maintaining all-pairs approximate shortest paths under deletion of edges. In Proceedings of the Fourteenth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2003), pages 394–403, (2003)
- 50.Haeupler, B., Long, Y., Saranurak, T.: In 65th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2024, Chicago, IL, USA, October 27-30, 2024, pages 2033–2044. IEEE, (2024)
- 51.Mądry, A.: Faster approximation schemes for fractional multicommodity flow problems via dynamic graph algorithms. In: Proceedings of the 42nd ACM Symposium on Theory of Computing (STOC 2010), pages 121–130, (2010)
- 52.Garg, N., Könemann, J.: Faster and simpler algorithms for multicommodity flow and other fractional packing problems. SIAM J. Comput. 37(2), 630–652 (2007). (Announced at FOCS 1998) [Google Scholar]
- 53.Fleischer, L.: Approximating fractional multicommodity flow independent of the number of commodities. SIAM J. Discrete Math. 13(4), 505–520 (2000). (Announced at FOCS 1999) [Google Scholar]
- 54.Chen, L., Kyng, R., Liu, Y. P., Peng, R., Gutenberg, M. P., Sachdeva, S.: Maximum flow and minimum-cost flow in almost-linear time. In 63rd IEEE Annual Symposium on Foundations of Computer Science, FOCS 2022, pages 612–623. IEEE, (2022)
- 55.van den Brand, J., Chen, L., Peng, R., Kyng, R., Liu, Y. P., Gutenberg, M. P., Sachdeva, S., Sidford, A.: A deterministic almost-linear time algorithm for minimum-cost flow. In 64th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2023, Santa Cruz, CA, USA, November 6-9, 2023, pages 503–514. IEEE, (2023)
- 56.Abboud, A., Bringmann, K., Khoury, S., Zamirm, O.: Hardness of approximation in P via short cycle removal: cycle detection, distance oracles, and beyond. In Proceedings of the 54th Annual ACM SIGACT Symposium on Theory of Computing (STOC 2022), pages 1487–1500, (2022)
- 57.Demetrescu, C., Italiano, G.F.: A new approach to dynamic all pairs shortest paths. J. ACM 51(6), 968–992 (2004). (Announced at STOC 2003) [Google Scholar]
- 58.Thorup, M.: Fully-dynamic all-pairs shortest paths: Faster and allowing negative cycles. In: Proceedings of the 9th Scandinavian Workshop on Algorithm Theory (SWAT 2004), pages 384–396, (2004)
- 59.Thorup, M.: Worst-case update times for fully-dynamic all-pairs shortest paths. In Proc. of the 37th Annual ACM Symposium on Theory of Computing (STOC 2005), pages 112–119, (2005)
- 60.Abraham, I., Chechik, S., Krinninger, S.: Fully dynamic all-pairs shortest paths with worst-case update-time revisited. In Proc. of the Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2017), pages 440–452, (2017)
- 61.Gutenberg, M. P., Wulff-Nilsen, C.: Fully-dynamic all-pairs shortest paths: Improved worst-case time and space bounds. In Proc. of the 2020 ACM-SIAM Symposium on Discrete Algorithms, SODA 2020, Salt Lake City, UT, USA, January 5-8, 2020, pages 2562–2574, (2020)
- 62.Chechik, S., Zhang, T.: Faster deterministic worst-case fully dynamic all-pairs shortest paths via decremental hop-restricted shortest paths. In Nikhil Bansal and Viswanath Nagarajan, editors, Proceedings of the 2023 ACM-SIAM Symposium on Discrete Algorithms, SODA 2023, Florence, Italy, January 22-25, 2023, pages 87–99. SIAM, (2023)
- 63.Sankowski, P.: Subquadratic algorithm for dynamic shortest distances. In: COCOON, volume 3595 of Lecture Notes in Computer Science, pages 461–470. Springer, (2005)
- 64.van den Brand, J., Nanongkai, D., Saranurak, T.: Dynamic matrix inverse: Improved algorithms and matching conditional lower bounds. In FOCS, pages 456–480. IEEE Computer Society, (2019)
- 65.Karczmarz, A., Sankowski, P.: Fully dynamic shortest paths and reachability in sparse digraphs. In Kousha Etessami, Uriel Feige, and Gabriele Puppis, editors, 50th International Colloquium on Automata, Languages, and Programming, ICALP 2023, Paderborn, Germany, July 10-14, 2023, volume 261 of LIPIcs, pages 84:1–84:20. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, (2023)
- 66.Henzinger, M., Krinninger, S., Nanongkai, D.: Dynamic approximate all-pairs shortest paths: Breaking the barrier and derandomization. SIAM J. Comput. 45(3), 947–1006 (2016). (Announced at FOCS 2013) [Google Scholar]
- 67.Bernstein, A., Probst, M., Wulff-Nilsen, C.: Decremental strongly-connected components and single-source reachability in near-linear time. In Proc. of the 51st Annual ACM SIGACT Symposium on Theory of Computing (STOC 2019), pages 365–376, (2019)
- 68.van den Brand, J., Nanongkai, D.: Dynamic approximate shortest paths and beyond: Subquadratic and worst-case update time. In FOCS, pages 436–455. IEEE Computer Society, (2019)
- 69.Van Den Brand, J., Forster, S., Nazari, Y.: Fast deterministic fully dynamic distance approximation. In 2022 IEEE 63rd Annual Symposium on Foundations of Computer Science (FOCS), pages 1011–1022, (2022)
- 70.van den Brand, J., Karczmarz, A.: Deterministic fully dynamic SSSP and more. In: 64th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2023, Santa Cruz, CA, USA, November 6-9, 2023, pages 2312–2321. IEEE, (2023)
- 71.Forster, S., Goranci, G., Henzinger, M.: Dynamic maintenance of low-stretch probabilistic tree embeddings with applications. In Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms, (SODA 2021), pages 1226–1245, (2021)
- 72.Baswana, S., Khurana, S., Sarkar, S.: Fully dynamic randomized algorithms for graph spanners. ACM Trans. Algorithms 8(4), 35:1-35:51 (2012) [Google Scholar]
- 73.Kyng, R., Meierhans, S., Gutenberg, M. P.: A dynamic shortest paths toolbox: Low-congestion vertex sparsifiers and their applications. In Bojan Mohar, Igor Shinkar, and Ryan O’Donnell, editors, Proceedings of the 56th Annual ACM Symposium on Theory of Computing, STOC 2024, Vancouver, BC, Canada, June 24-28, 2024, pages 1174–1183. ACM, (2024)
- 74.Even, S., Shiloach, Y.: An on-line edge-deletion problem. J. ACM 28(1), 1–4 (1981) [Google Scholar]
- 75.Henzinger, M. R., King, V.: Fully dynamic biconnectivity and transitive closure. In Proceedings of IEEE 36th Annual Foundations of Computer Science, pages 664–672. IEEE, (1995)
- 76.King, V.: Fully dynamic algorithms for maintaining all-pairs shortest paths and transitive closure in digraphs. In 40th Annual Symposium on Foundations of Computer Science (Cat. No. 99CB37039), pages 81–89. IEEE, (1999)
- 77.Gutenberg, M. P., Wulff-Nilsen, C.: Deterministic algorithms for decremental approximate shortest paths: Faster and simpler. In Shuchi Chawla, editor, Proceedings of the 2020 ACM-SIAM Symposium on Discrete Algorithms, SODA 2020, Salt Lake City, UT, USA, January 5-8, 2020, pages 2522–2541. SIAM, (2020)
- 78.Thorup, M., Zwick, U.: Compact routing schemes. In Arnold L. Rosenberg, editor, Proceedings of the Thirteenth Annual ACM Symposium on Parallel Algorithms and Architectures, SPAA 2001, pages 1–10. ACM, (2001)
- 79.Elkin, M., Neiman, O.: Linear-size hopsets with small hopbound, and constant-hopbound hopsets in RNC. Distrib. Comput. 35(5), 419–437 (2022) [Google Scholar]
- 80.Censor-Hillel, K., Dory, M., Janne, H., Korhonen, D.: Leitersdorf: Fast approximate shortest paths in the congested clique. Distrib. Comput. 34(6), 463–487 (2021) [Google Scholar]
- 81.Dory, M., Parter, M.: Exponentially faster shortest paths in the congested clique. ACM J. ACM (JACM) 69(4), 1–42 (2022) [Google Scholar]
- 82.Backurs, A., Roditty, L., Segal, G., Williams, V.V., Wein, N.: Toward tight approximation bounds for graph diameter and eccentricities. SIAM J. Comput. (SICOMP) 50(4), 1155–1199 (2021) [Google Scholar]
- 83.Abboud, A., Bodwin, G.: The 4/3 additive spanner exponent is tight. J. ACM (JACM) 64(4), 1–20 (2017) [Google Scholar]
- 84.Elkin, M., Peleg, D.: (,)-spanner constructions for general graphs. SIAM J. Comput. 33(3), 608–631 (2004) [Google Scholar]
- 85.Thorup, M., Zwick, U.: Spanners and emulators with sublinear distance errors. In: Proceedings of the seventeenth annual ACM-SIAM symposium on Discrete algorithm, pages 802–809, (2006)
- 86.Abboud, A., Bodwin, G., Pettie, S.: A hierarchy of lower bounds for sublinear additive spanners. SIAM J. Comput. 47(6), 2203–2236 (2018) [Google Scholar]
- 87.Elkin, M., Neiman, O.: Near-additive spanners and near-exact hopsets, a unified view. Bulletin of EATCS 1(130), (2020)
- 88.Łącki, J., Nazari, Y.: Near-Optimal Decremental Hopsets with Applications. In: 49th International Colloquium on Automata, Languages, and Programming (ICALP 2022). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, (2022)
- 89.Chuzhoy, J., Zhang, R.: A new deterministic algorithm for fully dynamic all-pairs shortest paths. In Proceedings of the 55th ACM Annual Symposium on Theory of Computing (STOC 2023), (2023)
- 90.Klein, P.N., Subramanian, S.: A randomized parallel algorithm for single-source shortest paths. J. Algorithms 25(2), 205–220 (1997) [Google Scholar]
Associated Data
This section collects any data citations, data availability statements, or supplementary materials included in this article.
Data Availability Statement
No datasets were generated or analysed during the current study.
