Reliable Hubs for Partially-Dynamic All-Pairs Shortest Paths in Directed Graphs

TL;DR

This paper introduces new deterministic and randomized algorithms for efficiently maintaining approximate all-pairs shortest paths in directed graphs under dynamic updates, significantly improving update times and reliability.

Contribution

It presents the first deterministic incremental algorithm with subquadratic update time for all-pairs shortest paths in directed graphs and enhances randomized algorithms to Las Vegas guarantees.

Findings

Deterministic incremental algorithm with $ ilde{O}(mn^{4/3} ext{polylog}(W)/ extepsilon)$ total update time.

Conversion of existing randomized algorithms from Monte Carlo to Las Vegas without increased running time.

New algorithms for dynamically maintaining hubs that hit shortest paths with certain hop-lengths.

Abstract

We give new partially-dynamic algorithms for the all-pairs shortest paths problem in weighted directed graphs. Most importantly, we give a new deterministic incremental algorithm for the problem that handles updates in $\widetilde{O}(mn^{4/3}\log{W}/\epsilon)$ total time (where the edge weights are from $[1,W]$) and explicitly maintains a $(1+\epsilon)$-approximate distance matrix. For a fixed $\epsilon>0$, this is the first deterministic partially dynamic algorithm for all-pairs shortest paths in directed graphs, whose update time is $o(n^2)$ regardless of the number of edges. Furthermore, we also show how to improve the state-of-the-art partially dynamic randomized algorithms for all-pairs shortest paths [Baswana et al. STOC'02, Bernstein STOC'13] from Monte Carlo randomized to Las Vegas randomized without increasing the running time bounds (with respect to the $\widetilde{O}(\cdot)$ notation). Our results are obtained by giving new algorithms for the problem of dynamically maintaining hubs, that is a set of $\widetilde{O}(n/d)$ vertices which hit a shortest path between each pair of vertices, provided it has hop-length $\Omega(d)$. We give new subquadratic deterministic and Las Vegas algorithms for maintenance of hubs under either edge insertions or deletions.

Equations

$$w_{G^{\prime }}(uv)={\mathrm{expround}}_{(1+{ϵ}^{\prime })}{w}_G(uv)$$

$${\delta }_G(s,v)\le {\delta }^{\prime }(s,v)\le (1+ϵ){\delta }_G^h(s,v)$$

$$D=\max\mathopen{}\mathclose{{}\left\{d_{x}+\ldots+d_{z}:1\leq x\leq z\leq l\text{ and }V(P_{y})\cap B=\emptyset\text{ for all }y\in(x,z)}\right\}.$$

$$D=\max\mathopen{}\mathclose{{}\left(d_{1}+\ldots+d_{z_{1}},d_{z_{1}}+\ldots+d_{z_{2}},\ldots,d_{z_{r}}+\ldots+d_{z_{r+1}}}\right).$$

$$P_i^{\prime }=(P_{z_i,2})\dots (P_{z_i,k_{z_i}}{P}_{z_i+1,1}{P}_{z_i+2,1}\dots P_{z_{i+1},1})$$

$${\delta }_{G^{\mathrm{R}}\cup S_u}^{d+1}(u,v)$$

$$=w_{S_u}(e)+\ell (P_k)$$

$$\le (1+{ϵ}_1)\ell (P_1\dots P_{k-1})+\ell (P_k)$$

$$\le (1+{ϵ}_1)\ell (P)$$

$$=(1+{ϵ}_1){\delta }_{G^{\mathrm{R}}}(u,v).\text{qed}$$

$$O\mathopen{}\mathclose{{}\left(\sum_{i=1}^{q}a_{i-1}\cdot m\cdot d_{i-1}}\right)=O\mathopen{}\mathclose{{}\left(\sum_{i=1}^{q}a_{i-1}\cdot m\cdot\frac{n}{a_{i}}\ln{n}}\right)=O\mathopen{}\mathclose{{}\left(nm\log{n}\cdot\sum_{i=1}^{q}\frac{a_{i-1}}{a_{i}}}\right)=O(nm\log^{2}{n}).$$

$${\delta }^{\prime }(s,v)={\delta }_{T_{k_v}}(s,p)+w_{T_{k_v}}(p,v)\ge {\delta }^{\prime }(s,p)+w_T(p,v)\ge {\delta }_T(s,p)+w_T(p,v)={\delta }_T(s,v).$$

$$\ell (T_{u_i}^{\mathrm{from}}[v_i])={\delta }_{T_{u_i}^{\mathrm{from}}}(u_i,v_i)\le (1+ϵ){\delta }_G^{3d}(u_i,v_i)\le (1+ϵ)\ell (P_i),$$

$$\ell (T_{v_1}^{\mathrm{to}}[u_1])={\delta }_{T_{v_1}^{\mathrm{to}}}(v_1,u_1)\le (1+ϵ){\delta }_G^{3d}(u_1,v_1)\le (1+ϵ)\ell (P_1).$$

$$D=\max\mathopen{}\mathclose{{}\left\{d_{x}+\ldots+d_{z}:1\leq x\leq z\leq r\text{ and }V(Q_{y}^{\prime\prime})\cap B=\emptyset\text{ for all }y\in(x,z)}\right\}.$$

$$\ell (P^{\prime })$$

$$\le (1+ϵ{)}^{j-1}\sum _{i=1}^r\ell (Q_i^{\prime })$$

$$=(1+ϵ{)}^{j-1}\sum _{i=1}^s\ell (Q_i)$$

$$\le (1+ϵ{)}^{j-1}\sum _{i=1}^s(1+ϵ)\ell (P_i)$$

$$=(1+ϵ{)}^j\ell (P).\text{qed}$$

$${\delta }_G(v,w)\le {\delta }_{i,v}^{\prime }(w)\le (1+{ϵ}_1{)}^{i-1}{\delta }_G^{2^i}(v,w).$$

$$O\mathopen{}\mathclose{{}\left(\sum_{v\in V}\Delta+\sum_{i=1}^{k}\sum_{v\in V}n^{2}\log{n}\log{(nW)}/\epsilon_{1}+\sum_{i=2}^{k}\sum_{v\in V}\sum_{w\in V}\Delta_{i-1,w}}\right)=O(n^{3}\log^{3}{n}\log{(nW)}/\epsilon).$$

$$\delta^{\prime}_{i}(u,v)=\min_{a\in A_{i}}\mathopen{}\mathclose{{}\left\{\delta_{T^{\mathrm{to}}_{i,a}}(a,u)+\delta_{T^{\mathrm{from}}_{i,v}}(a,v)}\right\}.$$

$$O\mathopen{}\mathclose{{}\left(\sum_{i=1}^{q}|A_{i}|\cdot n\cdot d_{i}\cdot n}\right)=O\mathopen{}\mathclose{{}\left(\sum_{i=1}^{q}n^{3}\log{n}}\right)=O(n^{3}\log^{2}{n}).$$

$$O\mathopen{}\mathclose{{}\left(\sum_{i=1}^{q}|A_{i}|\cdot md_{i}}\right)=O\mathopen{}\mathclose{{}\left(\sum_{i=1}^{q}mn\log{n}}\right)=O(mn\log^{2}{n})=O(n^{3}\log^{2}{n}).$$

$${\delta }_G(u,v)\le {\delta }_i^{\prime }(u,v)\le (1+{ϵ}^{\prime }{)}^{q-i+1}{\delta }_G(u,v).$$

$$O\mathopen{}\mathclose{{}\left(m\mathopen{}\mathclose{{}\left(\frac{n}{d}}\right)^{2}\log^{5}{n}\log(nW)/\epsilon^{\prime}+mnd\log^{2}{n}\log(nW)/\epsilon^{\prime}}\right)=O\mathopen{}\mathclose{{}\left(mn\mathopen{}\mathclose{{}\left(\frac{n}{d^{2}}\log^{3}{n}+d}\right)\log^{3}{n}\log(nW)/\epsilon}\right).$$

$$\displaystyle O\mathopen{}\mathclose{{}\left(\sum_{i=1}^{q}a_{i-1}\cdot md_{i-1}\log^{2}{n}\log{(nW)}/\epsilon^{\prime}}\right)$$

$$=O(nm{\log }^{5}n\log (nW)/{ϵ}^{\prime })$$

$$\displaystyle O\mathopen{}\mathclose{{}\left(\sum_{i=0}^{q-1}a_{i}\cdot d_{i+1}m\log{n}\log{(nW)}/\epsilon^{\prime}}\right)$$

$$=O(nm{\log }^{5}n\log (nW)/{ϵ}^{\prime })$$

Full text

Our results are obtained by giving new algorithms for the problem of dynamically maintaining hubs, that is a set of $\widetilde{O}(n/d)$ vertices which hit a shortest path between each pair of vertices, provided it has hop-length $\Omega(d)$. We give new subquadratic deterministic and Las Vegas algorithms for maintenance of hubs under either edge insertions or deletions.

1 Introduction

The sampling scheme of Ullman and Yannakakis [27] is a fundamental tool in designing dynamic algorithms for maintaining shortest path distances. Roughly speaking, the main idea is that if each vertex of the graph is sampled independently with probability $\Omega(\frac{d\ln n}{n})$, then with high probability111We say that a probabilistic statement holds with high (low) probability. abbreviated w.h.p., if it holds with probability at least $1-n^{-\beta}$ (at most $n^{-\beta}$, resp.), where $\beta$ is a constant that can be fixed arbitrarily. the set of the sampled vertices has the following property. If the shortest path between some vertices $u$ and $v$ contains more than $d$ edges, then this shortest path contains a sampled vertex222For simplicity, in the introduction we assume that the shortest paths are unique.. We call each set having this property a set of hubs333Zwick [29] uses the name bridging set for an analogous concept. Some works also use the term hitting set, but hitting set is a more general notion, which in our paper is used in multiple different contexts. of that graph.

The fact that one can easily obtain a set of hubs by random sampling is particularly useful for dynamic graph algorithms, since, by tuning constants in the sampling probability, one can assure that the set of hubs remains valid at each step (with high probability), while the graph is undergoing edge insertions and deletions, assuming the total number of updates is polynomial. This property has been successfully exploited to give a number of dynamic graph algorithms, e.g. [2, 4, 5, 9, 11, 12, 13, 20, 21, 22]. At the same time, the sampling approach also suffers from two drawbacks. First, it yields Monte Carlo algorithms, which with some nonzero probability can return incorrect answers. Second, it relies on the oblivious adversary assumption, that is, it requires that the updates to the graph are independent of the randomness used for sampling hubs. This becomes a substantial issue for problems where the answer to a query is not unique, e.g., for maintaining $(1+\epsilon)$-approximate distances or maintaining the shortest paths themselves (i.e. not just their lengths). In a typical case, the choice of the specific answer to a query depends on the randomness used for vertex sampling, which in turn means that in each answer to a query the data structure is revealing its randomness. Hence, if the following updates to the data structure depend on the specific values returned by the previous queries, the oblivious adversary assumption is not met.

In this paper we attempt to address both these issues. We study the dynamic maintenance of reliable hubs, that is we show how to maintain hubs using an algorithm that does not err, even with small probability. In addition, in the incremental setting we give an algorithm that maintains hubs deterministically. While the algorithms are relatively straightforward for unweighted graphs, making them also work in the weighted setting is a major challenge, which we manage to overcome. We then show how to take advantage of our results on reliable hubs to obtain improved algorithms for the problem of maintaining all-pairs shortest paths in directed graphs. In particular, we give a faster deterministic incremental algorithm and show how to improve the state-of-the-art decremental algorithms from Monte Carlo to Las Vegas.

1.1 Our Contribution

We study the problem of maintaining reliable hub sets in the partially dynamic setting. For the description, let us first assume the case when the graph is unweighted. Our first observation is that one can deterministically maintain the set of hubs $H_{d}$ under edge insertions in $\widetilde{O}(nmd)$ total time. To that end, we observe that after an edge $uw$ is inserted, we may ensure the set of hubs $H_{d}$ is valid by extending it with both $u$ and $w$. This increases the size of $H_{d}$, and hence we have to periodically discard all the hubs and recompute them from scratch.

The deterministic computation of hubs has been studied before. For unweighted digraphs, King [19] showed how to compute a hub set $H_{d}$ of size \widetilde{O}\mathopen{}\mathclose{{}\left(\frac{n}{d}}\right) in $\tilde{O}(n^{2})$ time. The algorithm, given shortest path trees up to depth $d$ from all vertices $v\in V$, computes a blocker-set [19] of these trees. (A blocker-set $S$ of a rooted tree is a set such that, for each path from the root to a leaf of length $d$, that path contains a vertex of $S$ distinct from the root.) Hence, if we work on unweighted graphs, in order to keep the set $H_{d}$ valid and relatively small, we can maintain shortest path trees up to depth $d$ from all vertices using the Even-Shiloach algorithm [10] in $O(nmd)$ total time, and recompute $H_{d}$ using King‘s algorithm every $\widetilde{O}(\frac{n}{d})$ insertions. The total time needed for maintaining the hubs is therefore $\widetilde{O}(nmd)$.

Furthermore, we also show how to maintain reliable hubs in a decremental setting. Suppose our goal is to compute a set of hubs that is guaranteed to be valid, which clearly is not the case for the sampled hubs of [27]. We show that if shortest path trees up to depth $d$ are maintained using dynamic tree data structures [24, 25], one can recompute a certainly-valid set $H_{d}$ in \widetilde{O}\mathopen{}\mathclose{{}\left(\frac{n^{2}}{d}}\right) time using a Las Vegas algorithm. To this end observe that one can deterministically verify if a set $B\subseteq V$ is a blocker-set of $n$ shortest path trees up to depth $d$ in $\widetilde{O}(n\cdot|B|)$ time. Therefore, a hub set $H_{d}$ can be found by combining the approaches of [27] and [19]: we may sample candidate hub sets of size $\widetilde{O}(\frac{n}{d})$ until a blocker-set of the trees is found. The number of trials is clearly constant with high probability.

We further extend this idea and show that the information whether $B$ is a blocker-set of a collection of $n$ shortest path trees up to depth $d$ can be maintained subject to the changes to these trees with only polylogarithmic overhead. Consequently, we can detect when the sampled hub set $H_{d}$ (for any $d$) ceases to be a valid hub set in $\widetilde{O}(nmd)$ total time. The algorithm may make one-sided error (i.e., say that $H_{d}$ is no longer a valid hub set when it is actually still good), but the probability of an error is low if we assume that the update sequence does not depend on our random bits. Subsequently we show how to extend this idea to improve the total update time to $\widetilde{O}(nm)$. Assume we are given a valid $d$-hub set $H_{d}$. We prove that in order to verify whether $H_{6d}$ is a valid $6d$-hub set, it suffices to check whether it hits sufficiently long paths between the elements of $H_{d}$. We use this observation to maintain a family of reliable hub sets $H_{1},H_{6},\ldots,H_{6^{i}},\ldots,H_{6^{k}}$ (where $6^{k}\leq n$) under edge deletions (or under edge insertions) in $\widetilde{O}(nm)$ total time. Using that, we immediately improve the state-of-the-art decremental APSP algorithms of Baswana et al. [4] (for the exact unweighted case) and Bernstein [5] (for the $(1+\epsilon)$-approximate case) from Monte Carlo to Las Vegas (but still assuming an oblivious adversary) by only adding a polylogarithmic factor to the total update time bound.

Generalization to weighted digraphs.

Adapting the reliable hub sets maintenance (for both described approaches: the incremental one and sample/verify) to weighted digraphs turns out to be far from trivial. This is much different from the sampling approach of Ullman and Yannakakis [27], which works regardless of whether the input graph is weighted or not. The primary difficulty is maintaining all shortest paths consisting of up to $d$ edges. While in the unweighted case the length of a path is equal to the number of edges on this path, this is no longer true in the weighted case.

To bypass this problem we first relax our definition of hubs. For each $u,v\in V$ we require that some $(1+\epsilon)$-approximate shortest $u\to v$ path contains a hub on each subpath consisting of at least $d+1$ edges. Next, we show that running King‘s blocker-set algorithm on a set of $(1+\epsilon)$-approximate shortest path trees up to depth444In such a tree (see Definition 5.1), which is a subgraph of $G$, for all $v\in V$, the path from the source $s$ to $v$ has length not exceeding $(1+\epsilon)$ times the length of a shortest out of $s\to v$ paths in $G$ that use no more than $d$ edges; however the tree path itself can have arbitrary number of edges. $d$ from all vertices of the graph yields a hub set that hits paths approximating the true shortest paths within a factor of $(1+\epsilon)^{\Theta(\log{n})}$. Note that a collection of such trees can be maintained in $\widetilde{O}(nmd\log{W}/\epsilon)$ total time subject to edge insertions, using Bernstein‘s $h$-SSSP algorithm [5] with $h=d$.

The $\Theta(\log n)$ exponent in the approximation ratio comes from the following difference between the weighted and unweighted case. In a $(1+\epsilon)$-approximate shortest path tree up to depth $d$, the length of a $u\to v$ path is no more than $(1+\epsilon)$-times the length of the shortest $u\to v$ path in $G$ that uses at most $d$ edges. However, the $u\to v$ path in the tree might consist of any number of edges, in particular very few. Pessimistically, all these trees have depth $o(d)$ and their blocker-set is empty, as there is no path of hop-length $\Omega(d)$ that we need to hit. Note that this is an inherent problem, as the fact that we can find a small blocker-set in the unweighted case relies on the property that we want it to hit paths of $\Omega(d)$ edges.

Luckily, a deeper analysis shows that our algorithm can still approximate the length of a $s\to v$ path. Roughly speaking, we split the $s\to v$ path $P$ into two subpaths of $d/2$ edges. If each of these two subpaths are approximated in the $h$-SSSP data structures by paths of less than $d/4$ edges, we replace the $P$ by the concatenation of the two approximate paths from the $h$-SSSP data structures. This way, we get a path that can be longer by a factor of $(1+\epsilon)$, but whose hop-length is twice smaller. By repeating this process $O(\log n)$ times we obtain a path of constant hop-length whose length is at most $(1+\epsilon)^{\Theta(\log n)}$ larger than the length of $P$. The overall approximation ratio is reduced to $(1+\epsilon)$ by scaling $\epsilon$ by a factor of $\Theta(\log n)$.

Deterministic incremental all-pairs shortest paths.

We now show how to apply our results on reliable hubs to obtain an improved algorithm for incremental all-pairs shortest paths problem in weighted digraphs. We give a deterministic incremental algorithm maintaining all-pairs $(1+\epsilon)$-approximate distance estimates in $\widetilde{O}(mn^{4/3}\log{W}/\epsilon)$ total time.

Let us now give a brief overview of our algorithm in the unweighted case. First, we maintain the set of hubs $H_{d}$ under edge insertions as described above in $\widetilde{O}(nmd)$ total time. Second, since the set $H_{d}$ changes and each vertex of the graph may eventually end up in $H_{d}$, we cannot afford maintaining shortest path trees from all the hubs (which is done in most algorithms that use hubs). Instead, we use the folklore $\widetilde{O}(n^{3}/\epsilon)$ total time incremental $(1+\epsilon)$-approximate APSP algorithm [5, 19] to compute distances between the hubs. Specifically, we run it on a graph whose vertex set is $H_{d}$ and whose edges represent shortest paths between hubs of hop-lengths at most $d$. These shortest paths are taken from the shortest path trees up to depth $d$ from all $v\in V$ that are required for the hub set maintenance. We reinitialize the algorithm each time the set $H_{d}$ is recomputed. This allows us to maintain approximate pairwise distances between the hubs at all times in \widetilde{O}\mathopen{}\mathclose{{}\left(m\mathopen{}\mathclose{{}\left(n/d}\right)^{2}/\epsilon}\right) total time.

Finally, we show how to run a dynamic algorithm on top of a changing set of hubs by adapting the shortcut edges technique of Bernstein [5]. Roughly speaking, the final estimates are maintained using $(1+\epsilon)$-approximate shortest path trees [5] up to depth $O(d)$ from all vertices $v$ on graph $G$ augmented with shortcuts from $v$ to $H_{d}$ and from $H_{d}$ to $v$. This poses some technical difficulties as the set of shortcuts is undergoing both insertions (when a hub is added) and deletions (when the entire set of hubs is recomputed from scratch). However, one can note that in the incremental setting the shortcuts that no longer approximate the distances between their endpoints do not break the approximation guarantee of our algorithm. Eventually, we use shortcuts between all pairs of vertices of $G$ but only some of them are guaranteed (and sufficient) to be up to date at any time. The total time cost of maintaining this component is $\widetilde{O}(nmd/\epsilon)$. Setting $d=\widetilde{O}(n^{1/3})$ gives the best update time.

It is natural to wonder if this approach could be made to work in the decremental setting. There are two major obstacles. First, it is unclear whether one can deterministically maintain a valid set of hubs under deletions so that only $O(1)$ vertices (in amortized sense) are added to the hub set after each edge deletion. Note that in extreme cases, after a single edge deletion the set of hubs may have to be extended with polynomially many new vertices. Second, all algorithms using the above approach of introducing shortcuts from and to hubs also maintain a decremental shortest path data structure on a graph consisting of the edges of the original graph and shortcut edges representing distances between the hubs. If hubs were to be added, the graph maintained by the data structure would undergo both insertions (of shortcuts) and deletions (of edges of the original graph) which would make this a much harder, fully dynamic problem. Some earlier works dealt with a similar issue by ignoring some ’’inconvenient” edge insertions [14] or showing that the insertions are well-behaved [6]. However, these approaches crucially depended on the graph being undirected.

1.2 Related Work

The dynamic graph problems on digraphs are considerably harder than their counterparts on undirected graphs. An extreme example is the dynamic reachability problem, that is, transitive closure on directed graphs, and connectivity on undirected graphs. While there exist algorithms for undirected graphs with polylogarithmic query and update times [17, 28, 26, 16, 18], in the case of directed graphs the best known algorithm with polylogarithmic query time has an update time of $O(n^{2})$ [23, 7, 20]. In addition, a combinatorial algorithm with an update time of $O(n^{2-\epsilon})$ is ruled out under Boolean matrix multiplication conjecture [1].

In 2003, in a breakthrough result Demetrescu and Italiano gave a fully dynamic, exact and deterministic algorithm for APSP in weighted directed graphs [8]. The algorithm handles updates in $\widetilde{O}(n^{2})$ amortized time and maintains the distance matrix explicitly. The bound of $O(n^{2})$ is a natural barrier as a single edge insertion or deletion may change up to $\Omega(n^{2})$ entries in the distance matrix. For dynamic APSP in digraphs there exists faster algorithms with polylogarithmic query time, all of which work in incremental or decremental setting:

• •

Ausiello et al. [3] gave a deterministic incremental algorithm for exact distances in unweighted digraphs that handles updates in $\widetilde{O}(n^{3})$ total time.

• •

Baswana et al. [4] solved the same problem in the decremental setting with a Monte Carlo algorithm with $\widetilde{O}(n^{3})$ total update time.

• •

Bernstein [5] gave a Monte Carlo algorithm for $(1+\epsilon)$-approximate distances in weighted graphs (with weights in $[1,W]$) with $\widetilde{O}(nm\log{W}/\epsilon)$ total update time. The algorithm works both in the incremental and decremental setting.

• •

Finally, deterministic partially-dynamic (both incremental and decremental) algorithms for APSP in directed graphs with $\widetilde{O}(n^{3}\log{W}/\epsilon)$ total update time can be obtained by combining the results of [19] and [5].

The algorithms of Baswana et al.  [4] and Bernstein [5] both use sampled hubs and thus require the oblivious adversary assumption. We highlight that in the class of deterministic algorithms, the best known results have total update time $\widetilde{O}(n^{3})$ [3, 5], even if we only consider sparse unweighted graphs in incremental or decremental setting and allow $(1+\epsilon)$ approximation. In the incremental setting, for not very dense graphs, when $m=O(n^{5/3-\epsilon})$, our algorithm improves this bound to $\widetilde{O}(mn^{4/3})$.

Organization of the paper.

In Section 2 we fix notation, review some of the existing tools that we use and give a formal definition of hubs. Section 3 describes the hub set maintenance for incremental unweighted digraphs and our $(1+\epsilon)$-approximate incremental algorithm for sparse graphs. In Section 4 we show a faster Las Vegas algorithm for computing reliable hubs and further extend it to maintain reliable hub sets in the partially dynamic setting. There we also sketch how to use it in order to to improve the state-of-the-art decremental APSP algorithms from Monte Carlo to Las Vegas randomized. Finally, in Section 5 we show how to adapt the hub set maintenance algorithms of Sections 3 and 4, so that they work on weighted graphs.

2 Preliminaries

In this paper we deal with directed graphs. We write $V(G)$ and $E(G)$ to denote the sets of vertices and edges of $G$, respectively. A graph $H$ is a subgraph of $G$, which we denote by $H\subseteq G$, if and only if $V(H)\subseteq V(G)$ and $E(H)\subseteq E(G)$. We write $uv\in E(G)$ when referring to edges of $G$ and use $w_{G}(uv)$ to denote the weight of $uv$. If $G=(V,E)$ is unweighted, then $w_{G}(e)=1$ for each $e\in E$. For weighted graphs, $w_{G}(e)$ can be any real number from the interval $[1,W]$. For simplicity, in this paper we assume that $W$ is an input parameter given beforehand. If $uv\notin E$, we assume $w_{G}(uv)=\infty$. We define the union $G\cup H$ to be the graph $(V(G)\cup V(H),E(G)\cup E(H))$ with weights $w_{G\cup H}(uv)=\min(w_{G}(uv),w_{H}(uv))$ for each $uv\in E(G\cup H)$. For an edge $e=uv$, we write $G+e$ to denote $(V(G)\cup\{u,v\},E(G)\cup\{e\})$. The reverse graph $G^{\mathrm{R}}$ is defined as $(V(G),\{xy:yx\in E(G)\})$ and $w_{G^{\mathrm{R}}}(xy)=w_{G}(yx)$.

A sequence of edges $P=e_{1}\ldots e_{k}$, where $k\geq 1$ and $e_{i}=u_{i}v_{i}\in E(G)$, is called a $u\to v$ path in $G$ if $u=u_{1}$, $v_{k}=v$ and $v_{i-1}=u_{i}$ for each $i=2,\ldots,k$. We sometimes view a path $P$ in $G$ as a subgraph of $G$ with vertices $\{u_{1},\ldots,u_{k},v\}$ and edges $\{e_{1},\ldots,e_{k}\}$ and write $P\subseteq G$. The hop-length $|P|$ is defined as $|P|=k$. The length of the path $\ell(P)$ is defined as $\ell(P)=\sum_{i=1}^{k}w_{G}(e_{i})$. If $G$ is unweighted, then we clearly have $|P|=\ell(P)$. For convenience, we sometimes consider a single edge $uv$ a path of hop-length $1$. It is also useful to define a length-[math] $u\to u$ path to be the graph $(\{u\},\emptyset)$. If $P_{1}$ is a $u\to v$ path and $P_{2}$ is a $v\to w$ path, we denote by $P_{1}\cdot P_{2}$ (or simply $P_{1}P_{2}$) a path $P_{1}\cup P_{2}$ obtained by concatenating $P_{1}$ with $P_{2}$.

A digraph $T$ is called an out-tree over $V$ rooted in $r$ if $v\in V(T)\subseteq V$, $|E(T)|=|V(T)|-1$ and for all $v\in V(T)$ there is a unique path ${T}[{v}]$ from $r$ to $v$. The depth $\mathrm{dep}_{T}({v})$ of a vertex $v\in V(T)$ is defined as $|{T}[{v}]|$. The depth of $T$ is defined as $\max_{v\in V(T)}\{\mathrm{dep}_{T}({v})\}$. Each non-root vertex of an out-tree has exactly one incoming edge. For $v\in V(T)\setminus\{r\}$ we call the other endpoint of the incoming edge of $v$ the parent $v$ and write $\mathrm{par}_{T}(v)$ when referring to it.

The distance $\delta_{G}(u,v)$ between the vertices $u,v\in V(G)$ is the length of the shortest $u\to v$ path in $G$, or $\infty$, if no $u\to v$ path exists in $G$. We define $\delta^{k}_{G}(u,v)$ to be the length of the shortest path from $u$ to $v$ among paths of at most $k$ edges. Formally, $\delta^{k}_{G}(u,v)=\min\{\ell(P):u\to v=P\subseteq G\text{ and }|P|\leq k\}$. We sometimes omit the subscript $G$ and write $w(uv)$, $\delta(u,v)$, $\delta^{k}(u,v)$ etc. instead of $w_{G}(u,v)$, $\delta_{G}(u,v)$, $\delta^{k}_{G}(u,v)$, etc., respectively.

We say that a graph $G$ is incremental, if it only undergoes edge insertions and edge weight decreases. Similarly, we say that $G$ is decremental if it undergoes only edge deletions and edge weight increases. We say that $G$ is partially dynamic if it is either incremental or decremental. For a dynamic graph $G$ we denote by $n$ the maximum value of $|V|$ and by $m$ the maximum value of $|E|$ throughout the whole sequence of updates.

When analyzing $(1+\epsilon)$-approximate algorithms, we assume $0<\epsilon<1$ and $1/\epsilon=\operatorname{poly}{n}$.555If this was not the case, we had better use exact fully-dynamic APSP algorithm [8] instead.

We denote by $\Delta$ the total number of updates a dynamic graph $G$ is subject to. If $G$ is unweighted, then clearly $\Delta\leq m$ and in fact we assume $\Delta=m$, which allows us to simplify the analyses. For weighted digraphs, on the other hand, since the total number of weight increases/decreases that an edge is subject to is unlimited, $\Delta$ may be much larger than $m$. As a result, it has to be taken into account when analyzing the efficiency of our algorithms.

We call a partially-dynamic $(1+\epsilon)$-approximate APSP problem on weighted graphs restricted if the edge weights of $G$ are of the form $(1+\epsilon)^{i}$ for $i\in[0,\lceil\log_{1+\epsilon}{W}\rceil]\cap\mathbb{N}$ at all times and additionally each update is required to actually change the edge set or change the weight of some existing edge. Consequently, observe that in the restricted problem we have $\Delta\leq m\cdot(\lceil\log_{1+\epsilon}{W}\rceil+2)$. In the following we concentrate on the restricted problem. This is without much loss of generality as proved below.

Lemma 2.1**.**

Let $\mathcal{A}$ be an algorithm solving the restricted $(1+\epsilon)$-approximate all-pairs shortest paths problem on a weighted digraph in $O(T(n,m,W,\epsilon,\Delta))$ total time, where $T(n,m,W,\epsilon,\Delta)=\operatorname{poly}{(n,m,W,\epsilon,\Delta)}$. Then, there exists an algorithm solving the corresponding general problem (i.e., with arbitrary real edge-weights from the range $[1,W]$) in $O(T(n,m,W,\epsilon,m\log{W}/\epsilon)+\Delta)$ total time.

Proof.

Let $\epsilon^{\prime}=\epsilon/4$. Let $G^{\prime}$ have the same vertices and edges as $G$ and let

[TABLE]

for each $uv\in E$, where $\mathrm{expround}_{a}(x):=x^{\lceil\log_{a}x\rceil}$. Note that for any $u,v\in V$, $\delta_{G^{\prime}}(u,v)\leq(1+\epsilon^{\prime})\delta_{G}(u,v)$.

Let us run an instance $A$ of the $(1+\epsilon^{\prime})$-approximate algorithm $\mathcal{A}$ on $G^{\prime}$. $A$ yields $(1+\epsilon^{\prime})^{2}\leq(1+\epsilon)$-approximate distances in $G$. However, not all updates to $G$ are passed to $A$. if $w_{G^{\prime}}(uv)$ does not change as a result of an update to $w_{G}(uv)$, it can be ignored from the point of view of $A$ in $O(1)$ time. On the other hand, if a change to $w_{G}(uv)$ makes $w_{G^{\prime}}(uv)$ change, such an update is passed to $A$. However, for each edge $uv\in E$ this can clearly happen at most $O(\log_{1+\epsilon^{\prime}}{W})=O(\log{W}/\epsilon^{\prime})=O(\log{W}/\epsilon)$ times.

Hence, the total update time is indeed $O(T(n,m,W,\epsilon,m\log{W}/\epsilon)+\Delta)$. ∎

2.1 Partially-Dynamic Single-Source Shortest Path Trees

Definition 2.2**.**

Let $G=(V,E)$ be an unweighted digraph and let $s\in V$. Let $d>0$ be an integer. We call an out-tree $T\subseteq G$ rooted in $s$ a shortest path tree from $s$ up to depth $d$ if:

for any $v\in V$, $v\in V(T)$ iff $\delta_{G}(s,v)\leq d$, and 2. 2.

for any $v\in V(T)$, $\delta_{T}(s,v)=\delta_{G}(s,v)$.

Theorem 2.3** (Even-Shiloach tree [10, 15]).**

Let $G=(V,E)$ be an unweighted graph subject to partially dynamic edge updates. Let $s\in V$ and let $d\geq 1$ be an integer. Then, a shortest path tree from $s$ up to depth $d$ can be explicitly maintained666By this we mean that the algorithm outputs all changes to the edge set of the maintained tree. in $O(md)$ total time.

Theorem 2.4** ($h$-SSSP [5]).**

Let $G=(V,E)$ be a weighted digraph. Let $s\in V$ and let $h\geq 1$ be an integer. There exists a partially dynamic algorithm explicitly maintaining $(1+\epsilon)$-approximate distance estimates $\delta^{\prime}(s,v)$ satisfying

[TABLE]

for all $v\in V$. The total update time of the algorithm $O(mh\log{n}\log(nW)/\epsilon+\Delta)$.

2.2 Hubs and How to Compute Them

We now define a blocker set, slightly modifying a definition by King [19].

Definition 2.5**.**

Let $V$ be a vertex set and let $d$ be a positive integer. Let $B\subseteq V$ and let $T$ be a rooted tree over $V$ of depth no more than $d$. We call $B$ a $(T,d)$-blocker set if for each $v\in V(T)$ such that $\mathrm{dep}_{T}({v})=d$, either $v$ or one of its ancestors in $T$ belongs to $B$.

Equivalently, $B$ is a $(T,d)$-blocker set if the tree $T^{\prime}$ obtained from $T$ by removing all subtrees rooted in vertices of $B$ (possibly the entire $T$, if the root is in $B$) has depth less than $d$.

Let $\mathcal{T}$ be a collection of rooted trees over $V$ of depth no more than $d$. We call $B$ a $(\mathcal{T},d)$-blocker set if $B$ is a $(T,d)$-blocker set for each $T\in\mathcal{T}$.

Lemma 2.6** ([19]).**

Let $V$ be a vertex set of size $n$. Let $d$ be a positive integer. Let $\mathcal{T}$ be a collection of rooted trees over $V$ of depth at most $d$. Then, a $(\mathcal{T},d)$-blocker set of size O\mathopen{}\mathclose{{}\left(\frac{n}{d}\log{n}}\right) can be computed deterministically in $O(n\cdot(|\mathcal{T}|+n)\log{n})$ time.

Proof.

For each vertex $v\in V$, we maintain a score, defined as the sum, over all trees of $T\in\mathcal{T}$ that $v$ participates in, of the number of descendants $w$ of $v$ such that $\mathrm{dep}_{T}({w})=d$. Clearly, the scores can be initialized in $O(|\mathcal{T}|\cdot n)$ time.

The set $B$ is constructed greedily by repeatedly picking a vertex $v$ with maximum score, removing from each $T\in\mathcal{T}$ the subtree rooted at $v$ (including $v$), and updating the scores accordingly. To update the scores one needs to iterate through all vertices of the removed subtree, as well as all $O(d)$ ancestors of $v$ in $T$. Thus, the time to spent on picking maximum-scoring vertices and updating the scores can be bounded by $O(|B|\cdot(n+|\mathcal{T}|\cdot d)+|\mathcal{T}|\cdot n)$.

As the maximum-scoring vertex participates in at least $\frac{d}{n}$-fraction of the remaining $d$-edge root-leaf paths at each step, $O(\frac{n}{d}\log{n})$ vertices will end up being picked. Hence, the total running time is $O(n\cdot(|\mathcal{T}|+n)\log{n})$. ∎

Definition 2.7**.**

Let $G=(V,E)$ be a directed graph. Let $B\subseteq V$ and let $d>0$ be an integer. We say that a path $P$ in $G$ is $(B,d)$-covered if it can be expressed as $P=P_{1}\ldots P_{k}$, where $P_{i}=u_{i}\to v_{i}$, $|P_{i}|\leq d$ for each $i=1,\ldots,k$, and $u_{i}\in B$ for each $i=2,\ldots,k$.

Lemma 2.8**.**

Let $G=(V,E)$ be a digraph and let $B\subseteq V$. Let $P=P_{1}\ldots P_{l}$ be a $u\to v$ path and suppose that for any $i$, $P_{i}$ is $(B,d_{i})$-covered. Then, $P$ is $(B,D)$-covered, where

[TABLE]

Proof.

Since $P_{i}$ is $(B,d_{i})$-covered, it can be expressed as $P_{i}=P_{i,1}\ldots P_{i,k_{i}}$, where for each $j\in[1,k_{i}]$, $|P_{i,j}|\leq d_{i}$, no vertices of $P_{i,j}$ other than its endpoints belong to $B$, and for each $j\in[2,k_{i}]$, $P_{i,j}$ starts in a vertex of $B$. Hence, if $V(P_{i})\cap B=\emptyset$, then $k_{i}=1$.

Let $z_{1},\ldots,z_{r}$ be those indices $i$ for which $V(P_{i})\cap B\neq\emptyset$ holds, in ascending order. Assume that $k_{z_{i}}\geq 2$ (if $k_{z_{i}}=1$, we can set $P_{z_{i},2}=v_{z_{i}}\to v_{z_{i}}$ to be a path of length [math]). Set $P_{l+1,1}$ to be a [math]-edge $v\to v$ path and let $z_{r+1}=l+1$. Observe that we can rewrite $D$ as

[TABLE]

For $i=1,\ldots,r$, let

[TABLE]

Let $P=(P_{1,1}\ldots P_{z_{1},1})P_{1}^{\prime}\ldots P_{r}^{\prime}$. Moreover, all the bracketed subpaths, except of $(P_{1,1}\ldots P_{z_{1},1})$, start with a vertex of $B$. The maximum number of edges, over all the bracketed subpaths, is clearly no more than $D$. Therefore, we conclude that $P$ is $(B,D)$-covered. ∎

Definition 2.9**.**

Let $G=(V,E)$ be a directed graph and let $d>0$ be an integer. A set $H_{d}\subseteq V$ is called a $d$-hub set of $G$ if for every $u,v\in V$ such that $\delta_{G}(u,v)<\infty$, there exists some shortest $u\to v$ path that is $(H_{d},d)$-covered.

Lemma 2.10**.**

Let $G=(V,E)$ be a directed unweighted graph and let $d>0$ be an integer. Suppose we are given a collection $\mathcal{T}=\{T_{v}:v\in V\}$ of shortest path trees up to depth $d$ from all vertices of $G$. Let $B$ be a $(\mathcal{T},d)$-blocker set. Then $B$ is a $2d$-hub set of $G$.

Proof.

Let $u,v\in V$ be any vertices such that $\delta_{G}(u,v)<\infty$. Let $P$ be some shortest $u\to v$ path. Let $P_{1},\ldots,P_{k}$, where $k\geq 1$ and $P_{i}=u_{i}\to v_{i}$, be such that $P=P_{1}\ldots P_{k}$, $|P_{1}|=\ldots=|P_{k-1}|=d$ and $|P_{k}|\leq d$. Then each $P_{i}$ is clearly a shortest $u_{i}\to v_{i}$ path. Since $T_{u_{i}}$ is a shortest path tree from $u_{i}$ containing all vertices $w$ such that $\delta_{G}(u_{i},w)\leq d$, $\delta_{T_{u_{i}}}(u_{i},v_{i})=|P_{i}|$. Let $P_{i}^{\prime}={T_{u_{i}}}[{v_{i}}]$ and set $P^{\prime}=P_{1}^{\prime}\ldots P_{k}^{\prime}$. Clearly, $|P^{\prime}|=|P|$ and thus $P^{\prime}$ is a shortest $u\to v$ path. As $|P_{i}^{\prime}|\leq d$ for each $i$, each $P_{i}^{\prime}$ is clearly $(B,d)$-covered. All paths $P_{1}^{\prime},\ldots,P_{k-1}^{\prime}$ contain a vertex of $B$ and thus, by Lemma 2.8, $P^{\prime}$ is $(B,2d)$-covered. We conclude that $B$ is indeed a $2d$-hub set of $G$. ∎

2.3 Deterministic Incremental Algorithm for Dense Graphs.

Theorem 2.11** ([19]+[5]).**

There exist an incremental algorithm maintaining $(1+\epsilon)$-approximate all-pairs distance estimates of a digraph in $O(n^{3}\log^{3}{n}\log(nW)/\epsilon+\Delta)$ total time.

As mentioned before, the above theorem basically follows by combining the partially-dynamic transitive closure algorithm of King [19] with Bernstein‘s $h$-SSSP algorithm (Theorem 2.4) for $h=2$. However, since the algorithm is not stated explicitly anywhere in the literature, we sketch it in Appendix A for completeness.

3 Deterministic Incremental Algorithm for Sparse Graphs

In this section we present our deterministic incremental algorithm with $\widetilde{O}(mn^{4/3}/\epsilon)$ total update time. We first observe that whenever an edge $xy$ is added, the set of hubs may be ’’fixed” by extending it with both $x$ and $y$.

Lemma 3.1**.**

Let $G=(V,E)$ be a directed unweighted graph. Let $H_{d}$ be a $d$-hub set of $G$. Let $x,y\in V$ be such that $xy\notin E$. Then $H_{d}^{\prime}=H_{d}\cup\{x,y\}$ is a $d$-hub set of $G^{\prime}=G+xy$.

In the proof we use Lemma 3.2, whose proof can be found above.

Lemma 3.2**.**

Let $G=(V,E)$ be a directed graph and let $B\subseteq V$. Let $b\in B$. Let $P$ be a $u\to b$ path in $G$ that is $(B,d_{P})$-covered. Let $Q$ be a $b\to v$ path in $G$ that is $(B,d_{Q})$-covered. Then the path $PQ=u\to v$ is $(B,\max(d_{P},d_{Q}))$-covered.

Proof.

Let $P=P_{1}\ldots P_{k}$ be such that for all $i$, $|P_{i}|\leq d_{P}$ and for all $i\geq 2$, $P_{i}$ starts at a vertex of $B$. Similarly, let $Q=Q_{1}\ldots Q_{l}$ be such that for all $i$, $|Q_{i}|\leq d_{Q}$ and for all $i\geq 2$, $Q_{i}$ starts at a vertex of $B$. By $b\in B$, all paths $P_{2},\ldots,P_{k},Q_{1},\ldots,Q_{l}$ start with a vertex of $B$. Moreover, each path of $P_{1},\ldots,P_{k},Q_{1},\ldots,Q_{l}$ has length no more than $\max(d_{P},d_{Q})$. We conclude that the path $PQ$ is $(B,\max(d_{P},d_{Q}))$-covered. ∎

Proof of Lemma 3.1.

Let $u,v\in V$ be such that $\delta_{G^{\prime}}(u,v)<\infty$. We need to show that there exists a shortest path $P=u\to v$ in $G^{\prime}$ such that $P$ is $(H_{d}^{\prime},d)$-covered.

Since $G\subseteq G^{\prime}$, $\delta_{G^{\prime}}(u,v)\leq\delta_{G}(u,v)$ If $\delta_{G^{\prime}}(u,v)=\delta_{G}(u,v)$, then there exists a shortest path $P=u\to v$ such that $P\subseteq G\subseteq G^{\prime}$. Hence, $P$ is $(H_{d},d)$-covered and thus also $(H_{d}^{\prime},d)$-covered.

If $\delta_{G^{\prime}}(u,v)<\delta_{G}(u,v)$, then all shortest $u\to v$ paths go through the edge $xy$. Let $P=P_{1}(xy)P_{2}$ be any such path, where $P_{1}=u\to x$ and $P_{2}=v\to y$ are shortest paths in $G$. Hence, there also exist shortest paths $P_{1}^{\prime}=u\to x$ and $P_{2}^{\prime}=v\to y$, also contained in $G$, such that $P_{1}^{\prime}$ and $P_{2}^{\prime}$ are both $(H_{d},d)$-covered and hence also $(H_{d}^{\prime},d)$-covered. Observe that the single-edge path $(x,y)$ is $(H_{d}^{\prime},1)$-covered.

By Lemma 3.2, since $x\in H_{d}^{\prime}$ and $d\geq 1$, the path $P_{1}^{\prime}(x,y)$ is $(H_{d}^{\prime},d)$ covered. Again by Lemma 3.2, since $y\in H_{d}^{\prime}$, and both paths $P_{1}^{\prime}(x,y)$ and $P_{2}^{\prime}$ are $(H_{d}^{\prime},d)$-covered, $P_{1}^{\prime}(x,y)P_{2}^{\prime}$ is $(H_{d}^{\prime},d)$-covered as well. We conclude that $H_{d}^{\prime}$ is indeed a $d$-hub set of $G^{\prime}$. ∎

3.1 The Data Structure Components

Let $d>1$ be an even integer and let $\epsilon_{1}$, $0<\epsilon_{1}<\epsilon$ be a real number, both to be set later. Our data structure consists of several components. Each subsequent component builds upon the previously defined components only.

Exact shortest paths between nearby vertices.

The data structure maintains two collections $\mathcal{T}^{\mathrm{from}}=\{T^{\mathrm{from}}_{v}:v\in V\}$ and $\mathcal{T}^{\mathrm{to}}=\{T^{\mathrm{to}}_{v}:v\in V\}$ of shortest path trees up to depth $\frac{d}{2}$ in $G$ and $G^{\mathrm{R}}$, resp. By Theorem 2.3, each tree of $\mathcal{T}^{\mathrm{from}}\cup\mathcal{T}^{\mathrm{to}}$ can be maintained under edge insertions in $O(md)$ total time. The total time spent in this component is hence $O(nmd)$.

The hubs.

A $d$-hub set $H_{d}$ of both $G$ and $G^{\mathrm{R}}$ such that |H_{d}|=O\mathopen{}\mathclose{{}\left(\frac{n}{d}\log{n}}\right) is maintained at all times, as follows. Initially, $H_{d}$ is computed in $O(n^{2}\log{n})$ time using Lemma 2.6 and the trees of $\mathcal{T}^{\mathrm{from}}\cup\mathcal{T}^{\mathrm{to}}$ (see Lemma 2.10). Next, the data structure operates in phases. Each phase spans $f=\Theta(\frac{n}{d}\log{n})$ consecutive edge insertions. When an edge $xy$ is inserted, its endpoints are inserted into $H_{d}$. By Lemma 3.1, this guarantees that $H_{d}$ remains a $d$-hub set of both $G$ and $G^{\mathrm{R}}$ after the edge insertion. Once $f$ edges are inserted in the current phase, the phase ends and the hub set $H_{d}$ is recomputed from scratch, again using Lemma 2.6. Observe that the size of $|H_{d}|$ may at most triple within each phase.

The total time spent on maintaining the set $H_{d}$ is clearly O\mathopen{}\mathclose{{}\left(\frac{m}{f}\cdot n^{2}\log{n}}\right)=O(nmd).

Approximate shortest paths between the hubs.

In each phase, we maintain a weighted graph $A=(H_{d},E_{A})$, where $E_{A}=\{uv:u,v\in H_{d},\delta_{G^{\mathrm{R}}}(u,v)\leq d\}$ and $w_{A}(uv)=\delta_{T^{\mathrm{to}}_{u}}(u,v)=\delta_{G^{\mathrm{R}}}(u,v)\leq d$. Observe that during each phase, the graph $A$ is in fact incremental. We can thus maintain $(1+\epsilon_{1})$-approximate distance estimates $\delta_{A}^{\prime}(u,v)$ for all $u,v\in H_{d}$ in O(|H_{d}|^{3}\log^{4}{n}/\epsilon_{1})=O\mathopen{}\mathclose{{}\left(\mathopen{}\mathclose{{}\left(\frac{n}{d}}\right)^{3}\log^{7}{n}/\epsilon_{1}}\right) total time per phase, using a data structure $\mathcal{D}_{A}$ of Theorem 2.11.888Technically speaking, the total update time of the data structure of Theorem 2.11 is $O(n^{3}\log^{4}{n}/\epsilon^{\prime})+O(\Delta)$. However, all updates to $\mathcal{D}_{A}$ arise when some previous component updates its explicitly maintained estimates, so the $\Delta$ term is asymptotically no more than the total update time of the previously defined components and can be charged to those. In the following, we omit $\Delta$ terms like this without warnings.

Summing over all phases, the total time spent on maintaining the $(1+\epsilon^{\prime})$-approximate distances estimates of the graph $A$ is O\mathopen{}\mathclose{{}\left(m\mathopen{}\mathclose{{}\left(\frac{n}{d}}\right)^{2}\log^{6}{n}/\epsilon_{1}}\right).

Lemma 3.3**.**

For any $u,v\in H_{d}$, $\delta_{G^{\mathrm{R}}}(u,v)=\delta_{A}(u,v)$.

Proof.

Let $u,v\in H_{d}$. If $\delta_{G^{\mathrm{R}}}(u,v)=\infty$, then clearly $\delta_{A}(u,v)=\infty$ as the edges of $A$ correspond to paths in $G^{\mathrm{R}}$. For the same reason, we have $\delta_{A}(u,v)\geq\delta_{G^{\mathrm{R}}}(u,v)$.

Suppose $\delta_{G^{\mathrm{R}}}(u,v)<\infty$. By the definition of $H_{d}$, there exists a shortest path $P=u\to v$ in $G^{\mathrm{R}}$ such that $P$ is $(H_{d},d)$-covered. Hence, $P$ can be expressed as $P_{1}\ldots P_{k}$, where $P_{i}=u_{i}\to v_{i}$, $u_{i},v_{i}\in H_{d}$ and $|P_{i}|\leq d$ for all $i$. Since $P_{i}$ is a shortest $u_{i}\to v_{i}$ path in $G^{\mathrm{R}}$, the edge $u_{i}v_{i}$ has length $|P_{i}|$ in $A$. Consequently, the path $(u_{1}v_{1})(u_{2}v_{2})\ldots(u_{k}v_{k})=u\to v$ has length $|P|=\delta_{G^{\mathrm{R}}}(u,v)$ in $A$. We thus obtain $\delta_{A}(u,v)\leq\delta_{G^{\mathrm{R}}}(u,v)$, which implies $\delta_{A}(u,v)=\delta_{G^{\mathrm{R}}}(u,v)$. ∎

By the above lemma, for each $u,v\in H_{d}$ we actually have $\delta^{\prime}_{A}(u,v)\leq(1+\epsilon_{1})\delta_{G^{\mathrm{R}}}(u,v)$.

Shortcuts to hubs.

For each $u\in V$, let $S_{u}$ be a graph on $V$ with exactly $n$ edges $\{uv:v\in V\}$ satisfying $w_{S_{u}}(u,v)\geq\delta_{G^{\mathrm{R}}}(u,v)$ for all $v\in V$, and additionally $w_{S_{u}}(u,v)\leq(1+\epsilon_{1})\delta_{G^{\mathrm{R}}}(u,v)$ if $u,v$ both currently belong to $H_{d}$. The edges between vertices of $H_{d}$ are the only ones that our algorithm needs to compute approximate distances. For other edges we only need to make sure they will not cause the algorithm to underestimate the distances.

Observe that the graphs $S_{u}$ can be maintained using the previously defined components as follows. First, they are initialized so that their edges are all infinite-weight. Whenever the data structure $\mathcal{D}_{A}$ changes (or initializes) some of its estimates $\delta_{A}^{\prime}(u,v)\leq(1+\epsilon_{1})\delta_{G^{\mathrm{R}}}(u,v)$, we perform $w_{S_{u}}(u,v):=\min(w_{S_{u}}(u,v),\delta_{A}^{\prime}(u,v))$. This guarantees that the invariants posed on $S_{u}$ are always satisfied and $S_{u}$ is incremental. The total number of updates to all graphs $S_{u}$ is equal to the number of estimate updates made by $\mathcal{D}_{A}$ and thus can be neglected.

For $u\in V$, we set up a $h$-SSSP data structure $\mathcal{D}_{u}$ of Theorem 2.4 for the graph $G^{\mathrm{R}}\cup S_{u}$ with source vertex $u$ and $h=d+1$. Hence, $\mathcal{D}_{u}$ maintains distance estimates $\delta^{\prime}(u,v)$ such that $\delta^{\prime}(u,v)\leq(1+\epsilon^{\prime})\delta_{G^{\mathrm{R}}\cup S_{u}}^{d+1}(u,v)$. As the graph $G^{\mathrm{R}}\cup S_{u}$ is incremental and has $O(m)$ edges, the total time that $\mathcal{D}_{u}$ needs to operate is $O(md\log^{2}{n}/\epsilon_{1}+\Delta_{u})$, where $\Delta_{u}$ is the total number of updates to $G^{\mathrm{R}}\cup S_{u}$. Summing the update times for all data structures $\mathcal{D}_{u}$, we obtain $O(nmd\log^{2}{n}/\epsilon_{1}+\sum_{v\in V}\Delta_{u})$ total time. Note that $\sum_{u\in V}\Delta_{u}$ equals $nm$ plus the number of updates to the graphs $S_{u}$, which can be charged to the operating cost of data structure $\mathcal{D}_{A}$, as argued before. We conclude that the total update time of all $\mathcal{D}_{u}$ is $O(nmd\log^{2}{n}/\epsilon_{1})$.

Observe that a shortest $u\to v$ path in $G^{\mathrm{R}}$, where $u\in H_{d}$ and $v\in V$ is approximated by a path in $G^{\mathrm{R}}\cup S_{u}$ consisting of at most $d+1$ edges. The first edge belongs to $S_{u}$ and ’’jumps” to some hub. The latter (at most $d$) edges belong to $G^{\mathrm{R}}$. This is formalized as follows.

Lemma 3.4**.**

Let $u\in H_{d}$ and $v\in V$. Then $\delta_{G^{\mathrm{R}}\cup S_{u}}^{d+1}(u,v)\leq(1+\epsilon_{1})\delta_{G^{\mathrm{R}}}(u,v)$.

Proof.

Recall that $H_{d}$ is a $d$-hub set of $G^{\mathrm{R}}$. It follows that there exists a shortest path $P=P_{1}\ldots P_{k}=u\to v$ such that for each $i$, $P_{i}=u_{i}\to v_{i}$, $|P_{i}|\leq d$ and $u_{i}\in H_{d}$ (since $u_{1}=u\in H_{d}$). Consider the edge $e=uu_{k}$ of $S_{u}$. As $u,u_{k}\in H_{d}$, $w_{S_{u}}(e)\leq(1+\epsilon_{1})\delta_{G^{\mathrm{R}}}(u,u_{k})=(1+\epsilon_{1})\ell(P_{1}\ldots P_{k-1})$. Moreover, clearly $P_{k}\subseteq G^{\mathrm{R}}\cup S_{u}$. The path $P^{\prime}=eP_{k}=u\to v$ thus has $d+1$ edges and $P^{\prime}\subseteq G^{\mathrm{R}}\cup S_{u}$. Consequently, we obtain

[TABLE]

By the above lemma, we conclude that for $u\in H_{d}$, $v\in V$, the estimate $\delta^{\prime}(u,v)$ produced by the data structure $\mathcal{D}_{v}$ satisfies $\delta^{\prime}(u,v)\leq(1+\epsilon_{1})\delta_{G^{\mathrm{R}}\cup S_{u}}^{d+1}(u,v)\leq(1+\epsilon_{1})^{2}\delta_{G^{\mathrm{R}}}(u,v)$.

All-pairs approximate shortest paths.

We maintain another set of shortcut graphs $R_{u}$, for $u\in V$. Again $R_{u}$ has exactly $n$ edges $\{uv:v\in V\}$ whose weights satisfy $w_{R_{u}}(uv)\geq\delta_{G}(u,v)$ for all $v$ and $w_{R_{u}}(uv)\leq(1+\epsilon_{1})^{2}\delta_{G}(u,v)$ if $v\in H_{d}$. Each graph $R_{u}$ is maintained using the previously defined data structures $\mathcal{D}_{v}$. Initially all weights of $R_{u}$ are infinite. Whenever some $\mathcal{D}_{v}$ changes the estimate $\delta^{\prime}(v,u)$, we set $w_{R_{u}}(uv):=\min(w_{R_{u}}(uv),\delta^{\prime}(v,u))$. Since for $v\in H_{d}$ we have $\delta^{\prime}(v,u)\leq(1+\epsilon_{1})^{2}\delta_{G^{\mathrm{R}}}(v,u)$, equivalently, $\delta^{\prime}(v,u)\leq(1+\epsilon_{1})^{2}\delta_{G}(u,v)$ and we obtain $w_{R_{u}}(uv)\leq(1+\epsilon_{1})^{2}\delta_{G}(u,v)$. Therefore, the graphs $R_{u}$ are all incremental and the total number of changes they are subject to is no more than the total number of estimate changes made by the data structures $\mathcal{D}_{v}$, $v\in V$. Thus, we may neglect the cost of actually performing these changes.

Finally, for each $u\in V$ we set up a $h$-SSSP data structure $\mathcal{D}^{\prime}_{u}$ of Theorem 2.4 on graph $G\cup R_{u}$ with source $u$ and $h=d+1$, maintaining $(1+\epsilon_{1})$-approximate estimates of the values $\delta^{d+1}_{G\cup R_{u}}(u,\cdot)$. Similarly as was the case for the data structures $\mathcal{D}_{u}$ of the previous component, as the graphs $G\cup R_{u}$ are incremental, the total operating time of the $h$-SSSP instances running on the graphs $G\cup R_{u}$ is $O(nmd\log^{2}{n}/\epsilon_{1})$.

Lemma 3.5**.**

Let $u,v\in V$. Then $\delta_{G\cup R_{u}}^{d+1}(u,v)\leq(1+\epsilon_{1})^{2}\delta_{G}(u,v)$.

Proof.

Recall that $H_{d}$ is a $d$-hub set of $G$. Hence, if $\delta_{G}(u,v)<\infty$, there exists a shortest path $P=P_{1}\ldots P_{k}=u\to v$, where $P_{i}=u_{i}\to v_{i}$, $|P_{i}|\leq d$ and $u_{i}\in H_{d}$ for all $i\geq 2$. If $k=1$ then $|P|\leq d$ and as a result $\delta_{G\cup R_{u}}^{d+1}(u,v)\leq\delta_{G}^{d}(u,v)=\delta_{G}(u,v)$.

Suppose $k\geq 2$. Then $u_{k}\in H_{d}$ and consequently the weight of the edge $e=uu_{k}\in E(R_{u})$ satisfies $w_{R_{u}}(e)\leq(1+\epsilon_{1})^{2}\delta_{G}(u,u_{k})=(1+\epsilon_{1})^{2}|P_{1}\ldots P_{k-1}|$. The path $P^{\prime}=eP_{k}\subseteq G\cup R_{u}$ satisfies $\ell(P^{\prime})\leq(1+\epsilon_{1})^{2}\ell(P)=(1+\epsilon_{1})^{2}\delta_{G}(u,v)$ and $|P^{\prime}|\leq d+1$. Hence, indeed $\delta_{G\cup R_{u}}^{d+1}(u,v)\leq\ell(P^{\prime})\leq(1+\epsilon_{1})^{2}\delta_{G}(u,v)$. ∎

By the above lemma, the the distance estimates $\delta^{\prime\prime}(u,v)$ maintained by the data structure $\mathcal{D}^{\prime}_{u}$, approximate the corresponding distances $\delta_{G}(u,v)$ within a factor of $(1+\epsilon_{1})^{3}$.

Theorem 3.6**.**

Let $G$ be a directed unweighted graph. There exists a deterministic incremental algorithm maintaining $(1+\epsilon)$-approximate distance estimates between all pairs of vertices of $G$ in $O(mn^{4/3}\log^{10/3}{n}/\epsilon)$ total time.

Proof.

Let $\epsilon_{1}=\epsilon/6$. Then the estimates $\delta^{\prime\prime}(u,v)$ produced by the data structures $\mathcal{D}^{\prime}_{u}$ approximate the actual distances within a factor of \mathopen{}\mathclose{{}\left(1+\frac{\epsilon}{6}}\right)^{3}\leq 1+\epsilon. The total time used by the data structure is clearly O\mathopen{}\mathclose{{}\left(nmd\log^{2}{n}/\epsilon+m\mathopen{}\mathclose{{}\left(\frac{n}{d}}\right)^{2}\log^{6}{n}/\epsilon}\right)=O\mathopen{}\mathclose{{}\left(nm\log^{2}{n}\cdot\mathopen{}\mathclose{{}\left(d+\frac{n}{d^{2}}\log^{4}{n}}\right)/\epsilon}\right). By setting $d=n^{1/3}\log^{4/3}{n}$, we obtain the desired bound. ∎

4 Partially-Dynamic Verification of a Sampled Hub Set

In this section we show how to maintain the information whether a sampled set remains a hub set of an unweighted digraph $G$ subject to partially dynamic updates. For simplicity, assume that $G$ is decremental (the incremental case, being somewhat easier, can be handled similarly). We start by showing how a reliable hub set can be found if we are given shortest path trees up to depth $d$ from all vertices of $G$, stored in dynamic tree data structures.

Lemma 4.1** ([27, 29]).**

Let $V$ be a vertex set of size $n$ and let $d>0$ be an integer. Let $\mathcal{T}$ be a collection of rooted trees of depth no more than $d$, whose vertex sets are subsets of $V$.

Let $c>1$ be some positive constant. Let $B$ be a random subset of $V$ of size \min\mathopen{}\mathclose{{}\left(\lceil c\frac{n}{d}\ln{n}\rceil,n}\right). Then, $B$ is a $(\mathcal{T},d)$-blocker set with probability at least $\max(0,1-|\mathcal{T}|/n^{c-1})$.

Proof.

If $\lceil c\frac{n}{d}\ln{n}\rceil\geq n$, then $B=V$ and the lemma obviously holds.

Suppose $\lceil c\frac{n}{d}\ln{n}\rceil<n$. For each $v\in V$, $\mathrm{Pr}[v\notin B]\leq 1-\frac{c\ln{n}}{d}$. Hence, for a fixed $T\in\mathcal{T}$ and $w\in T$ such that $\mathrm{dep}_{T}({w})=d$, the probability that neither $w$ nor any of its ancestors in $T$ belong to $B$ is no more than \mathopen{}\mathclose{{}\left(1-\frac{c\ln{n}}{d}}\right)^{d+1}\leq e^{-c\ln{n}}=n^{-c}. Therefore, the probability that this happens for any $T$ and $w$, is no more than $|\mathcal{T}|/n^{c-1}$. ∎

Lemma 4.2**.**

Let $V$ be some set of $n$ vertices. Let $F$ be a forest of (initially single-vertex) rooted out-trees over $V$ such that the vertex sets of the individual trees of $F$ form a partition of $V$. For $v\in V$, let $T_{v}\in F$ denote the unique tree of $F$ containing $v$.

There exists a data structure for dynamically maintaining $F$ (initially consisting of $n$ $1$-vertex trees) and supporting the following operations in $O(\log{n})$ time each:

$\mathtt{parent}(v)$: if $v$ is not the root of $T_{v}$, return its parent. Otherwise return $\mathbf{nil}$. 2. 2.

$\mathtt{link}(u,v)$: assuming $T_{u}\neq T_{v}$ and that $u$ is the root of $T_{u}$, make $u$ a child of $v$ in $T_{v}$. 3. 3.

$\mathtt{cut}(v)$: assuming $v$ is not the root of $T_{v}$, split $T_{v}$ into two trees by removing the edge between $v$ and its parent. 4. 4.

$\mathtt{depth}(v)$: return the depth of the tree $T_{v}$.

Proof.

We store our forest $F$ as a collection of the Euler-tour based dynamic trees of Tarjan [25]. This data structure is capable of maintaining a forest $F^{\prime}$ of unrooted and undirected trees over $V$ such that each $v\in V$ is additionally associated a real value $val(v)$. Similarly, let us denote by $T_{v}^{\prime}$ the unique tree of the forest containing $v$. The supported operations are as follows:

• •

$link(u,v)$: if $T_{u}^{\prime}\neq T_{v}^{\prime}$, then combine $T_{u}^{\prime}$ and $T_{v}^{\prime}$ by adding the edge $uv$.

• •

$cut(u,v)$: assuming $T_{u}^{\prime}=T_{v}^{\prime}$ and $uv\in E(T_{u}^{\prime})$, break the tree $T_{u}^{\prime}$ into two by removing the edge $uv$.

• •

$change\textnormal{-}val(v,x)$: set $val(v):=x$.

• •

$find\textnormal{-}val(v)$: return $val(v)$.

• •

$add\textnormal{-}val(v,x)$: add $x\in\mathbb{R}$ to $val(w)$ of every vertex $w\in V(T_{v}^{\prime})$.

• •

$find\textnormal{-}max\textnormal{-}val(v)$: return a vertex $w$ with maximum $val(w)$ in $T_{v}^{\prime}$.

Even though the data structure of [25] maintains a forest of unrooted undirected trees, we show that the above operations are sufficient to maintain the depth of each out-tree (which both rooted and directed) of $F$.

To be able to operate on out-trees, for each vertex $v\in V$, we explicitly store its parent $\mathrm{par}(v)$ in a table (if $v$ is the root of $T_{v}$, $\mathrm{par}(v)=\mathbf{nil}$). Initially we set $\mathrm{par}(v)=\mathbf{nil}$ for all $v\in V$. $\mathtt{parent}(v)$ simply returns $\mathrm{par}(v)$. The forest $F^{\prime}$ stored in our data structure of [25] always consists of (undirected) edges of the form $\mathrm{par}(v)v$, for $v$ such that $\mathrm{par}(v)\neq\mathbf{nil}$. Hence, $F^{\prime}$ is initially empty.

For each $v$, we will guarantee that the value $val(v)$ maintained by the data structure of [25] is equal to $\mathrm{dep}_{T_{v}}({v})$. To this end, we initially perform $change\textnormal{-}val(v,0)$ for each $v\in V$. By the invatiant posed on the values $val(v)$, and since the depth of any $T_{v}$ is the maximum depth over all its vertices, we can implement $\mathtt{depth}(v)$ with $find\textnormal{-}max\textnormal{-}val(v)$.

$\mathtt{cut}(v)$ is implemented as follows. We first record $y:=find\textnormal{-}val(v)$. Then we perform $cut(\mathrm{par}(v),v)$ on $F^{\prime}$ and set $\mathrm{par}(v)$ to $\mathbf{nil}$. Afterwards, $T_{v}$ is a tree rooted in $v$. At this point the values $val(w)$ for all $w\in V(T_{v})$ exceed the respective depths in $T_{v}$ by exactly $y$. So, in order to update the vertex depths in the new tree $T_{v}$, we perform $add\textnormal{-}val(v,-y)$. Clearly, the depths in the other obtained tree (the one that does not contain $v$) need not be updated.

To implement $\mathtt{link}(u,v)$, we first set $\mathrm{par}(u):=v$. Then, we update the depths in $T_{u}$ before it is connected to $T_{v}$ by calling $add\textnormal{-}val(u,find\textnormal{-}val(v)+1)$. Finally, we call $link(u,v)$.

Since each of the operations $\mathtt{depth}$, $\mathtt{cut}$ and $\mathtt{link}$ translate into a constant number of operations on the data structure of [25] storing $F^{\prime}$, all operations run in $O(\log{n})$ time. ∎

Lemma 4.3**.**

Let $V$ be a vertex set, $n=|V|$, and let $d>0$ be integral. Let $\mathcal{T}$ be a collection of rooted trees over $V$ of depth no more than $d$, where $|\mathcal{T}|=O(\operatorname{poly}{n})$. Suppose each $T\in\mathcal{T}$ is given as a separate data structure of Lemma 4.2 and for each $T\in\mathcal{T}$, $\mathrm{root}(T)$ is known.

Then, there exists a Las Vegas randomized algorithm computing a $(\mathcal{T},d)$-blocker set $B$ of size O\mathopen{}\mathclose{{}\left(\frac{n}{d}\log{n}}\right) in $O(|\mathcal{T}|\cdot\frac{n}{d}\cdot\log^{2}{n})$ time with high probability.

Proof.

Let $|\mathcal{T}|=O(n^{\alpha})$ for some $\alpha>0$. The algorithm is to simply repeatedly pick random subsets $B$ of $V$ of size $\min(\lceil(\alpha+2)\frac{n}{d}\ln{n}\rceil,n)$ until $B$ succeeds in being a $(\mathcal{T},d)$-blocker set. By Lemma 4.1, for a random $B$, the probability that this is not the case is at most $\frac{1}{n}$. Hence, the probability that we fail finding a $(\mathcal{T},d)$-blocker set after $k=O(1)$ trials is at most $1/n^{k}$.

We thus only need to show how to verify whether a set $B$ is actually a $(\mathcal{T},d)$-blocker set in $O(|\mathcal{T}|\cdot|B|\log{n})$ time. Recall that for a single $T\in\mathcal{T}$, if the depth of $T$ is no more than $d$, then $B$ is a $(T,d)$-blocker set if the tree $T^{\prime}$ obtained from $T$ by removing all subtrees rooted in vertices of $B$, has depth less than $d$. Consequently, to verify whether $B$ is a $(T,d)$-blocker set, we take advantage of the fact that $T$ is stored in a data structure of Lemma 4.2.

We first check whether $r=\mathrm{root}(T)\in B$. If this is the case, $B$ is a $(T,d)$-blocker set in a trivial way. Otherwise, for each $b\in B$, we store $p_{b}=\mathtt{parent}(b)$ and perform $\mathtt{cut}(b)$. Afterwards, one can see that $B$ is a $(T,d)$-blocker set if and only if $\mathtt{depth}(r)<d$. Finally, we revert all the performed $\mathtt{cut}$ operations by running $\mathtt{link}(b,p_{b})$ for all $b\in B$.

Clearly, the time needed to verify whether $B$ is a $(T,d)$-blocker set for any $T\in\mathcal{T}$, is $O(|B|\log{n})$. Hence, one can check whether $B$ is a $(\mathcal{T},d)$-blocker set in $O(|\mathcal{T}|\cdot|B|\log{n})$ time. ∎

Now we move on to the problem of detecting when a sampled set ceases to be a valid hub set of $G$. In fact, our algorithm will solve a bit more general problem (which is anyway needed for applications, as we will see later), as follows.

Let $|V|=n=a_{0}>a_{1}>\ldots>a_{q}=1$ be some sequence of integers such that $a_{i}\mid a_{i-1}$. For each $i=0,\ldots,q$, let $A_{i}$ be a random $a_{i}$-subset (a subset of size $a_{i}$) of $V$. By Lemmas 2.10 and 4.1, each $A_{i}$ is in fact an \Theta\mathopen{}\mathclose{{}\left((n/a_{i})\ln{n}}\right)-hub set of $G$ with high probability.

We would like to detect when some $A_{i}$ ceases to be an \Theta\mathopen{}\mathclose{{}\left((n/a_{i})\ln{n}}\right)-hub set of $G$ while $G$ undergoes edge deletions. Using this terminology, both state-of-the-art Monte-Carlo randomized algorithms for decremental exact shortest paths [4] and partially-dynamic $(1+\epsilon)$-approximate shortest paths [5] (for unweighted digraphs) use randomness only for constructing hub sets $A_{0},\ldots,A_{q}$ (they use $a_{i}=2^{q-i}$, but in fact any $a_{i}=c^{q-i}$, where $c$ is a positive integer, would be sufficient for these algorithms to work), valid simultaneously for all versions of the input graph with high probability (the sets $A_{i}$ satisfy this, as we will later show).

Without loss of generality, we can assume that given the sets $A_{0},\ldots,A_{q}$, the algorithms of [4, 5] proceed deterministically (we discuss these algorithms in a more detailed way in Appendix B). Suppose we develop an efficient partially dynamic algorithm $\mathcal{A}$ verifying whether each $A_{i}$ remains a \Theta\mathopen{}\mathclose{{}\left((n/a_{i})\ln{n}}\right)-hub set of $G$ (i.e., $\mathcal{A}$ is supposed to detect that some $A_{i}$ ceases to be a \Theta\mathopen{}\mathclose{{}\left((n/a_{i})\ln{n}}\right)-hub set immediately after this happens) and producing false negatives with low probability (the algorithm is guaranteed to be correct if it says that all $A_{i}$ have the desired property but might be wrong saying that some $A_{i}$ is no longer a hub set). Then, we could use $\mathcal{A}$ to convert the algorithms of [4, 5] into Las Vegas algorithms by drawing new sets $A_{0},\ldots,A_{q}$ and restarting the respective algorithms whenever $\mathcal{A}$ detects (possibly incorrectly) that any of these sets ceases to be a hub set. As this does not happen w.h.p., with high probability the overall asymptotic running time remains unchanged. The remainder of this section is devoted to describing such an algorithm $\mathcal{A}$.

Lemma 4.4**.**

Let $d>0$ be an integer. Let $F$ be a forest of out-trees of depth no more than $d$ over $V$. Denote by $T_{v}$ the unique tree of $F$ containing $v\in V$. Let $B\subseteq V$ be fixed.

There exists a data structure with update time $O(\log{n})$, maintaining the information whether $B$ is a $(F,d)$-blocker set, subject to updates to $F$ of the following types:

• •

cut the subtree rooted in $v$ out of $T_{v}$ where $v\in V$ and $v$ is not the root of $T_{v}$,

• •

make the tree $T_{r}$ a child of $v\in T_{v}$ where $r\in V$ is the root of $T_{r}$ and $v\notin T_{r}$,

Proof.

We use the data structure of Lemma 4.2 to store $F$. However, each $T\in F$ is represented in this data structure as a collection $F_{T}$ of either $|V(T)\cap B|$ (if the root of $T$ is in $B$) or $|V(T)\cap B|+1$ (otherwise) trees: the maximal subtrees of $T$ that intersect with $B$ either only in their respective roots or not at all.

Recall that for a single $T\in F$, if the depth of $T$ is no more than $d$, then $B$ is a $(T,d)$-blocket set if the tree $T^{\prime}$ obtained from $T$ by removing all subtrees rooted in vertices of $B$ has depth less than $d$. Equivalently, $B$ is a $(T,d)$-blocker set if the depth of all trees of $F_{T}$ is less than $d$. Consequently, $B$ is a $(F,d)$-blocker set if the depth of all trees of $\bigcup_{T\in F}F_{T}$ is less than $d$. This information is easy to maintain using the data structure of Lemma 4.2 if this data structure stores $F^{\prime}=\bigcup_{T\in F}F_{T}$ at all times. This is precisely what our algorithm does.

The first operation can be implemented simply as $\mathtt{cut}(v)$ on $F^{\prime}$. To implement the second operation, we first check if $r\in B$. If so, we do nothing, as the vertices of $B$ can only be roots in $F^{\prime}$. Otherwise, we perform $\mathtt{link}(r,v)$. After any $\mathtt{link}(r,v)$ operation, to update the information whether $B$ is still a $(F,d)$-blocker set, it is sufficient to check whether $\mathtt{depth}(v)<d$. ∎

The following technical lemma will prove useful.

Lemma 4.5**.**

Let $G=(V,E)$ be a directed graph and let $B\subseteq V$. Let $d>0$ be an integer. Let $P$ be a path that is $(B,d)$-covered and $|P|\geq d$. Then, one can represent $P$ as $P_{1}\ldots P_{k}$ such that:

• •

$|P_{i}|\in[d,3d]$* for each $i=1,\ldots,k$,*

• •

$P_{i}$* starts with a vertex of $B$ for each $i=2,\ldots,k$.*

Proof.

By the fact that $P=u\to v$ is $(B,d)$-covered, $P$ can be expressed as $P=P^{\prime}_{1}\ldots P^{\prime}_{l}$, where $P^{\prime}_{i}=u_{i}\to v_{i}$, $|P^{\prime}_{i}|\leq d$ for all $i$ and $u_{i}\in B$ for all $i\geq 2$. Let us partition the path $P^{\prime}_{1}\ldots P^{\prime}_{l}$ into subpaths (blocks) $P_{1},\ldots,P_{k}$ using the following procedure.

At each step $P^{\prime}_{j},\ldots,P^{\prime}_{l}$ ($j\geq 1$) will constitute the remaining part of $P^{\prime}_{1},\ldots,P^{\prime}_{l}$ to be partitioned and $|P^{\prime}_{j}\ldots P^{\prime}_{l}|\geq d$. Initially, $j=1$. If $|P^{\prime}_{j}\ldots P^{\prime}_{l}|\leq 3d$, the next block $P_{i}$ is set to $P^{\prime}_{j}\ldots P^{\prime}_{l}$ and the procedure ends. Otherwise, let $f$ be the minimum index such that $|P^{\prime}_{j}\ldots P^{\prime}_{f}|\geq d$. We set the next block $P_{i}$ to be $P^{\prime}_{j}\ldots P^{\prime}_{f}$. By the definition of $f$ and $|P^{\prime}_{f}|\leq d$, we have $|P_{i}|=|P^{\prime}_{j}\ldots P^{\prime}_{f}|\leq 2d$ and $|P^{\prime}_{f+1}\ldots P^{\prime}_{l}|\geq d$. ∎

The following lemma says that in order to test whether a given set of vertices is a $6d$-hub set it suffices to test the hub set property for paths starting in vertices of a $d$-hub set.

Lemma 4.6**.**

Let $G=(V,E)$ be a directed unweighted graph. Let $H_{d}$ be a $d$-hub set of $G$. Suppose we are given two collections $\mathcal{T}^{\mathrm{from}}=\{T^{\mathrm{from}}_{v}:v\in H_{d}\}$, $\mathcal{T}^{\mathrm{to}}=\{T^{\mathrm{to}}_{v}:v\in H_{d}\}$ of shortest path trees up to depth $d$ from all vertices of $H_{d}$ in $G$ and $G^{\mathrm{R}}$, respectively.

Let $B$ be a $(\mathcal{T}^{\mathrm{from}}\cup\mathcal{T}^{\mathrm{to}},d)$-blocker set. Then $B$ is a $6d$-hub set of $G$.

Proof.

Let $u,v\in V$ be any vertices such that $\delta_{G}(u,v)<\infty$. If $\delta_{G}(u,v)\leq d$, then any shortest $u\to v$ path is $(B,6d)$-covered. Suppose $\delta_{G}(u,v)>d$.

Let $P$ be any shortest $u\to v$ path in $G$ that is $(H_{d},d)$-covered. By Lemma 4.5, one can express $P$ as $P=P_{1}\ldots P_{k}$ where $|P_{i}|\in[d,3d]$ and each $P_{i}$ for $i\geq 2$ starts with a vertex of $H_{d}$. Now define $P_{1}^{\prime},\ldots,P_{k}^{\prime}$ as follows. If $i\in[2,k]$, then let $P_{i}=R_{i}S_{i}$ where $R_{i}=a_{i}\to b_{i}$, $|R_{i}|=d$, and set $P_{i}^{\prime}={T^{\mathrm{from}}_{a_{i}}}[{b_{i}}]\cdot S_{i}.$ For $i=1$, suppose $P_{1}=R_{1}S_{1}$ where $|S_{1}|=d$ and $S_{1}=a_{1}\to b_{1}$. Then we set $P_{1}^{\prime}=R_{1}\cdot({T^{\mathrm{to}}_{b_{i}}}[{a_{i}}])^{\mathrm{R}}$. Clearly, for all $i$, $P_{i}^{\prime}$ has the same endpoints as $P_{i}$ and $|P_{i}^{\prime}|=|P_{i}|$. Therefore, $P^{\prime}=P_{1}^{\prime}\ldots P_{k}^{\prime}$ is also a shortest $u\to v$ path.

Since $|P_{i}^{\prime}|\leq 3d$, $P_{i}^{\prime}$ is $(B,3d)$-covered. Moreover, by the definition of $B$, for all $i$ we have $V(P_{i}^{\prime})\cap B\neq\emptyset$. Hence, by Lemma 2.8, we conclude that $P^{\prime}$ is $(B,6d)$-covered.

We have thus proved that for all $u,v\in V$, where $\delta_{G}(u,v)<\infty$, some shortest $u\to v$ is $(B,6d)$-covered. Equivalently, $B$ is a $6d$-hub set of $G$. ∎

Observe that by Lemma 4.1, there exists an integral constant $z>0$, such that for any fixed collection of trees $\mathcal{T}$ of depth no more than $z\cdot\frac{n}{a_{i}}\lceil\ln{n}\rceil$, where $|\mathcal{T}|=O(n^{3})$, $A_{i}$ is a \mathopen{}\mathclose{{}\left(\mathcal{T},z\cdot\frac{n}{a_{i}}\lceil\ln{n}\rceil}\right)-blocker set with high probability. For $i=0,\ldots,q$, set $d_{i}=z\cdot\frac{n}{a_{i+1}}\lceil\ln{n}\rceil$ where $a_{q+1}=1$. Suppose $G$ undergoes partially dynamic updates. For each $i=1,\ldots,q$, and $v\in V$ let $T^{\mathrm{from}}_{i,v}$ ($T^{\mathrm{to}}_{i,v}$) denote the shortest path tree that the algorithm of Theorem 2.3 would maintain for $d=d_{i-1}$ and source $v$ in $G$ (in $G^{\mathrm{R}}$, respectively). Note that how the trees $T^{\mathrm{from}}_{i,v}$ and $T^{\mathrm{to}}_{i,v}$ evolve depends only on the sequence of updates to $G$ (which, by the oblivious adversary assumption, does not depend on sets $A_{0},\ldots,A_{q}$ in any way) and the details of the deterministic algorithm of Theorem 2.3. Since only $O(mn)=O(n^{3})$ different trees appear in $\{T^{\mathrm{from}}_{i,v}:v\in V\}\cup\{T^{\mathrm{to}}_{i,v}:v\in V\}$ throughout all updates, $A_{i}$ remains a $(\{T^{\mathrm{from}}_{i,v}:v\in V\}\cup\{T^{\mathrm{to}}_{i,v}:v\in V\},d_{i-1})$-blocker set throughout the whole sequence of updates with high probability, by Lemma 4.1.

Let $\mathcal{T}^{\mathrm{from}}_{i}=\{T^{\mathrm{from}}_{i,v}:v\in A_{i-1}\}$ and $\mathcal{T}^{\mathrm{to}}_{i}=\{T^{\mathrm{to}}_{i,v}:v\in A_{i-1}\}$, i.e., $\mathcal{T}^{\mathrm{from}}_{i}$ ($\mathcal{T}^{\mathrm{to}}_{i}$) contains only trees with roots from a subset $A_{i-1}\subseteq V$. However $A_{i}$ being a blocker set of such a collection of trees will turn out sufficient for our needs. Clearly, since we have $\mathcal{T}^{\mathrm{from}}_{i}\cup\mathcal{T}^{\mathrm{to}}_{i}\subseteq\{T^{\mathrm{from}}_{i,v}:v\in V\}\cup\{T^{\mathrm{to}}_{i,v}:v\in V\}$, by the above claim, $A_{i}$ in fact remains a $(\mathcal{T}^{\mathrm{from}}_{i}\cup\mathcal{T}^{\mathrm{to}}_{i},d_{i-1})$-blocker set throughout the whole sequence of updates with high probability.

Now, let $q=\lceil\log_{6}{n}\rceil$ and for $i=1,\ldots,q$ set $a_{i}=6^{q-i}$. To verify whether each $A_{i}$ remains a $d_{i}$-hub set subject to partially dynamic updates to $G$, we proceed as follows. We deterministically maintain the trees $\bigcup_{i=1}^{q}(\mathcal{T}^{\mathrm{from}}_{i}\cup\mathcal{T}^{\mathrm{to}}_{i})$ subject to partially dynamic updates to $G$ using Theorem 2.3. The total number of changes these trees are subject to throughout the whole sequence of updates is

[TABLE]

We additionally store each tree $T^{\mathrm{from}}_{i,v}$ (and $T^{\mathrm{to}}_{i,v}$), for $v\in A_{i-1}$, in a data structure of Lemma 4.4 with $B=A_{i}$. Whenever the data structure of Theorem 2.3 updates some tree, the update is repeated in the corresponding data structure of Lemma 4.4. Consequently, the total time needed to maintain these additional data structures is O\mathopen{}\mathclose{{}\left(nm\log^{2}{n}\cdot\sum_{i=1}^{q}\frac{a_{i-1}}{a_{i}}}\right)=O(nm\log^{3}{n}).

After each update we can detect whether each $A_{i}$ is still a $(\mathcal{T}^{\mathrm{from}}_{i}\cup\mathcal{T}^{\mathrm{to}}_{i},d_{i-1})$-blocker set in $O(\sum_{i}^{q}|A_{i-1}|\log{n})=O(n\log{n})$ time by querying the relevant data structures of Lemma 4.4999The Even-Shiloach algorithm (Theorem 2.3), apart from maintaining distance labels for all $v\in V$, moves around entire subtrees of the maintained tree $T$. Hence, in order to ensure that some set $B$ remains a blocker-set of $T$, it is not sufficient to simply check whether $B\cap V(T[v])$ whenever the Even-Shiloach algorithm changes the distance label of $v$ to $d$ (and, consequently, use a data structure much simpler than that given in Lemma 4.4). storing $\mathcal{T}^{\mathrm{from}}_{i}\cup\mathcal{T}^{\mathrm{to}}_{i}$. By Lemma 4.6, a simple inductive argument shows that if this is the case, each $A_{i}$ is a $d_{i}$-hub set of both $G$ and $G^{\mathrm{R}}$. Hence, verifying all $A_{1},\ldots,A_{q}$ while $G$ evolves takes $O(mn\log{n})$ total time. The algorithm terminates when it turns out that some $A_{i}$ is no longer a $(\mathcal{T}^{\mathrm{from}}_{i}\cup\mathcal{T}^{\mathrm{to}}_{i},d_{i-1})$-blocker set. However, recall that this happens only with low probability, regardless of whether $A_{i}$ actually ceases to be a $d_{i}$ hub set or not. We have proved the following.

Theorem 4.7**.**

Let $G$ be an unweighted digraph. Let $q=\lceil\log_{6}{n}\rceil$. For $i=0,\ldots,q$, let $A_{i}$ be a random $6^{q-i}$-subset of $V$. One can maintain the information whether each $A_{i}$ is a $\Theta(6^{i}\ln{n})$-hub set of $G$, subject edge deletions issued to $G$, in $O(nm\log^{3}{n})$ total time.

The algorithm might produce false negatives with low probability.

By plugging in the hubs of Theorem 4.7 into the algorithms of [4, 5], we obtain the following.

Corollary 4.8**.**

Let $G$ be an unweighted digraph. There exists a Las Vegas randomized decremental algorithm maintaining exact distance between all pairs of vertices of $G$ with $\widetilde{O}(n^{3})$ total update time w.h.p. It assumes an adversary oblivious to the random bits used.

Corollary 4.9**.**

Let $G$ be an unweighted digraph. There exists a Las Vegas randomized decremental algorithm maintaining $(1+\epsilon)$-approximate distance estimates between all pairs of vertices of $G$ in $\widetilde{O}(nm/\epsilon)$ total time w.h.p. The algorithm assumes an oblivious adversary.

5 Approximate Shortest Paths for Weighted Graphs

In this section we generalize the reliable hub maintenance algorithms to weighted graphs, at the cost of $(1+\epsilon)$-approximation. First we we give key definitions.

Definition 5.1**.**

Let $G=(V,E)$ be a weighted digraph and let $s\in V$ be a source vertex. Let $d$ be a positive integer. An out-tree $T\subseteq G$ is called a $(1+\epsilon)$-approximate shortest path tree from $s$ up to depth $d$, if $T$ is rooted at $s$ and for any $v\in V$ such that $\delta^{d}_{G}(s,v)<\infty$, we have $v\in V(T)$ and $\delta_{T}(s,v)\leq(1+\epsilon)\delta^{d}_{G}(s,v)$.

Definition 5.2**.**

Let $G=(V,E)$ be directed and let $d>0$ be an integer. A set $H_{d}^{\epsilon}\subseteq V$ is called an $(1+\epsilon)$-approximate $d$-hub set of $G$ if for every $u,v\in V$ such that $\delta_{G}(u,v)<\infty$, there exists a path $P=u\to v$ in $G$ such that $\ell(P)\leq(1+\epsilon)\delta_{G}(u,v)$ and $P$ is $(H_{d}^{\epsilon},d)$-covered.

We also extend the definition of a $(T,d)$-blocker set to trees of depth more than $d$.

Definition 5.3**.**

Let $V$ be a vertex set and let $d>0$ be an integer. Let $T$ be a rooted tree over $V$. Define $T^{d}$ to be the set of all maximal subtrees of $T$ of depth no more than $d$, rooted in non-leaf vertices $x\in V(T)$ satisfying $d\mid\mathrm{dep}_{T}({x})$. In other words, the set $T^{d}$ can be obtained from the tree $T$ be repeatedly taking a deepest non-leaf vertex $x$ of $T$ such that $\mathrm{dep}_{T}({x})$ is divisible by $d$, inserting the subtree of $T$ rooted in $x$ into $T^{d}$ and consequently removing all the descendants of $x$ out of $T$.

Then, $B$ is a $(T,d)$-blocker set if and only if it is a $(T^{d},d)$-blocker set (in terms of Definition 2.5). Let $\mathcal{T}$ be a collection of rooted trees over $V$. We call $B$ a $(\mathcal{T},d)$-blocker set if and only if $B$ is a $(T,d)$-blocker for each $T\in\mathcal{T}$.

We now state the main theorem relating blocker sets in $(1+\epsilon)$-approximate shortest path trees to the approximate hub sets. The theorem is proved in Section 5.1.

Theorem 5.4**.**

Let $G=(V,E)$ be a directed graph and let $d<n$ be an even integer. Let $\mathcal{T}^{\mathrm{from}}=\{T^{\mathrm{from}}_{v}:v\in V\}$ ($\mathcal{T}^{\mathrm{to}}=\{T^{\mathrm{to}}_{v}:v\in V\}$) be a collection of $(1+\epsilon)$-approximate shortest path trees up to depth-$3d$ from all vertices in $G$ (in $G^{\mathrm{R}}$, resp.).

Let $B\subseteq V$ be a $(\mathcal{T}^{\mathrm{from}}\cup\mathcal{T}^{\mathrm{to}},\frac{d}{2})$-blocker set. Then $B$ is a $(1+\epsilon)^{p}$-approximate $2dp$-hub set of $G$, where $p=\lceil\log_{2}{n}\rceil+1$.

Finally, we explain how to incorporate these tools into our improved dynamic APSP algorithms in order to generalize then to weighted graphs. Recall that our reliable hubs maintenance algorithms for unweighted graphs essentially maintained some shortest path trees up to depth $d$ and either computed their blocker sets using King‘s algorithm, or dynamically verified whether the sampled hub sets remain blocker sets of the shortest path trees.

We first replace all shortest path trees up to depth $d$ with $(1+\epsilon)$-approximate shortest path trees up to depth $d$. We use the following extension of Bernstein‘s $h$-SSSP algorithm.

Lemma 5.5**.**

The $h$-SSSP algorithm of Theorem 2.4 can be extended so that it maintains a $(1+\epsilon)$-approximate shortest path tree up to depth $h$ from $s$ within the same time bound.

Proof.

The $h$-SSSP data structure (see [5]) actually maintains $O(\log(nW))$ $h$-SSSPk data structures, handling different ranges of the distances to be estimated. For each $k=0,\ldots,\lfloor\log_{2}{nW}\rfloor$, the $h$-SSSPk data structure maintains an out-tree $T_{k}\subseteq G$ rooted at $s$, such that for all $v\in V$, if $2^{k}\leq\delta_{G}^{d}(s,v)\leq 2^{k+1}$, then $v\in V(T_{k})$ and $\delta_{G}(s,v)\leq\delta_{T_{k}}(s,v)\leq(1+\epsilon)\delta_{G}^{d}(s,v)$. The final $(1+\epsilon)$-approximate estimate $\delta^{\prime}(s,v)$ of $\delta_{G}^{d}(s,v)$ produced by $h$-SSSP is defined as $\delta^{\prime}(s,v)=\min_{k}\{\delta_{T_{k}}(s,v):v\in V(T_{k})\}$. Even though each $h$-SSSPk has total update time $O(mh/\epsilon+\Delta)$, Bernstein [5] uses additional data structures and tricks to make different $h$-SSSPk components register only relevant edge updates and make the dependence on $\Delta$ only $O(\Delta)$.

Nevertheless, all $h$-SSSPk components maintain their trees $T_{k}$ explicitly in the stated $O(mh/\epsilon\log{n}\log{nW}+\Delta)$ total time. Having a single out-tree instead of $\lfloor\log{nW}\rfloor+1$ will simplify our further developments considerably. Therefore, we combine these trees $T_{k}$ into a single $(1+\epsilon)$-approximate shortest path tree $T$ up to depth $d$ from $s$, as follows.

The $h$-SSSP algorithm [5] has an additional property that it explicitly maintains, for each vertex $v\neq s$, both the value $\delta^{\prime}(s,v)$ and the index $k_{v}$ of the tree $T_{k_{v}}$ such that $\delta^{\prime}(s,v)=\delta_{T_{k_{v}}}(s,v)=\min_{k}\{\delta_{T_{k}}(s,v):v\in V(T_{k})\}$. Whenever $k_{v}$ is updated for some $v$, we make $\mathrm{par}_{T_{k_{v}}}(v)$ the new parent of $v$ in $T$ and the edge $\mathrm{par}_{T_{k_{v}}}(v)v=e\in E(T_{k_{v}})$ the only incoming edge of $v$ in $T$. When $\delta^{\prime}(s,v)$ becomes $\infty$, $v$ is removed from $T$.

We first prove that by proceeding this way, $T$ actually remains a tree, or, in other words, the edges of the form $\mathrm{par}_{T}(v)v$, where $v\in V(T)\setminus\{s\}$, form an out-tree that is a subgraph of $G$. Since each vertex in $T$ except of $s$ (which has [math] outgoing edges) has exactly one incoming edge, we only need to prove that $T$ has no directed cycles. For contradiction, suppose there is a cycle $e_{1}\ldots e_{k}$ in $T$, where $e_{i}=u_{i}u_{i+1}$, $u_{k+1}=u_{1}$ and $u_{i}=\mathrm{par}_{T}(u_{i+1})$ for all $i=1,\ldots k$. Consider some edge $e_{i}$. We have $u_{i}=\mathrm{par}_{T}(u_{i+1})=\mathrm{par}_{T_{k_{u_{i+1}}}}(u_{i+1})$ and hence $\delta^{\prime}(s,u_{i+1})=\delta_{T_{k_{u_{i+1}}}}(s,u_{i+1})=\delta_{T_{k_{u_{i+1}}}}(s,u_{i})+w_{T_{k_{u_{i+1}}}}(u_{i}u_{i+1})$ for some $l$. Recall that $G$ has positive edge weights and $T_{k_{u_{i+1}}}\subseteq G$. As a result $\delta^{\prime}(s,u_{i+1})>\delta_{T_{k_{u_{i+1}}}}(s,u_{i})\geq\delta^{\prime}(s,u_{i})$. This way we obtain $\delta^{\prime}(s,u_{1})=\delta^{\prime}(s,u_{k+1})>\delta^{\prime}(s,u_{k})>\ldots>\delta^{\prime}(s,u_{1})$, a contradiction.

Second, we prove that for all $v\in V(T)$ we have $\delta_{T}(s,v)\leq\delta^{\prime}(s,v)$. We proceed by induction on $\mathrm{dep}_{T}({v})$. If $s=v$, this is clearly true. Otherwise, let $\mathrm{dep}_{T}({v})>0$ and suppose the claim holds for all vertices of $T$ of smaller depth. Let $p=\mathrm{par}_{T}(v)$. By the inductive hypothesis, we have $\delta_{T}(s,p)\leq\delta^{\prime}(s,p)$. By the definition of $T$, we also have $p=\mathrm{par}_{T_{k_{v}}}(v)$ and $w_{T}(p,v)=w_{T_{k_{v}}}(p,v)$. Hence,

[TABLE]

Finally, note that as the $h$-SSSP algorithm guarantees that $\delta^{\prime}(s,v)\leq(1+\epsilon)\delta_{G}^{d}(s,v)$, we also have $\delta_{T}(s,v)\leq(1+\epsilon)\delta_{G}^{d}(s,v)$. Clearly, as $T\subseteq G$, for all $v\in V(T)$ we have $\delta_{T}(s,v)\geq\delta_{G}(s,v)$. ∎

By Theorem 5.4, by finding blocker sets of approximate shortest path trees (as in Definition 5.3), we can compute/verify $(1+\epsilon^{\prime})^{\Theta(\log{n})}$-approximate $\Theta(d\log{n})$-hub sets as before.

Given appropriate hub sets, all that both our deterministic incremental $(1+\epsilon)$-approximate APSP algorithm, and Bernstein‘s randomized $(1+\epsilon)$-approximate partially dynamic APSP algorithm do, is essentially set up and maintain a ’’circuit‘‘ (i.e., a collection of data structures whose outputs constitute the inputs of other structures) of $h$-SSSP data structures from the hubs with different parameters $h$ and appropriately set $\epsilon^{\prime}$. In order to make these algorithms work with our reliable approximate hub sets, we basically need to play with the parameters: increase all $h$‘s by a polylogarithmic factor, and decrease $\epsilon^{\prime}$ by a polylogarithmic factor. We discuss the details in Appendix C.

5.1 Proof of Theorem 5.4

Lemma 5.6**.**

Let $T$ be a rooted tree over $V$. Let $d$ be a positive integer and suppose $B\subseteq V$ is a $(T,d)$-blocker set (with respect to Definition 5.3). Then for any $v\in V(T)$, the path ${T}[{v}]$ is $(B,2d)$-covered.

Proof.

By the definition of $B$, ${T}[{v}]$ can be expressed as $P_{1}\ldots P_{k}$, $P_{i}=u_{i}\to v_{i}$, where $|P_{i}|=d$ and $V(P_{i})\cap B\neq\emptyset$ for $i=1,\ldots,k-1$ and $|P_{k}|\leq d$. This is because each for such $i$ we have $d\mid\mathrm{dep}_{T}({u_{i}})$ and $P_{i}$ is a root-leaf path in some tree of the set $T^{d}$ obtained from $T$ using Definition 5.3. Since each $P_{i}$ is trivially $(B,d)$-covered and $P_{k}$ is the only subpath that may not contain a vertex of $B$, by Lemma 2.8 we conclude that ${T}[{v}]$ is indeed $(B,2d)$-covered. ∎

Lemma 5.7**.**

Let $G=(V,E)$ be a directed graph and let $d>0$ be an even integer. Let $H\subseteq V$. Let $\mathcal{T}^{\mathrm{from}}=\{T^{\mathrm{from}}_{v}:v\in H\}$ ($\mathcal{T}^{\mathrm{to}}=\{T^{\mathrm{to}}_{v}:v\in H\}$) be a collection of $(1+\epsilon)$-approximate shortest path trees up to depth-$3d$ from $H$ in $G$ (in $G^{\mathrm{R}}$, resp.).

Let $B\subseteq V$ be a $(\mathcal{T}^{\mathrm{from}}\cup\mathcal{T}^{\mathrm{to}},\frac{d}{2})$-blocker set. Then, for any path $P=u\to v$ in $G$ that is $(H,d)$-covered and integer $j\geq 0$, if $|P|\leq 2^{j}d$, then there exists a path $P^{\prime}=u\to v$ in $G$ such that $\ell(P^{\prime})\leq(1+\epsilon)^{j}\cdot\ell(P)$ and $P^{\prime}$ is $(B,2d(j+1))$-covered.

Proof.

We proceed by induction on $j$. For $j=0$, $j+1=2^{j}$ so $P^{\prime}=P$ has the required properties since $P$ has no more than $d\leq 2d$ edges.

Let $j>0$ and suppose the lemma holds for all $j^{\prime}<j$. If $|P|\leq d\cdot 2^{j-1}$, then $P^{\prime}$ exists by the inductive hypothesis. Assume $|P|>d\cdot 2^{j-1}=d$.

By Lemma 4.5, we can partition $P$ into $s\geq 1$ subpaths $P_{1},\ldots,P_{s}$, where $P_{i}=u_{i}\to v_{i}$, such that $|P_{i}|\in[d,3d]$ for all $i=1,\ldots,s$ and $u_{i}\in H$ for all $i=2,\ldots,s$.

Since $P_{i}$ has no more than $3d$ edges, for each $i\in\{2,\ldots,s\}$ we have

[TABLE]

whereas for $i=1$ we have

[TABLE]

For $i=1$, let $Q_{1}=({T^{\mathrm{to}}_{v_{1}}}[{u_{1}}])^{\mathrm{R}}$, whereas for $i=2,\ldots,s$, set $Q_{i}={T^{\mathrm{from}}_{u_{i}}}[{v_{i}}]$. Then we clearly have $\ell(Q_{i})\leq(1+\epsilon)\ell(P_{i})$ for all $i$.

Let $Q_{1}^{\prime},\ldots,Q_{r}^{\prime}$ be a partition of $Q_{1}\ldots Q_{s}$ into blocks, i.e., $Q_{i}^{\prime}=Q_{t_{i}}Q_{t_{i}+1}\ldots Q_{t_{i+1}-1}$, where $1=t_{1}<t_{2}<\ldots<t_{r}<t_{r+1}=s+1$, such that:

• •

If $|Q_{i}|\geq\frac{d}{2}$, then $Q_{i}$ forms a single-element block $Q_{z}^{\prime}$. In other words, for some $z$, $t_{z}=i$ and $t_{z+1}=i+1$.

• •

If $Q_{x},\ldots,Q_{y}$ is a maximal set of paths such that for all $g\in[x,y]$, we have $|Q_{g}|<\frac{d}{2}$, then $Q_{x},\ldots,Q_{y}$ form a single block $Q_{z}^{\prime}$. In other words, for some $z$, $t_{z}=x$ and $t_{z+1}=y+1$.

We now set $P^{\prime}=Q_{1}^{\prime\prime}Q_{2}^{\prime\prime}\ldots Q_{r}^{\prime\prime}$, where each $Q_{z}^{\prime\prime}$, for $z=1,\ldots,r$, is defined as follows.

• •

If $Q_{z}^{\prime}=Q_{i}$, where $|Q_{i}|\geq\frac{d}{2}$, then $Q_{z}^{\prime\prime}=Q_{z}^{\prime}=Q_{i}$. Note that by Lemma 5.6, $Q_{z}^{\prime\prime}$ is $(B,d_{z})$-covered, where $d_{z}=2\cdot\frac{d}{2}=d$. Moreover, since $|Q_{z}|\geq\frac{d}{2}$, $Q_{z}^{\prime\prime}$ necessarily contains a vertex from $B$.

• •

If $Q_{z}^{\prime}=Q_{t_{z}}\ldots Q_{t_{z+1}-1}$, where for each $g\in[t_{z},t_{z+1}-1]$, $|Q_{g}|<\frac{d}{2}$, then $|Q_{z}^{\prime}|\leq\frac{|P|}{2}\leq d\cdot 2^{j-1}$. Since $Q_{z}^{\prime}$ is a concatenation of paths of length less than $\frac{d}{2}$, each of which has a vertex of $H$ as its endpoint, by Lemma 2.8 $Q_{z}^{\prime}$ is $(H,d)$-covered. Hence, we can apply the inductive hypothesis to $Q_{z}^{\prime}$: there exists a path $Q_{z}^{\prime\prime}=u_{t_{z}}\to v_{t_{z+1}-1}$ such that $\ell(Q_{z}^{\prime\prime})\leq(1+\epsilon)^{j-1}\cdot\ell(Q_{z}^{\prime})$ and $Q_{z}^{\prime\prime}$ is $(B,d_{z})$-covered, where $d_{z}=2dj$.

By Lemma 2.8, $P^{\prime}$ is $(B,D)$-covered, where

[TABLE]

We now prove that $D\leq 2d(j+1)$. Let $x,z$ be such that $1\leq x\leq z\leq r$ and $V(Q_{y}^{\prime\prime})\cap B=\emptyset$ for all $y\in(x,z)$. If $(x,z)\cap\mathbb{Z}=\emptyset$, then $z\leq x+1$. Otherwise, let $g\in(x,z)\cap\mathbb{Z}$. Observe that $V(Q_{g}^{\prime\prime})\cap B=\emptyset$ can only hold if $Q_{g}^{\prime\prime}$ is a maximal set of consecutive paths $Q_{i}$, $i\leq r$, with less than $\frac{d}{2}$ edges each. Hence, by the aforementioned maximality, $V(Q_{g-1}^{\prime\prime})\cap B\neq\emptyset$ and $V(Q_{g+1}^{\prime\prime})\cap B\neq\emptyset$. We thus have $x\geq g-1$ and $y\leq g+1$. Consequently, we obtain $z\leq x+2$ and from $g\in(x,y)$ we obtain $z=x+2$ and $g=x+1$. We clearly have $d_{x}+d_{x+1}+d_{x+2}=d_{x}+d_{g}+d_{z}=d+2dj+d=2d(j+1)$.

Observe now that among at most two consecutive paths $Q_{i}^{\prime\prime}$, there can be at most one maximal set of consecutive paths $Q_{i}$, $i\leq r$, with less than $\frac{d}{2}$ edges each. Therefore, $d_{x}+d_{x+1}\leq 2dj+d\leq 2d(j+1)$ for any $x\leq r$.

It remains to prove that $\ell(P^{\prime})\leq(1+\epsilon)^{j}\ell(P)$. We have:

[TABLE]

Corollary 5.8**.**

Let $G=(V,E)$ be a directed graph and let $d>0$ be an even integer. Let $H_{d}^{\epsilon}$ be a $(1+\epsilon)^{q}$-approximate $d$-hub set of $G$.

Let $\mathcal{T}^{\mathrm{from}}=\{T^{\mathrm{from}}_{v}:v\in H_{d}^{\epsilon}\}$ ($\mathcal{T}^{\mathrm{to}}=\{T^{\mathrm{to}}_{v}:v\in H_{d}^{\epsilon}\}$) be a collection of $(1+\epsilon)$-approximate shortest path trees up to depth-$3d$ from vertices of $H_{d}^{\epsilon}$ in $G$ (in $G^{\mathrm{R}}$, resp.).

Let $B\subseteq V$ be a $(\mathcal{T}^{\mathrm{from}}\cup\mathcal{T}^{\mathrm{to}},\frac{d}{2})$-blocker set. Then $B$ is a $(1+\epsilon)^{p+q-1}$-approximate $2dp$-hub set of $G$, where $p=\lceil\log_{2}{n}\rceil+1$.

Proof.

To prove that $B$ is in fact a $(1+\epsilon)^{p+q-1}$-approximate $2dp$-hub set for $G$, let $u,v\in V$ be such that $\delta_{G}(u,v)<\infty$ and take any path $P$ from $u$ to $v$ that is $(H_{d}^{\epsilon},d)$-covered and $\ell(P)\leq(1+\epsilon)^{q}\delta_{G}(u,v)$. As $|P|\leq n$ and $d\geq 1$, $P$ clearly has less than $d2^{p-1}$ edges.

Therefore, by Lemma 5.7 (for $H=H^{\epsilon}_{d}$), there exists a path $P^{\prime}=u\to v$ in $G$ such that $\ell(P^{\prime})\leq(1+\epsilon)^{p-1}\ell(P)\leq(1+\epsilon)^{p+q-1}\delta_{G}(u,v)$ and $P^{\prime}$ is $(B,2dp)$-covered. ∎

In order to prove Theorem 5.4, just apply Corollary 5.8 with $q=1$.

Appendix A Deterministic Incremental Algorithm for Dense Graphs

Let us focus on the restricted version of the problem – this assumption can be dropped by applying Lemma 2.1. So, $\Delta=O(n^{2}\log{W}/\epsilon)$.

Let use $k=\lceil\log_{2}n\rceil$ layers of $n$ $h$-SSSP data structures (see Theorem 2.4) with $h=2$. Let $\epsilon_{1}=\epsilon/2k$. For $i=1,\ldots,k$, and $v\in V$ the data structure $D_{i,v}$ will maintain distance estimates $\delta^{\prime}_{i,v}(w)$, satisfying

[TABLE]

Clearly, since $\delta^{2^{k}}_{G}(v,w)=\delta_{G}(v,w)$ for all $v,w\in V$, data structures $D_{k,v}$ will maintain $(1+\epsilon_{1})^{k}\leq(1+\epsilon)$ approximate distances from $v$ to all other vertices.

We achieve that by making setting up $D_{i,v}$ to be a $h$-SSSP data structure with $h=2$ run from $v$ on:

• •

either the input graph $G$ if $i=1$,

• •

or a complete graph $G_{i}$ on $V$ with edge weights equal to the estimates produced by the previous layer, i.e., $w_{G_{i}}(uv)=\delta^{\prime}_{i-1,u}(v)$.

Then, inequality (1) follows easily by induction.

Recall that for dense graphs, the $h$-SSSP algorithm [5] runs in $O(n^{2}h\log{n}\log{(nW)}/\epsilon+\Delta)$ time and updates some of its estimates $O(nh\log{(nW)}/\epsilon)$ times. In our case, whenever $D_{i-1,u}$ updates $\delta^{\prime}_{i-1,u}(v)=w_{G_{i}}(uv)$, we send that update to all data structures $D_{i,\cdot}$ run on $G_{i}$. Let $\Delta_{i,v}$ be the number of times $D_{i,v}$ updates some of its estimates. Then, $\Delta_{i,v}=O(n\log{(nW)}/\epsilon_{1})$ and thus the total running time of the algorithm can be seen to be

[TABLE]

Appendix B Details of the State-Of-the-Art Decremental APSP Algorithms

B.1 The Algorithm of Baswana et al. [4] Given Hub Sets

The algorithm of Baswana et al. [4] explicitly maintains the matrix of pairwise distances between the vertices of an unweighted digraph under edge deletions in $O(n^{3}\log^{2}{n})$ total time. The algorithm is Monte Carlo randomized. Below we briefly describe how to turn it into a Las Vegas algorithm running in time $O(n^{3}\log^{2}{n}+nm\log^{3}{n})=O(n^{3}\log^{3}{n})$.

Let the sets $A_{0},\ldots,A_{q}$ be defined as before (i.e., $a_{i}=6^{q-i}$). The algorithm of Baswana et al. [4] can be rephrased using our terminology as follows. The set $A_{i}$ is used to maintain the values $\delta_{i}^{\prime}(u,v)$ such that $\delta_{i}^{\prime}(u,v)\geq\delta(u,v)$ and additionally $\delta_{i}^{\prime}(u,v)=\delta(u,v)$ if $\delta(u,v)\in[t_{i}+1,t_{i+1}]$. The thresholds $t_{i}$ are defined as follows: $t_{0}=-1$, $t_{i}=\min(d_{i},n-1)$ for $i=1,\ldots,q$ and $t_{q+1}=n-1$.

Clearly, the intervals $[t_{i}+1,t_{i+1}]$ cover the entire range $[0,n-1]$ of possible distances, so for any $u,v\in V$ we have $\min_{i=0}^{q}\{\delta^{\prime}_{i}(u,v)\}=\delta(u,v)$.

It remains to show how to maintain the values $\delta^{\prime}_{i}(u,v)$. For each $i=0,\ldots,q$ and $v\in A_{i}$ we maintain shortest path trees $T^{\mathrm{from}}_{i,v}$ and $T^{\mathrm{to}}_{i,v}$ up to depth $t_{i+1}$ in $G$ and $G^{\mathrm{R}}$, respectively. We keep each $\delta^{\prime}_{i}(u,v)$ equal to

[TABLE]

To see that this is correct, note that since $A_{0}=V$ and $A_{i}$ is a $d_{i}$-hub set, then for each $u,v$ such that $\delta(u,v)\in[t_{i}+1,t_{i+1}]$, $\delta(u,v)>d_{i}$ and hence there exists some shortest $P=u\to v$ path that goes through some vertex of $a\in A_{i}$. Equivalently, $P=P_{1}P_{2}$, where $P_{1}=u\to a$ and $P_{2}=a\to v$ and both $P_{1}$ and $P_{2}$ are shortest and $|P_{i}|\leq|P|\leq t_{i+1}$. Consequently, $|P|=|P_{1}|\cup|P_{2}|=\delta_{T^{\mathrm{to}}_{i,a}}(a,u)+\delta_{T^{\mathrm{from}}_{i,v}}(a,v)$.

To keep $\delta^{\prime}_{i}(u,v)$ updated, whenever some $\delta_{T^{\mathrm{to}}_{i,a}}(a,u)$ (or $\delta_{T^{\mathrm{from}}_{i,v}}(a,v)$) changes we go through all $v\in V$ ($u\in V$, resp.), and set $\delta^{\prime}_{i}(u,v):=\min(\delta^{\prime}_{i}(u,v),\delta_{T^{\mathrm{to}}_{i,a}}(a,u)+\delta_{T^{\mathrm{from}}_{i,v}}(a,v))$. Observe that each $\delta_{T^{\mathrm{to}}_{i,a}}(a,u)$ (similarly ($\delta_{T^{\mathrm{from}}_{i,v}}(a,v)$) changes at most $t_{i+1}=O(d_{i})$ times and each such changes is followed by a computation that runs in $O(n)$ time. The total time needed for updating the values $\delta^{\prime}_{i}(u,v)$ (apart from maintaining the trees themselves) is hence

[TABLE]

The total time needed to maintain the needed shortest path trees is also

[TABLE]

Combining with our hub set verification procedure, we obtain a Las Vegas algorithm running in $O(n^{3}\log^{2}{n}+mn\log^{3}{n})$ time with high probability.

B.2 The Algorithm of Bernstein [5] Given Hub Sets

Bernstein [5] showed that $(1+\epsilon)$-approximate distance estimates between all pairs of vertices of an unweighted101010Bernstein [5] showed that even for weighted graphs, but in this section we concentrate on the unweighted case. We explain the modifications needed for the weighted version in Section 5. digraph $G$ subject to partially dynamic updates can be maintained in $O(mn\log^{5}{n}/\epsilon)$ total time. The algorithm is Monte Carlo randomized and assumes an oblivious adversary.

Given the sets $A_{0},\ldots,A_{q}$, the algorithm works as follows. For each subsequent $i=q,\ldots,0$, for $(u,v)\in(A_{i}\times V)\cup(V\times A_{i})$ it maintains estimates $\delta^{\prime}_{i}(u,v)$ satisfying

[TABLE]

For $i=q$, the values $\delta^{\prime}_{q}(u,v)$ are maintained using $h$-SSSP data structures of Theorem 2.4 run on $G$ and $G^{\mathrm{R}}$ from the only vertex of $A_{q}$ for $h=n$. This takes $O(mn\log^{2}{n}/\epsilon^{\prime})$ time.

For $i<q$ on the other hand, the distance estimates $\delta_{i}^{\prime}(u,\cdot)$ and $\delta^{\prime}_{i}(\cdot,u)$, where $u\in A_{i}$, are maintained using $h$-SSSP data structures of Theorem 2.4 run for $h=d_{i+1}+1$ on $G_{i,u}$ and $G_{i,u}^{\mathrm{R}}$, where $G_{i,u}=G\cup S_{i,u}$, $S_{i,u}=(V,\{uv:v\in A_{i+1}\})$, and $w_{S_{i,u}}(uv)=\delta^{\prime}_{i+1}(u,v)$. Using the assumption that $\delta^{\prime}_{i+1}(x,y)\leq(1+\epsilon^{\prime})^{q-i}\delta_{G}(x,y)$ which holds for $x\in V$ and $y\in A_{i+1}$, one can show that $\delta_{G_{i,u}}^{d_{i+1}+1}(u,v)\leq(1+\epsilon^{\prime})^{q-i}\delta_{G}(u,v)$ for $v\in V$ and hence $\delta^{\prime}_{i}(u,v)\leq(1+\epsilon^{\prime})^{q-i+1}\delta_{G}(v,u)$. Consequently, the total cost of maintaining estimates $\delta_{i}^{\prime}(u,\cdot)$ and $\delta_{i}^{\prime}(\cdot,u)$ is $O(a_{i}\cdot d_{i+1}m\log^{2}{n}/\epsilon^{\prime})$. As we set $a_{i}=6^{q-i}$ and we have $d_{i+1}=O(n/a_{i})$, this total cost is in fact $O(nm\log^{3}{n}/\epsilon^{\prime})$.

In total, as $q=O(\log{n})$ and we set $\epsilon^{\prime}=\Theta(\epsilon/\log{n})$, the total update time is $O(nm\log^{5}{n}/\epsilon)$. Hence, combining Bernstein‘s algorithm with our verification procedure yields a Las Vegas algorithm with asymptotically the same running time with high probability.

Appendix C Using Reliable Hubs in Algorithms for Weighted Digraphs

C.1 Deterministic Incremental APSP

In order to adjust the data structure of Section 3 so that it supports edge weights, we do the following. Assume wlog. that we solve the restricted problem (see Section 2). First, instead of maintaining exact shortest paths between nearby vertices in $G$, we maintain collections $\mathcal{T}^{\mathrm{from}}$ and $\mathcal{T}^{\mathrm{to}}$ of $(1+\epsilon^{\prime})$-approximate shortest path trees up to depth-$3d$ from all vertices of $V$ in $G$ and $G^{\mathrm{R}}$ respectively. To this end, we use data structures of Theorem 2.4. Consequently, the total time spent in this component is $O(mnd\log{n}\log{(nW)}/\epsilon^{\prime})$, as only $O(m\log{W}/\epsilon^{\prime})$ updates are issued to any $h$-SSSP data structure maintaining the approximate shortest path trees.

Next, the $d$-hub set $H_{d}$ is replaced with a $(1+\epsilon^{\prime})^{p}$-approximate $d^{\prime}$-hub set $H_{d^{\prime}}$, also of size $O(\frac{n}{d}\log{n})$, where $d^{\prime}=\Theta(d\log{n})$ and $p=\Theta(\log{n})$. By Theorem 5.4, such a hub set can be computed deterministically at the beginning of each phase in $O(n^{2}\log{n})$ time using Lemma 2.6. An analogue of Lemma 3.1 also holds for approximate hub sets and therefore whenever $uv$ is added to the graph of the weight of $uv$ is decreased, $\{u,v\}$ is added to $H_{d^{\prime}}^{\epsilon}$.

The approximate shortest paths between the hubs are maintained analogously as in Section 3, also using Theorem 2.11, in O\mathopen{}\mathclose{{}\left(\frac{md}{n\log{n}}|H_{d^{\prime}}|^{3}\log^{3}{n}\log{(nW)}/\epsilon^{\prime}}\right)=O\mathopen{}\mathclose{{}\left(m\mathopen{}\mathclose{{}\left(\frac{n}{d}}\right)^{2}\log^{5}{n}\log{(nW)}/\epsilon^{\prime}}\right) total time. However, since $H_{d^{\prime}}$ is now only a $(1+\epsilon^{\prime})^{p}$-approximate $d^{\prime}$-hub set, we need to explicitly maintain the estimates of distances $\delta_{G}^{d^{\prime}}(u,v)$ for $u,v\in H_{d^{\prime}}$ (the algorithm already maintains approximate shortest path trees up to depth $3d$, but $d^{\prime}=\Theta(d\log n)$.) For this, we need $O(n)$ data structures of Theorem 2.4, run with $h=d^{\prime}$. Throughout the whole update sequence, these data structures require $O(mnd^{\prime}\log{n}\log{(nW)}/\epsilon^{\prime})=O(mnd\log^{2}{n}\log{(nW)}/\epsilon^{\prime})$ time. Observe that this component produces $(1+\epsilon^{\prime})$-approximate distance estimates between pairs of hubs $H_{d^{\prime}}$.

The remaining two components producing the estimates between $H_{d^{\prime}}\times V$ and subsequently $V\times V$, are also analogous to those in Section 3. The only change is that $H_{d^{\prime}}$ is now a $(1+\epsilon)^{p}$-approximate $d^{\prime}$-hub set, instead of an (exact) $d$-hub set, so the parameter $h$ in the used data structures of Theorem 2.4 needs to be appropriately increased. The total time used by these components is again $O(mnd\log^{2}{n}\log{(nW)}/\epsilon^{\prime})$. The final estimates are $(1+\epsilon^{\prime})^{p+4}$-approximate, so we set $\epsilon^{\prime}=\epsilon/(2p+8)$ in order to obtain $(1+\epsilon)$-approximate distance estimates.

Theorem C.1**.**

*Let $G$ be a weighted directed graph. There exists a deterministic incremental algorithm maintaining $(1+\epsilon)$-approximate distance estimates between all pairs of vertices of $G$ in $O(mn^{4/3}\log^{4}{n}\log{(nW)}/\epsilon+\Delta)$ total time. *

Proof.

The total update time is

[TABLE]

Hence, the described algorithm solving the restricted version of the problem is asymptotically the most efficient if $d=n^{1/3}\log{n}$. By applying Lemma 2.1, we obtain the desired bound. ∎

C.2 Bernstein‘s Partially-Dynamic APSP

Let $\alpha=2(\lceil\log_{2}{n}\rceil+1)$ and set $q=\lceil\log_{\alpha}{n}\rceil$. Let $a_{0}=n$ and $a_{i}=\alpha^{q-i}$ for $i=1,\ldots,q$. By increasing $n$ by at most a factor of $2$, we may assume that $a_{i+1}\mid a_{i}$ for all $i>1$. Again $p=\lceil\log_{2}{n}\rceil+1$, so $\alpha=2p$. Similarly as in Section 4, let $A_{i}$ be a random $a_{i}$-subset of $V$ and let $d_{i}=z\cdot\frac{n}{a_{i+1}}\lceil\ln{n}\rceil$, where $z$ is such a constant that, with high probability, $A_{i}$ is a $(\mathcal{T},z\cdot\frac{n}{2a_{i}}\lceil\ln{n}\rceil)=(\mathcal{T},\frac{d_{i-1}}{2})$-blocker set for any fixed collection $\mathcal{T}$ of trees over $V$ such that $|\mathcal{T}|=O(mn/\epsilon^{\prime})$, where $\epsilon^{\prime}$ is to be set later.

We proceed similarly as in Section 4, and maintain, for each $i=1,\ldots,q$, collections $\mathcal{T}^{\mathrm{from}}_{i}$ and $\mathcal{T}^{\mathrm{to}}_{i}$ of depth-$3d_{i-1}$ $(1+\epsilon^{\prime})$-approximate shortest path trees from all vertices of $A_{i-1}$ in both $G$ and $G^{\mathrm{R}}$. We now prove that as long as $A_{i}$ remains a $(\mathcal{T}^{\mathrm{from}}_{i}\cup\mathcal{T}^{\mathrm{to}}_{i},\frac{d_{i-1}}{2})$-blocker set, it is a $(1+\epsilon^{\prime})^{ip}$-approximate $d_{i}$-hub set of both $G$ and $G^{\mathrm{R}}$.

Clearly, since $A_{0}=V$, $A_{0}$ is a $(1+\epsilon^{\prime})^{0}$ approximate $d_{0}$ hub set of both $G$ and $G^{\mathrm{R}}$. Now suppose $i\geq 1$. We apply Corollary 5.8 with $H^{\epsilon}_{d}=A_{i-1}$, $q=(i-1)p$, $d=d_{i-1}$, $\mathcal{T}^{\mathrm{from}}=\mathcal{T}^{\mathrm{from}}_{i}$, $\mathcal{T}^{\mathrm{to}}=\mathcal{T}^{\mathrm{to}}_{i}$, and $B=A_{i}$, and obtain that $A_{i}$ is a $(1+\epsilon^{\prime})^{p+(i-1)p}=(1+\epsilon^{\prime})^{ip}$-approximate $2d_{i-1}p=d_{i}p\cdot\frac{2a_{i+1}}{a_{i}}=d_{i}\frac{2p}{\alpha}=d_{i}$-hub set of both $G$ and $G^{\mathrm{R}}$.

If we additionally store the individual trees of $\mathcal{T}^{\mathrm{from}}_{i}\cup\mathcal{T}^{\mathrm{to}}_{i}$ in data structures of Lemma 4.4 (first splitting the trees into maximal subtrees of depth $\frac{d_{i-1}}{2}$, as in Definition 5.3), then the hub sets $A_{i}$ can be verified in

[TABLE]

total time.

Let $x_{i}$ be such that Bernstein‘s algorithm maintains the $(1+\epsilon^{\prime})^{x_{i}}$-approximate distance estimates $\delta^{\prime}_{i}(u,v)$ for $(u,v)\in(A_{i}\times V)\cup(V\times A_{i})$ using the $(1+\epsilon^{\prime})^{x_{i+1}}$-approximate distance estimates $\delta^{\prime}_{i+1}(\cdot,\cdot)$ and the $(1+\epsilon^{\prime})^{(i+1)p}$-approximate hub set $A_{i+1}$. One can easily show that the estimates $\delta^{\prime}_{i}(\cdot,\cdot)$ are in fact $(1+\epsilon^{\prime})^{x_{i+1}+(i+1)p+1}$-approximate. Hence, we have $x_{q}=1$ and $x_{i}=x_{i+1}+(i+1)p+1$ for all $i<q$, so we conclude that $x_{i}=1+\sum_{j=i+1}^{q}jp$ and therefore $x_{0}=\Theta(q^{2}p)$. Consequently, the final estimates are $(1+\epsilon^{\prime})^{\Theta(q^{2}p)}=(1+\epsilon^{\prime})^{\Theta(\log^{3}{n})}$-approximate.

Recall from Section B.2, that given hub sets, Bernstein‘s algorithm runs in

[TABLE]

total time. By setting $\epsilon^{\prime}=\Theta(\epsilon/\log^{3}{n})$, we get $O(nm\log^{8}{n}\log{(nW)}/\epsilon+\Delta)$ total update time with high probability. We have thus proved the following theorem.

Theorem C.2**.**

Let $G$ be a weighted directed graph. There exists a partially-dynamic algorithm maintaining $(1+\epsilon)$-approximate distance estimates between all pairs of vertices of $G$ in $O(mn\log^{8}{n}\log{(nW)}/\epsilon+\Delta)$ total time. The algorithm is Las Vegas randomized and assumes an oblivious adversary.