Constant Girth Approximation for Directed Graphs in Subquadratic Time

TL;DR

This paper introduces faster algorithms for approximating the girth of directed graphs, achieving constant-factor approximations in subquadratic time, surpassing previous methods that relied on All-Pairs Shortest Paths computations.

Contribution

The paper presents the first subquadratic time algorithms for constant-factor girth approximation in directed graphs, including deterministic and trade-off algorithms improving upon prior randomized methods.

Findings

First sub-APSP-time algorithm for girth approximation.

Deterministic algorithm with improved approximation factor.

Trade-off algorithm balancing time complexity and approximation quality.

Abstract

In this paper we provide a $\tilde{O}(m\sqrt{n})$ time algorithm that computes a $3$-multiplicative approximation of the girth of a $n$-node $m$-edge directed graph with non-negative edge lengths. This is the first algorithm which approximates the girth of a directed graph up to a constant multiplicative factor faster than All-Pairs Shortest Paths (APSP) time, i.e. $O(mn)$. Additionally, for any integer $k \ge 1$, we provide a deterministic algorithm for a $O(k\log\log n)$-multiplicative approximation to the girth in directed graphs in $\tilde{O}(m^{1+1/k})$ time. Combining the techniques from these two results gives us an algorithm for a $O(k\log k)$-multiplicative approximation to the girth in directed graphs in $\tilde{O}(m^{1+1/k})$ time. Our results naturally also provide algorithms for improved constructions of roundtrip spanners, the analog of spanners in directed graphs. The previous fastest algorithms for these problems either ran in All-Pairs Shortest Paths (APSP) time, i.e. $O(mn)$, or were due Pachocki et al. (PRSTV18) which provided a randomized algorithm that for any integer $k \ge 1$ in time $\tilde{O}(m^{1+1/k})$ computed with high probability a $O(k\log n)$ multiplicative approximation of the girth. Our first algorithm constitutes the first sub-APSP-time algorithm for approximating the girth to constant accuracy, our second removes the need for randomness and improves the approximation factor in Pachocki et al. (PRSTV18), and our third is the first time versus quality trade-off for obtaining constant approximations.

Equations

$$B_v^{\mathrm{in}}(r):=G[\{u:d(u,v)\le r\}]\text{ and }{B}_v^{\mathrm{out}}(r):=G[\{u:d(v,u)\le r\}]$$

$$B_v(r):=G[\{u:d(u\leftrightarrows v)\le r\}].$$

$$G_0(v)=\{s\in V\mid d(v,s)\le R/2\}$$

$$G_i(v)=\{s\in V\mid d(v,s)\le R/2\text{ and }d(s,t)\le 3R/2\text{ for all }t\in {\cup }_{0\le j\le i-1}{R}_j(v)\}.$$

$$d(v,s)\le R/2\text{ and }d(s,t)\le 3R/2\text{ for all }t\in {\cup }_{j\in [0,...,M]}{R}_j(v).$$

$$|V(B_v^{\mathrm{in}}((i_{\mathrm{in}}+1)R))|\ge |V(B_v^{\mathrm{in}}(i_{\mathrm{in}}R)){|}^{\frac{k-1}{k}}{n}^{\frac{1}{k}}$$

$$|E(B_v^{\mathrm{in}}((i_{\mathrm{in}}+1)R))|$$

$$x_{2k\log 4\log n}=n^{1-{\left(\frac{k-1}{k}\right)}^{2k\log 4\log n}}\ge \frac{3}{4}n.$$

$$1+i_{\mathrm{in}}\le 1+2k\log 4\log n+2k\log 4\log n+k\le 5k\log \log n$$

$$2n+10{\left(\frac{n}{2}\right)}^{\frac{k}{k-1}}\le 10n^{\frac{k}{k-1}}$$

$$10|V(B_v^{\mathrm{in}}((i_{\mathrm{in}}+1)R)){|}^{\frac{k}{k-1}}+10(n-s{)}^{\frac{k}{k-1}}\le 10(s^{\frac{k-1}{k}}{n}^{\frac{1}{k}}{)}^{\frac{k}{k-1}}+10(n-s{)}^{\frac{k}{k-1}}$$

$$\le 10s{n}^{\frac{1}{k-1}}+10(n-s)n^{\frac{1}{k-1}}=10n^{\frac{k}{k-1}}.$$

$$\sum _i{\left(1+\frac{2}{k}\right)}^{\ell -1}{t}_i^{\frac{k}{k-1}}\le {\left(1+\frac{2}{k}\right)}^{\ell -1}\sum _i\max {\left(\left(1+\frac{1}{k}\right)s_i,s_i^{\frac{k-1}{k}}{m}^{\frac{1}{k}}\right)}^{\frac{k}{k-1}}$$

$$\le {\left(1+\frac{2}{k}\right)}^{\ell -1}\sum _i\left(1+\frac{2}{k}\right)s_i{m}^{\frac{1}{k-1}}\le {\left(1+\frac{2}{k}\right)}^{\ell }{m}^{\frac{k}{k-1}}$$

$$\text{RoundtripCover}(G,O(k),2^i)\text{ for }0\le i\le O(\log n).$$

$$\bigcup _{i=0}^{O(\log n)}\text{RoundtripCover}(G,O(k),2^i)$$

$$n^{1-{\left(\frac{k-1}{k}\right)}^K}\ge n^{1-\frac{1}{k}}=n^{\frac{k-1}{k}}.$$

$$d(v,u)\le iR\text{ and }d(u,w)\le (i+K)R\text{ for all }w\in S_v^j\text{ for all }1\le j\le 100\log \hat{n}.$$

$$E_v^i\leftarrow \{u\in V(G):\mathrm{on}[u]\text{ and }\text{textsc}Similar(G,u,v,D,i,R)\text{ and }u\text{ reachable from }v\text{ through }{E}_v^i\}$$

$$d(v,u)\le KR\text{ and }d(u,w)\le 2KR\text{ for all }w\in S_v^j\text{ for all }1\le j\le 100\log \hat{n}$$

$$H_v^i:=\{u\in V(G):d(v,u)\le KR\text{ and }d(u,w)\le 2KR\text{ for all }w\in S_v^j\text{ for all }1\le j<i\},$$

$$|H_v^{100\log \hat{n}}|\le {\left(\frac{9}{10}\right)}^{100\log \hat{n}}n<1,$$

$$\underset{w^{\prime }\in H_v^i}{\mathrm{Pr}}\left[d(w,w^{\prime })\le 2KR\right]\le \frac{4}{5},$$

$$\left(\frac{9}{10}\cdot \frac{4}{5}-\frac{1}{2}\right)|H_v^i{|}^2=.22|H_v^i{|}^2$$

$${\left(1-\frac{.44n^{\frac{k-1}{k}}}{n}\right)}^{{\sum }_{i=1}^{100\log \hat{n}}|S^i|}\le 1-{\hat{n}}^{-20}$$

$$\underset{w^{\prime }\in H_v^i}{\mathrm{Pr}}\left[d(w,w^{\prime })\le 2KR\right]\le \frac{4}{5}.$$

$$|V(E_v^{i+1})|>n^{\frac{1}{k}}|V(E_v^i){|}^{\frac{k-1}{k}}.$$

$$|V(E_v^i)|\ge n^{1-{\left(\frac{k-1}{k}\right)}^i}.$$

$$|V(E_v^K)|\ge n^{1-{\left(\frac{k-1}{k}\right)}^K}>n^{\frac{k-1}{k}},$$

$$\sum _{j=1}^{100\log n}|S^j|=\tilde{O}(n^{1+\frac{1}{k}}).$$

$$\sum _{i=1}^t|V(F_i^2){|}^{\frac{k}{k-1}}\le \sum _{i=1}^t{\left(n^{\frac{1}{k}}|V(F_i^1){|}^{\frac{k-1}{k}}\right)}^{\frac{k}{k-1}}\le \sum _{i=1}^t{n}^{\frac{1}{k-1}}|V(F_i^1)|\le n^{\frac{k}{k-1}}$$

Full text

Constant Girth Approximation for Directed Graphs in

Subquadratic Time

Shiri Chechik

Tel Aviv University

shiri.chechik@gmail.com

This project has received funding from the European Union’s Horizon 2020 research grant agreement 803118.

  

Yang P. Liu

Stanford University

yangpatil@gmail.com

Research supported by the U.S. Department of Defense via an NDSEG fellowship.

  

Omer Rotem

Tel Aviv University

omer.rotem1@gmail.com

  

Aaron Sidford

Stanford University

sidford@stanford.edu

Research supported by NSF CAREER Award CCF-1844855

In this paper we provide a $\tilde{O}(m\sqrt{n})$ time algorithm that computes a $3$-multiplicative approximation of the girth of a $n$-node $m$-edge directed graph with non-negative edge lengths. This is the first algorithm which approximates the girth of a directed graph up to a constant multiplicative factor faster than All-Pairs Shortest Paths (APSP) time, i.e. $O(mn)$. Additionally, for any integer $k\geq 1$, we provide a deterministic algorithm for a $O(k\log\log n)$-multiplicative approximation to the girth in directed graphs in $\tilde{O}(m^{1+1/k})$ time. Combining the techniques from these two results gives us an algorithm for a $O(k\log k)$-multiplicative approximation to the girth in directed graphs in $\tilde{O}(m^{1+1/k})$ time. Our results naturally also provide algorithms for improved constructions of roundtrip spanners, the analog of spanners in directed graphs.

The previous fastest algorithms for these problems either ran in All-Pairs Shortest Paths (APSP) time, i.e. $O(mn)$, or were due Pachocki et al. [PRS*+*18] which provided a randomized algorithm that for any integer $k\geq 1$ in time $\tilde{O}(m^{1+1/k})$ computed with high probability a $O(k\log n)$ multiplicative approximation of the girth. Our first algorithm constitutes the first sub-APSP-time algorithm for approximating the girth to constant accuracy, our second removes the need for randomness and improves the approximation factor in Pachocki et al. [PRS*+*18], and our third is the first time versus quality trade-off for obtaining constant approximations.

1 Introduction

The girth of a graph $G$ is the length of the shortest cycle in $G$. It is an important graph quantity that has been studied extensively in both combinatorial settings (see Bollobás’s book [Bol98] for a discussion) and computational settings. In particular, exact algorithms for the girth running in time $O(mn)$ in weighted directed graphs [OS17] are known. On the other hand, a result of Vassilevska W. and Williams show that a truly subcubic algorithm for girth (i.e. running in time $n^{3-\varepsilon}$ for some $\varepsilon>0$) implies a truly subcubic algorithm for the All Pairs Shortest Path (APSP) problem [WW10]. As it is a longstanding open problem whether APSP admits a truly subcubic time algorithm, exact computation of the girth in truly subcubic time would be a major breakthrough.

This has motivated the study of efficient approximation algorithms for the girth. There has been extensive work on approximating the girth in undirected graphs [IR77, LL09, RW12, DKS17]. Many such algorithms use the concept of a $\alpha$-spanner of a graph $G$, a fundamental combinatorial object which was introduced by Chew [Che89]. An $\alpha$-spanner of a graph $G$ is a subgraph of $G$ which multiplicatively preserves distances up to a factor of $\alpha$. It is well-known that $(2k-1)$-spanners with $O(n^{1+1/k})$ edges exist for any undirected weighted graph [ADD*+*93], and work on the efficient construction of such spanners [TZ05, RTZ05, BS03] implies a $O(mn^{\frac{1}{k}})$ time algorithm for $(2k-1)$-multiplicative girth approximation in undirected graphs. There has also been work on improved spanner constructions in the case of undirected unweighted graphs [LL09, RW12], and these algorithms also immediately imply algorithms for girth approximation in undirected unweighted graphs.

Therefore, in order to obtain efficient constant factor girth approximations in directed graphs, it is natural to study an analog of spanners in directed graphs. Unfortunately, approximately computing all pairs distances in directed graphs is a notoriously difficult problem and while sparse spanners do exist in all undirected graphs, they do not exist in all directed graphs. For example, any directed spanner for the “directed” complete bipartite graph with $n$ vertices on the left directed towards $n$ vertices on the right clearly requires all $n^{2}$ edges. This problem seems to arise from the fact that the distance metric $d(u,v)$ in directed graphs is asymmetric. Therefore, if we want to construct sparse spanners, it is natural to work instead with the symmetric roundtrip distance metric, defined as $d(u\leftrightarrows v):=d(u,v)+d(v,u)$ [CW04] and similarly define an $\alpha$-roundtrip spanner of a directed graph $G$ to be a subgraph that multiplicatively preserves roundtrip distances up to a factor of $\alpha$.

Interestingly, there do exist roundtrip spanners for directed graphs with comparable sparsity as spanners for undirected graphs. A result of Roditty, Thorup, and Zwick [RTZ08] shows that for any $k\geq 1$ and $\varepsilon>0$, every graph has a $(2k+\varepsilon)$-roundtrip spanner with $O(k^{2}n^{1+1/k}\log(nW)\varepsilon^{-1})$ edges, where $W$ is the maximum edge weight. Unforunately, this algorithm ran in time $\Omega(mn)$, as it requires the computation of all pairs distances in the graph. Recent work Pachocki et al. [PRS*+*18] gave a randomized algorithm running in time $\tilde{O}(m^{1+1/k})$ which on weighted directed graphs $G$ returns a $O(k\log n)$-roundtrip spanner with $\tilde{O}(n^{1+1/k})$ edges and an $O(k\log n)$ approximation to the girth. Up to a logarithmic approximation factor, this matches the sparsity and runtime known for spanners on undirected weighted graphs and girth on sparse graphs.

The result of Pachocki et al. [PRS*+*18] constitutes one of small, but rapidly growing [CKP*+*17, CKK*+*18], set of instances where it is possible to obtain robust nearly linear time approximations to fundamental quantities of directed graphs in nearly linear time, overcoming typical running time gaps between solving problems on directed and undirected graphs.

However, a fundamental open problem left open by this work is whether it is possible to achieve subquadratic algorithms for constant factor approximation of the girth in directed graphs, and more ambitiously to fully close this gap and provide algorithms for $O(k)$ girth approximation and $O(k)$ roundtrip spanners in directed graphs that fully match the runtime and sparsity of those in undirected graphs. This is the primary problem this paper seeks to address and this paper provides multiple new girth approximation algorithms with improved runtime, approximation quality, and dependency on randomness.

1.1 Our Results

In this paper we provide a subquadratic algorithm for constant factor girth approximation in directed graphs and in turn show several improvements on the girth approximation algorithms and roundtrip spanner constructions in the work of Pachocki et al. [PRS*+*18]. Here and throughout the remainder of the paper we use $\tilde{O}(\cdot)$ notation to hide factors polylogarithmic in $n$, where $n$ is the number of vertices in the graph.

In Section 3 we consider obtaining constant approximations to the girth. In particular we provide a randomized algorithm that obtains a $3$-approximation to the girth on graphs with non-negative integer edge weights in $\tilde{O}(m\sqrt{n})$ time. Up to logarithmic factors this matches the runtime that would be predicted from the fact that $(2k-1)$-undirected spanners with $\tilde{O}(n^{1+1/k})$ edges can be constructed in $\tilde{O}(mn^{1/k})$ time for $k=2$. Further, we show that this procedure can be used to with high probability obtain constant multiplicative roundtrip spanners in directed graphs with arbitrary edge weights in $\tilde{O}(m\sqrt{n})$ time.

Theorem 1** (3-Multiplicative Girth Approximation).**

For any directed graph $G$ with $n$ vertices, $m$ edges, integer non-negative edge weights, and unknown girth $g$ we can compute in $\tilde{O}(m\sqrt{n})$ time an estimate $g^{\prime}$ such that $g\leq g^{\prime}\leq 3g$ with high probability in $n$.

Theorem 2** (8-Multiplicative Roundtrip Spanners).**

For any directed graph $G$ with $n$ vertices, $m$ edges, integer non-negative edge weights, we can compute in $\tilde{O}(m\sqrt{n})$ time an $8$-multiplicative roundtrip spanner with $\tilde{O}(n^{3/2})$ edges with high probability in $n$.

Then, in Section 4 we give algorithms for a $O(k\log\log n)$-multiplicative approximation of the the girth and construct $O(k\log\log n)$ multiplicative roundtrip spanners with $\tilde{O}(n^{1+1/k})$ edges for a weighted directed graph $G$ with $n$ vertices and $m$ edges in $\tilde{O}(m^{1+1/k})$ time. These algorithms are deterministic and constitute the first deterministic nearly linear time algorithms for $\tilde{O}(1)$ multiplicative approximation of the girth and $\tilde{O}(1)$ multiplicative roundtrip spanners with $\tilde{O}(n)$ edges.

Theorem 3** (Deterministic Multiplicative Girth Approximation).**

For any integer $k\geq 1$ and weighted directed graph $G$ with $n$ vertices, $m$ edges, and unknown girth $g$ we can compute in $\tilde{O}(m^{1+1/k})$ time an estimate $g^{\prime}$ such that $g\leq g^{\prime}\leq O(k\log\log n)\cdot g$.

Theorem 4** (Deterministic Multiplicative Roundtrip Spanners).**

For any integer $k\geq 1$ and any weighted directed graph $G$ with $n$ vertices and $m$ edges, we can compute in $\tilde{O}(m^{1+1/k})$ time an $O(k\log\log n)$ multiplicative roundtrip spanner with $\tilde{O}(n^{1+1/k})$ edges.

Setting $k=\frac{\log n}{\log\log n}$ yields the following corollaries. For $k=\Omega(\log n)$ these results nearly match the optimal algorithms in undirected graphs for $O(k)$ girth approximation and the construction of $O(k)$ spanners.

Corollary 1.1**.**

For any weighted directed graph $G$ with $n$ vertices, $m$ edges, and unknown girth $g$ we can compute in $\tilde{O}(m)$ time an estimate $g^{\prime}$ such that $g\leq g^{\prime}\leq O(\log n)\cdot g$.

Corollary 1.2**.**

For any weighted directed graph $G$ with $n$ vertices and $m$ edges, we can compute in $\tilde{O}(m)$ time an $O(\log n)$ multiplicative roundtrip spanner with $\tilde{O}(n)$ edges.

Interestingly, our results for constant factor randomized approximations and our results for deterministic approximations are achieved in different ways. Highlighting this, in Section 5 we show how to combine the techniques of these algorithms to obtain both $O(k\log k)$ multiplicative approximations to the girth and $O(k\log k)$ multiplicative roundtrip spanners of size $\tilde{O}(n^{1+1/k})$ in $\tilde{O}(mn^{1/k})$ time with high probability in $n$.

Theorem 5** (Constant Multiplicative Girth Approximation).**

For any integer $k\geq 1$ and any weighted directed graph $G$ with $n$ vertices, $m$ edges, and unknown girth $g$ we can compute in $\tilde{O}(m^{1+1/k})$ time an estimate $g^{\prime}$ such that $g\leq g^{\prime}\leq O(k\log k)\cdot g$ with high probability in $n$.

Theorem 6** (Constant Multiplicative Roundtrip Spanners).**

For any integer $k\geq 1$ and any weighted directed graph $G$ with $n$ vertices and $m$ edges, we can compute in $\tilde{O}(m^{1+1/k})$ time an $O(k\log k)$ multiplicative roundtrip spanner with $\tilde{O}(n^{1+1/k})$ edges with high probability in $n$.

This shows that for any fixed $\varepsilon>0$, that there is an algorithm running in time $m^{1+\varepsilon}$ that approximates the girth of a directed graph to within a constant depending on $\varepsilon$, but not on $m$ or $n$. Additionally, this almost matches the $O(k)$-multiplicative girth approximation algorithms running in $m^{1+1/k}$ time in undirected graphs.

1.2 Comparison to previous work

While the existence of roundtrip spanners matching the quality in undirected graphs was shown in [RTZ08], the runtime was $O(mn)$ and required an APSP computation. Our results, Theorem 1, Theorem 2 are the first to show that constant factor girth approximation and construction of constant factor roundtrip spanners with $\tilde{O}(n\sqrt{n})$ edges can be built in subquadratic $\tilde{O}(m\sqrt{n})$ time. This algorithm leverages new randomized techniques for testing a notion we call similarity between vertices not present in previous girth approximation and roundtrip spanner algorithms and we believe is of independent interest.

Our Theorem 3 and Theorem 4 offer direct improvements over the analogous results in [PRS*+*18]. Specifically, our algorithms provide a tighter multiplicative girth approximation and multiplicative spanner stretch in the same runtime as the algorithms in [PRS*+*18], which produce a $O(k\log n)$ girth approximation and $O(k\log n)$ roundtrip spanner with $\tilde{O}(n^{1+1/k})$ edges in time $\tilde{O}(m^{1+1/k}).$

Additionally, our algorithm is deterministic and in our opinion, simpler. The algorithm of Pachocki et al. [PRS*+*18] involved the following pieces. First, they use a method of Cohen to estimate ball sizes [Coh97] and resolve the case where there is a vertex whose inball and outball (of some small radius) intersect in a significant fraction of the vertices. In the other case, they use exponential clustering (see [MPX13]) to partition the graph and recurse. Finally, they rerun the algorithm $n^{1/k}$ times. On the other hand, our algorithm simply grows inballs and outballs from various vertices, and uses a delicate cutting conditition to decide when to cut and recurse.

Additionally, Theorem 5 and Theorem 6 further improve upon Pachocki et al. [PRS*+*18] by combining the ideas from the constant factor girth approximation algorithm and the deterministic ball-growing algorithm, completely removing the dependence on $n$ in the approximation factor while still running in time $\tilde{O}(m^{1+1/k})$. We remark that the ideas for our deterministic algorithm are essential in obtaining this last result, and that more directly combining the ideas of [PRS*+*18] with our constant factor approximation algorithm does not seem to give an $O(k\log k)$ multiplicative girth approximation in $\tilde{O}(m^{1+1/k})$ time.

1.3 Overview of Approach

Summary of randomized $O(1)$ approach.

Our approach to obtaining a $3$-approximation in Section 3 to the girth is rooted in the simple insight that if a vertex $v$ is in a cycle of length $R$ then every vertex in the ball of radius $\alpha$ from $v$ is at distance at most $\alpha+R$ from every vertex in the cycle. Consequently, for each vertex if we repeatedly prune vertices from its outball of radius $R$ if they do not have the property that they can reach every vertex in this ball by traversing a distance at most $2R$, then we will never prune away vertices in a cycle of length $R$ from that vertex.

Leveraging these insights, we can show that if we randomly compute distances to and from a random $\tilde{O}(\sqrt{n})$ vertices and if a cycle of length $O(R)$ is not discovered immediately then we can efficiently implement a pruning procedure so that each vertex only has in expectation $\tilde{O}(\sqrt{n})$ vertices that could possibly be in a cycle of length $O(R)$ through that vertex. By then checking each of these sets for a cycle and being careful about the degrees of the vertices (and therefore the cost of the algorithm) this approach yields essentially a $4$-approximation to the girth in $\tilde{O}(m\sqrt{n})$ time with high probability in $n$.

Our $3$-approximation is then obtained by carefully applying this argument to both outballs and inballs and leveraging the simple fact that if a vertex $v$ is on a cycle $C$ of length $R$ then for every $c\in C$ either $d(v,c)\leq R/2$ or $d(c,v)\leq R/2$.

Overview of deterministic $O(k\log\log n)$ results:

Our deterministic algorithm in Section 4 is based on a different approach than our randomized constant approximation algorithms in Section 3. We think this approach is of independent interest and further demonstrate its utility in Section 5 by showing how to combine the insights that underly it with the algorithm from Section 4 to achieve arbitrary constant approximations.

For the sake of simplicity, we focus on unweighted directed graphs $G$ and for a parameter $R$, construct a subgraph (roundtrip spanner) $H$ so that if the roundtrip distance between $u$ and $v$ is at most $R$ in $G$, then their roundtrip distance is at most $O(Rk\log\log n)$ in $H$.

The key insight of guiding our algorithm is the following: instead of partitioning the graph into disjoint pieces and recursing (as is done in [PRS*+*18]), we instead allow the pieces to overlap on the boundaries. This is justified by the following observation. Consider a subgraph $W$ of $G$, and let $W^{\prime}$ denote the subgraph consisting of all vertices within distance $R$ of $W$. Then if we recursively build a roundtrip spanner on $W^{\prime}$, then we are guaranteed that we can delete $W$ from our graph. Indeed, if $u\in W$ and the roundtrip distance between $u$ and $v$ is at most $R$, then $u,v\in W^{\prime}$. This simple observation allows us to overcome the critical challenge in [PRS*+*18], arguing that that graph can be broken apart, while nevertheless preserving roundtrip distance.

This observation also forms the basis of an optimal spanner construction on unweighted undirected graphs, which appears in a book of Peleg (exercise 3 on page 188 in [Pel00]). Specifically, for any integer $k\geq 1$, we can construct a $(2k-1)$-spanner with $O(n^{1+1/k})$ edges in time $O(m).$ The construction works as follows. Start at any vertex $v$, let $B_{i}$ denote the ball of radius $i$ centered at $v$, and let $|B_{i}|$ denote the number of vertices in $B_{i}$. Grow such balls around $v$ until we find an index $i$ with $|B_{i+1}|\leq n^{1/k}|B_{i}|.$ We can clearly guarantee that $i\leq k$. At this point, add a spanning tree on $B_{i+1}$ to your spanner and delete all vertices in $B_{i}.$ Now, recurse on the remaining graph. It is easy to check that the resulting spanner is as desired. Our algorithm for directed graphs is similar, and we give a more specific overview in Section 4.1.

We gain an $O(\log\log n)$ dependence over the undirected spanner algorithm presented because we must recurse on the balls we grew instead of simply building a spanning tree on them. The precise condition for recursion and corresponding calculation are performed in the algorithms GoodCut (Algorithm 4) and Lemma 4.2.

Further, our $O(k\log k)$ approximations of Section 5 are then achieved by using the techniques of the algorithms in Section 3 to better control the size of the outballs and inballs in an invocation of the deterministic algorithm of Section 4.

2 Preliminaries

For weighted directed graph $G$, we let $V(G)$ and $E(G)$ denote the vertex and edge sets of $G$. We assume all edge lengths are nonnegative. For a subgraph $S\subseteq G$ (not necessarily vertex induced), let $V(S)$ denote the set of vertices of $G$, and let $E(S)$ denote the set of edges. For a subset $W\subseteq V(G)$, we define $G[W]$ to be subgraph induced by $W$. When the graph $G$ is clear from context, we let $n$ and $m$ denote $|V(G)|$ and $|E(G)|$ respectively.

For a weighted directed graph $G$ with non-negative edge lengths, we let $d_{G}(u,v)$ denote the (shortest path) distance from $u$ to $v$ in $G$. When the graph $G$ is clear from context, we simply denote this as $d(u,v).$ If there is no path from $u$ to $v$, we let $d(u,v)=\infty.$ When $S$ is a subgraph of $G$, we let $d_{S}(u,v)$ denote the (shortest path) distance from $u$ to $v$ only using the edges in $E(S).$ We denote the roundtrip distance between $u$ and $v$ as $d_{G}(u\leftrightarrows v):=d_{G}(u,v)+d_{G}(v,u)$ and define a roundtrip spanner.

Definition 2.1** (Roundtrip Spanner).**

We say that a subgraph $S\subseteq G$ is an $\alpha$-roundtrip spanner if $d_{S}(u\leftrightarrows v)\leq\alpha\cdot d_{G}(u\leftrightarrows v)$ for all $u,v\in V(G).$

For weighted directed graph $G$ we define the inball and outball of radius $r$ around a vertex $v$ as

[TABLE]

respectively. In other words, the inball of radius $r$ around $v$ is the subgraph induced by vertices $u$ with $d(u,v)\leq r.$ The outball is defined similarly. We define the ball of radius $r$ around vertex $v$ as

[TABLE]

In other words, the ball of radius $r$ around $v$ is the subgraph induced by vertices $u$ within roundtrip distance $r$ of $v$.

3 Randomized Constant Approximations

Here we provide algorithms for efficiently computing a 3-approximation to the girth Section 3.1. To simplify our algorithm and analysis we assume that the maximum degree of $G$ is bounded by $O(m/n)$, i.e. we assume it is only a constant larger than the average degree, which is $2m/n$. We justify this assumption by showing that we can always reduce to this case as is formalized in the following lemma. We defer the proof to Section A.1.

Lemma 3.1**.**

Given a directed weighted graph $G=(V,E)$ of $n$ vertices and $m$ edges with non negative edge weights, one can construct a graph $H$ in $O(m)$ time of $O(n)$ vertices and $O(m)$ edges with non negative edge weights and of maximum degree $O(m/n)$ such that

All roundtrip distances (between pairs of vertices in $G$) in $H$ and in $G$ are the same. 2. 2.

Given a cycle in $H$, one can find in $O(m)$ time a cycle in $G$ of the same length. 3. 3.

Given a subgraph $H^{\prime}$ of $H$, one can find in $O(m)$ time a subgraph $G^{\prime}$ of $G$ such that the number of edges in $G^{\prime}$ is at most the number of edges in $H^{\prime}$ and the roundtrip distances in $H^{\prime}$ and $G^{\prime}$ are the same.

3.1 An $\tilde{O}(m\sqrt{n})$ Time $3$-approximation to Girth

In this section we show a procedure that given a directed weighted graph $G$ and a girth estimate $R$, returns a cycle of length at most $3R$ if the girth in $G$ is at most $R$. The algorithm is given by GirthApprox (See Algorithm 1) which in turn invokes the subroutine SimilarSet (See Algorithm 2).

In order to approximate the girth of $G$ we invoke this procedure for every $r=(1+\epsilon)^{i}$ for $1\leq i\leq\log_{1+\epsilon}{nW}$ and stop once the procedure returns a cycle. If $g$ is the girth of $G$ this incurs an additional $\log_{1+\epsilon}{g}$ factor to the running time (as for the first index $i$ such that $(1+\epsilon)^{i}>g$ the algorithm will return a cycle w.h.p.) and an additional $(1+\epsilon)$ factor in the approximation ratio. The additional $(1+\epsilon)$ factor in the approximation ratio can be avoided if the weights are integers by simply using binary search on the range between 1 and $nW$ (where $W$ is the maximum edge weight in $G$) and finding two consecutive integers $i$ and $i+1$ such that the procedure returned a cycle of length at most $3(i+1)$ when invoked on $i+1$ but not a cycle when invoked on $i$. This incurs a $\log{nW}$ factor in the running time that can be improved to $O(\log{n})$ by the same method as done in [PRS*+*18] of contracting small weight strongly connected components and deleting large weight edges (see Section 5.1 in [PRS*+*18] for more details).

Let $G=(V,E)$ be a directed graph with $n$ vertices and $m$ edges. We assume the graph $G$ is of average degree $\delta=2m/n$ and that also the maximum degree in the graph is also $O(\delta)$.

The subroutine SimilarSet gets as an input the graph $G$ and the target distance $R$ and either returns a cycle of length at most $3R$ or returns a subset $A_{v}$ of vertices for every $v\in V$. The subset $A_{v}$ for a vertex $v\in V$ consists of vertices at distance at most $R/2$ from $v$ with the guarantee that $A_{v}$ contains all vertices that are

At distance at most $R/2$ from $v$ and 2. 2.

On a cycle of length $R$ with $v$.

Procedure GirthApprox invokes the Procedure SimilarSet twice, once on $G$ and once on the reversed graph of $G$ (the graph obtained by reversing every edge of $G$). If a cycle of length $3R$ is returned in one of these calls then procedure GirthApprox returns such a cycle. Otherwise, let $\{A_{v}^{\mathrm{in}}\}_{v\in V}$ be the sets returned from invoking SimilarSet on the graph $G$ and $\{A_{v}^{\mathrm{out}}\}_{v\in V}$ on the reversed graph. Next, the procedure for every $v\in V$ checks if there is a cycle containing $v$ of length at most $R$ in the induced graph of $A_{v}^{\mathrm{in}}\cup A_{v}^{\mathrm{out}}$. If such a cycle exists then the procedure returns such a cycle.

Procedure SimilarSet works as follows. The algorithms starts by sampling $O(\log{n})$ independent subsets $S_{i}$ of expected size $O(\sqrt{n})$ each for $1\leq i\leq M$ where $M=50\log{n}$. From every vertex $w\in\bigcup_{1\leq i\leq M}{S_{i}}$ the algorithm runs Dijkstra from and to $w$ in $G$. If a cycle of length $3R$ is detected then the algorithm returns it.

Next for every vertex $v\in V$ and index $1\leq i\leq M$ the algorithm defines a set $T_{i}(v)\subseteq S_{i}$. The sets $T_{i}(v)$ will be used to reduce the number of potential vertices that can be on a cycle of length at most $R$ with $v$. First, the set $T_{0}(v)$ consists of all vertices in $S_{0}$ that are at distance at most $R/2$ from $v$. Let $R_{0}(v)$ be a sampled set of $O(\log{n})$ vertices from $T_{0}(v)$. Now, the sets $T_{i}(v)$ and $R_{i}(v)$ are defined as follows. The set $T_{i}(v)$ is the set of all vertices $s\in S_{i}$ such that $d(v,s)\leq R/2$ and $d(s,t)\leq 3R/2\text{ for all }t\in\bigcup_{0\leq j\leq i-1}{R_{j}(v)}$. Again, define $R_{i}(v)$ as a sampled set of $O(\log n)$ vertices from $T_{i}(v)$.

To gain intuition for the definition of $T_{i}(v)$ and $R_{i}(v)$, consider the set $G_{i}(v)$ of all vertices $s\in V(G)$ such that $d(v,s)\leq R/2$ and $d(s,t)\leq 3R/2\text{ for all }t\in\bigcup_{0\leq j\leq i-1}{R_{j}(v)}$. We remark that our algorithm does not compute $G_{i}(v)$, but its definition is essential for the analysis. Intuitively, the set $G_{i}(v)$ consists of the vertices after $i$ rounds that the algorithm still believes could be in a cycle of length $R$ with $v$. If $|G_{i}(v)|\geq 100\sqrt{n}\log n$, then by the choice of $S_{i}$ as an independent random set of expected size $O(\sqrt{n})$, we have that $T_{i}(v)$ is a random sample of $G_{i}(v)$ of expected size at least $100\log n.$ In this way, $R_{i}(v)$ is just a random sample of $G_{i}(v)$ of size $O(\log n).$

As we show in Lemma 3.4, if $|G_{M}(v)|\geq 100\sqrt{n}\log n$, our algorithm discovers w.h.p. a cycle of length at most $3R$ sometime during the shortest path computations done at the beginning. On the other hand, if $|G_{M}(v)|\leq 100\sqrt{n}\log n$, then we can grow a shortest path tree from $v$ but only include vertices in $G_{M}(v)$ to search for a cycle of length $R$, only paying runtime $|G_{M}(v)|=\tilde{O}(\sqrt{n})$ for that vertex $v$.

Formalizing this final step, the algorithm computes a shortest path tree $T(v)$ from $v$ up to depth $R/2$, keeping only vertices $s\in V$ such that $d(v,s)\leq R/2$ and $d(s,t)\leq 3R/2\text{ for all }t\in\bigcup_{0\leq j\leq M}{R_{j}(v)}$. The set $A_{v}$ is the set of vertices in $T(v)$.

Next we prove the correctness of our girth computation algorithm GirthApprox (Algorithm 1) and bound its running time. First we prove the following lemma which provides a fairly straightforward argument that the algorithm always outputs the correct result. The more challenging part of the analysis will be to bound its running time.

Lemma 3.2**.**

If $G$ contains a cycle of length at most $R$ then $\textsc{GirthApprox}(G,R)$ (Algorithm 1) returns a cycle of length at most $3R$.

Proof.

Assume $G$ contains a cycle $C$ of length at most $R$. Let $v$ be a vertex in $C$. If the algorithm returns a cycle in line 3 of SimilarSet (Algorithm 2) then since this cycle has length at most $3R$, the algorithm works as desired.

Consequently, we assume that this is not the case. Our goal is now to show that $A_{v}^{\mathrm{out}}$ contains all vertices $c\in C$ such that $d(v,c)\leq R/2$ and that $A_{v}^{\mathrm{in}}$ contains all vertices $c\in C$ such that $d(c,v)\leq R/2$. Since for all $c\in C$ either $d(v,c)\leq R/2$ or $d(c,v)\leq R/2$ this will imply that $C\subseteq A_{v}^{\mathrm{out}}\cup A_{v}^{\mathrm{in}}$ and therefore a cycle of length at most $R$ will be found in Line 3 of $\textsc{GirthApprox}(G,R)$ (Algorithm 1) and the algorithm works as desired. Further, note that it suffices to show that $A_{v}^{\mathrm{out}}$ contains all vertices $c\in C$ such that $d(v,c)\leq R/2$ as this will imply the desired claimed regarding $A_{v}^{\mathrm{in}}$ by symmetry.

Consider the execution of SimilarSet (Algorithm 2) from Line 1 of $\textsc{GirthApprox}(G,R)$ (Algorithm 1). Further, consider a vertex $t\in T_{i}(v)$ for some $0\leq i\leq M-1$. Recall that $d(v,t)\leq R/2$ (by definition and construction of $T_{i}(v)$). Consider a vertex $c$ in $C$. As $v$ and $c$ are on a cycle of length $R$ we have $d(c,v)\leq R$ and therefore $d(c,t)\leq d(c,v)+d(v,t)\leq 3R/2$ by triangle inequality. It follows by construction that each vertex $c\in C$ with $d(v,c)\leq R/2$ will be added to $A_{v}$ as desired. ∎

With the correctness of GirthApprox (Algorithm 1) established, in the remainder of this section we focus on analyzing its running time. To do this we will consider an invocation of SimilarSet (Algorithm 2) and both bound its running time and the size of the sets $A_{v}$ it computes.

Before setting up the proofs, for each vertex $v\in V$ we define

[TABLE]

and

[TABLE]

Notice that the distribution of $T_{i}(v)$ is the distribution on vertices that results from taking each $s\in G_{i}(v)$ and including it in $T_{i}(v)$ with probability $p=1/\sqrt{n}$.

Loosely speaking, the analysis of the running time is roughly as follows. The main non trivial part is to show that the expected size of the sets $A_{v}^{\mathrm{in}}$ and $A_{v}^{\mathrm{out}}$ is $\tilde{O}(\sqrt{n})$. This, together with the assumption that the maximum degree is $O(m/n)$, will imply that the running time of our algorithm is $\tilde{O}(m\sqrt{n})$. We roughly speaking show the following for the set $A_{v}^{\mathrm{out}}$ (similarly for the set $A_{v}^{\mathrm{in}}$ ). We want to claim that w.h.p. the sets $G_{i}(v)$ are decreasing by at least a constant factor until there is a set $G_{i}(v)$ of $\tilde{O}(\sqrt{n})$ size. As $A_{v}^{\mathrm{out}}$ is a subset of $G_{M}(v)\subseteq G_{i}(v)$, the claim follows. Assume this is not case, i.e., there exists an index $i$ such that $|G_{i+1}(v)|>0.8|G_{i}(v)|$. Note that by construction for every vertex $s$ in $G_{i+1}(v)$ all vertices in $R_{i}(v)$ are at distance at most $3R/2$ from it. As $R_{i}(v)$ is a sampled set of $G_{i}(v)$, we can show that w.h.p. most vertices in $G_{i}(v)$ (say 0.9 fraction of them) are at distance at most $3R/2$ from $s$. As $|G_{i+1}(v)|>0.8|G_{i}(v)|$, this means that this is also true for most vertices in $G_{i}(v)$. That is, most vertices in $G_{i}(v)$ are at distance at most $3R/2$ to most of the other vertices in $G_{i}(v)$. We show by counting argument that in this case there must be many pairs of vertices $u$ and $v$ such that $u,v\in G_{i}(v)$ and $d_{G}(u,v)\leq 3R/2$ and $d_{G}(v,u)\leq 3R/2$ (hence $u$ and $v$ are both on a cycle of length at most $3R$). That is, w.h.p. $G_{i}(v)$ contains many vertices that are on cycles of length at most $3R$. W.h.p. we can show that such a vertex will belong to $S_{i}(v)$ and therefore the algorithm will detect a cycle of length $3R$ and will not continue to computing the sets $A_{v}^{\mathrm{out}}$.

Lemma 3.3**.**

Consider a vertex $v$, index $i\in[M]$ such that $|G_{i}(v)|\geq 200\sqrt{n}\log{n}$ and a vertex $u\in V$. If there are less than $0.9|G_{i}(v)|$ vertices $s\in G_{i}(v)$ such that $d(u,s)\leq 3R/2$ then with probability at least $1-2/n^{10}$, $u\notin G_{i+1}(v)$.

Proof.

Note that the distribution of obtaining $T_{j}(v)$ is equivalent to the distribution of picking every vertex in $G_{j}(v)$ with probability $p$ for every $1\leq j\leq M$.

We first show that with high probability $T_{i}(v)$ contains at least $100\log{n}$ vertices (and therefore also $R_{i}(v)$). As $|G_{i}(v)|\geq 200\sqrt{n}\log{n}$ then the expected size of $|T_{i}(v)|$ is at least $200\log{n}$. Therefore, by Chernoff Bound the probability that $|T_{i}(v)|\leq 100\log{n}$ is at most $\left(\frac{e^{-1/2}}{1/2^{1/2}}^{100\log{n}}\right)<1/n^{10}$.

Assume this is indeed the case, that is, $T_{i}(v)$ contains at least $100\log{n}$ vertices. The set $R_{i}(v)$ is a sampled set of $100\log{n}$ vertices from $T_{i}(v)$. As the distribution of obtaining the set $T_{i}(v)$ is equivalent to distribution of picking every vertex in $G_{i}(v)$ with probability $p$ then the distribution of $R_{i}(v)$ is equivalent to picking $100\log{n}$ vertices from $G_{i}(v)$ (every vertex in $G_{i}(v)$ has the same probability appearing in $R_{i}(v)$). Consider a uniformly random vertex $s$ from $G_{i}(v)$. With probability at least $1/10$ we have $d(u,s)>3R/2$. In other words with probability at most $9/10$ we have $d(u,s)\leq 3R/2$. Therefore, the probability that for every vertex $s$ in $R_{j}(v)$ we have $d(u,s)\leq 3R/2$ is at most $(9/10)^{100\log{n}}\leq 1/n^{10}$.

The lemma follows by union bound over the events that either $|T_{i}(v)|$ is smaller than $100\log{n}$ or for all $s\in R_{i}(v)$ we have $d(u,s)\leq 3R/2$. ∎

Lemma 3.4**.**

If there exists a vertex $v$ and an index $i$ such that $|G_{i}(v)|\geq 200\sqrt{n}\log{n}$ and $|G_{i+1}(v)|\geq 0.8|G_{i}(v)|$ then with probability at least $1-1/n^{8}$ there exists a vertex in $T_{i}(v)$ that is contained in a cycle of length at most $3R$.

Proof.

Assume such a vertex $v$ and index $i$ exist.

We say that a vertex $u$ is $(v,i)$-dense if there are at least $0.9|G_{i}(v)|$ vertices $s\in G_{i}(v)$ such that $d(u,s)\leq 3R/2$.

By union bound on all vertices $v\in V$ on Lemma 3.3, with probability at least $1-2/n^{9}$, all vertices in $G_{i+1}(v)$ are $(v,i)$-dense.

As $G_{i+1}(v)\subseteq G_{i}(v)$ and $|G_{i+1}(v)|\geq 0.8|G_{i}(v)|$, we also have that with probability at least $1-2/n^{9}$, $0.8|G_{i}(v)|$ vertices in $G_{i}(v)$ are $(v,i)$-dense. Assume this is indeed the case.

Imagine constructing the following directed graph $H$ whose set of vertices is $G_{i}(v)$ and set of edges is the following. For every vertex $u$ in $G_{i}(v)$ add an outgoing edge for every vertex $s$ such that $d(u,s)\leq 3R/2$. Note that if there exists two edges in the graph $(u,s)$ and $(s,u)$ then both $u$ and $s$ are on a cycle of length at most $3R$. We next show that by counting argument there are many vertices in $G_{i}(v)$ that are on a cycle of length at most $3R$. Every $(v,i)$-dense vertex $u$ has $0.9|G_{i}(v)|$ outgoing edges in $H$. There are at least $0.9|G_{i}(v)|$ $(v,i)$-dense vertices in $H$. We get that the number of edges $E(H)$ is at least $0.71|G_{i}(v)|^{2}$, that is, $|E(H)|\geq 0.71|G_{i}(v)|^{2}$.

On the other hand let $\alpha$ be the fraction of vertices in $G_{i}(v)$ that do appear on a cycle of length at most $3R$. For every edge in $H$ give a credit of 1/2 for each of its endpoints vertices. Note that every vertex $x$ that do not belong to a cycle of length at most $3R$ can get a credit of less than $|G_{i}(v)|/2$. To see this, note that there is no other vertex with both incoming and outgoing edge to $x$ (as otherwise $x$ is on a cycle of length at most $3R$) so the total number of incoming and outgoing edges of $x$ is at most $|G_{i}(v)|-1<|G_{i}(v)|$. Hence, the total credit of $x$ is less than $|G_{i}(v)|/2$. The total credit of a vertex $x$ that do participate in a cycle of length at most $3R$ is less than $|G_{i}(v)|$. We get that the total credit of all vertices, which is also equal to the total number of edges in $H$, is less than $\alpha|G_{i}(v)||G_{i}(v)|/2+(1-\alpha)|G_{i}(v)|^{2}$. It follows that $0.71|G_{i}(v)|^{2}\leq\alpha|G_{i}(v)||G_{i}(v)|/2+(1-\alpha)|G_{i}(v)|^{2}$. Straight forward calculation show that $\alpha<0.58$ and thus $1-\alpha>0.42$. In other words, at least $0.42|G_{i}(v)|$ vertices in $G_{i}(v)$ belong to a cycle of length at most $3R$.

Next, we claim that w.h.p. there is such a vertex in $T_{i}(v)$. Recall that the distribution of $T_{i}(v)$ is equivalent to picking every vertex in $G_{i}(v)$ with probability $p$. Consider one vertex that participates in a cycle of length at most $3R$ the probability it does not belong to $T_{i}(v)$ is $1-p$. The probability that none of the $0.42|G_{i}(v)|$ vertices belong to $T_{i}(v)$ is at most $(1-p)^{0.42|G_{i}(v)|}\leq(1-p)^{84\log{n}/p}\leq 1/n^{10}$.

The lemma follows (as $1/n^{10}+2/n^{9}<1/n^{8}$ for large enough $n$). ∎

Finally, the following concludes the running time of our algorithm.

Lemma 3.5**.**

The expected running time of Algorithm 1 is $O(m\sqrt{n}\log{n}+n\sqrt{n}\log^{3}{n})=\tilde{O}(m\sqrt{n})$.

Proof.

Consider one of the executions of SimilarSet (Algorithm 2) by GirthApprox (Algorithm 1). This algorithm computes Dijkstra to/from each vertex $w\in S_{i}$ for every $1\leq i\leq M$ in $O(m+n\log{n})$ time. The expected size of each $S_{i}$ is $O(n^{1/2})$. Thus, the expected time of this computation for $S_{i}$ is $O(m\sqrt{n}+n\sqrt{n}\log{n})$. There are $O(\log{n})$ sets $S_{i}$ and therefore there is at most $O(m\sqrt{n}\log{n}+n\sqrt{n}\log^{2}{n})$ expected time for the computation of all Dijkstra’s. Next, for every vertex $v$ the algorithm computes the sets $T_{i}(v)$ for every $i\in[M]$. The set $T_{0}(v)$ can be computed easily in $O(|S_{0}|)$ time which is $O(n^{1/2})$ in expectation. In order to compute $T_{i}(v)$ for $i>0$, the algorithm considers every vertex $s\in S_{i}$ and it check if $s$ is at distance at most $3R/2$ from every vertex in $t\in\cup_{j\in[0,...,i-1]}{R_{j}(v)}$. There are $O(\log^{2}{n})$ vertices $t$ in $\cup_{j\in[0,...,i-1]}{R_{j}(v)}$. The distance $d(s,v)$ is already computed and thus can be retrieved in $O(1)$ time. Overall, computing the set $T_{i}(v)$ takes $O(n^{1/2}\log^{2}{n})$ in expectation. Therefore, $O(n^{1/2}\log^{3}{n})$ for all indices $i\in[M]$. Hence, for all vertices $v$ $O(n^{3/2}\log^{3}{n})$ expected time for this part.

Next, we bound the cost of computing the balls, $A_{v}$, and we bound their size. By a slight abuse of notation we call a vertex $s$ $(v,M)$-dense if it satisfies

[TABLE]

The algorithm grows a ball from every vertex $v\in V$ by only keeping vertices $s$ that are $(v,M)$-dense to compute $A_{v}$.

We first show that if there is no index $i$ such that $|G_{i}(v)|\geq 200\sqrt{n}\log{n}$ and $|G_{i+1}(v)|\geq 0.8|G_{k}(v)|$ then the expected time to compute the ball of $v$ is $O(n^{1/2}\log^{3}{n}+n^{1/2}\log{n}\cdot\delta)$. We do that by showing that the expected number of vertices in $G_{M}(v)$ is $O(n^{1/2}\log{n})$. As the maximum degree in $G$ is $O(\delta)$ and checking if a vertex $s$ is $(v,M)$-dense takes $O(\log^{2}{n})$ time, then the claim follows.

As for every $i$ such that $|G_{i}(v)|\geq O(\sqrt{n}\log{n})$ we have $|G_{i+1}(v)|\leq 0.8|G_{i}(v)|$ then straight forward calculation shows that there exists an index $M^{\prime}\in[1..M]$ such that $|G_{M^{\prime}}(v)|<O(\sqrt{n}\log{n})$. Note that the ball of $v$ contains only vertices from $G_{M^{\prime}}(v)$ and thus the claim follows.

We now assume that there exists a vertex $v$ and index $i$ such that $|G_{i}(v)|\geq O(\sqrt{n}\log{n})$ and $|G_{i+1}(v)|\geq 0.8|G_{i}(v)|$. By claim 3.4 in this case with probability at least $1-1/n^{8}$ the algorithm finds a cycle of length $3R$ and returns it in Line 3. Therefore, in this case the algorithm does not compute the balls in Line 13. With probability at most $1/n^{8}$ the algorithm does not find a cycle in Line 3 and therefore continues to computing the balls in Line 13. The computation of all balls in Line 13 is bounded by $O(mn)$ in this case. As this happens with very small probability this does not effect the asymptotic bound of the expected running time. The lemma follows. ∎

We conclude this section with the proof of Theorem 1.

Proof of Theorem 1.

The algorithm calls Algorithm GirthApprox using a binary search on the range $[1,nW]$ to find a parameter $R$ such that Algorithm GirthApprox returns a cycle (of length at most $3(R+1)$) when invoked on $R+1$ but not on $R$. As mentioned above the dependency on $\log{nW}$ can be improved to $\log{n}$ using the method used in [PRS*+*18] (Section 5.1). Roughly speaking this method constructs in $O(m\log{n})$ time a set of graphs such that the number of vertices in all these graphs together is $O(n\log{n})$, the number of edges is $O(m\log{n})$, the ratio between the maximum edge weight and the minimum edge weight in all these graphs is $O(n)$ and the shortest cycle is contained in one of these graphs. Instead of running binary search on $G$, we run it in each of these graphs.

Now using Lemma 3.2 and Lemma 3.5 the theorem follows. ∎

We give our result on constant approximation roundtrip spanners in $\tilde{O}(m\sqrt{n})$ time and show Theorem 2 in Appendix B.

4 Deterministic $O(k\log\log n)$ Approximation Algorithms

In this section we present our deterministic algorithms for computing a $O(k\log\log n)$ approximation to the girth and computing $O(k\log\log n)$ multiplicative roundtrip spanners. Our main result will be showing how to compute improved roundtrip covers as defined originally in [RTZ08]. Leveraging this result we will prove Theorem 3 and Theorem 4.

First, leveraging the definitions of balls in Section 2 we define roundtrip covers. Intuitively, roundtrip covers are a union of balls of radius $kR$ such that if vertices $u,v\in V(G)$ satisfy $d(u\leftrightarrows v)\leq R$ then $u,v$ are both in some ball in the cover.

Definition 4.1** (Roundtrip Covers).**

A collection $C$ of balls is a $(k,R)$ roundtrip cover of a weighted directed graph $G$ if and only if every ball in $C$ has radius at most $kR$, and for any $u,v\in V(G)$ with $d(u\leftrightarrows v)\leq R$ there is a ball $B\in C$ such that $u,v\in B$.

Specifically, we show the following theorem.

Theorem 7** (Improved Roundtrip Covers).**

For an $n$-vertex $m$-edge graph $G$, an execution of $\textsc{RoundtripCover}(G,k,R)$ returns a collection $C$ of balls that forms a $(O(k\log\log n),R)$ roundtrip cover of a weighted directed graph $G$ in time $m^{1+O(1/k)}$ where $\sum_{B\in C}|V(B)|=n^{1+O(1/k)}.$

To show Theorem 3 from Theorem 7, we can compute $(k,2^{i})$ roundtrip covers for all $0\leq i\leq O(\log n)$, and set our girth estimate as the minimum radius of any ball in the cover that has a cycle. To compute a roundtrip spanner, simply take the union of all the balls in the $(k,2^{i})$ roundtrip covers for all $i=O(\log n).$

The rest of the section is organized as follows. In Section 4.2 we state our main algorithm. In Section 4.3 we analyze the algorithm and prove Theorem 7. In Section 4.4 we use Theorem 7 to formally prove Theorem 3 and Theorem 4.

4.1 Technical Overview

We focus on unweighted directed graphs $G$ and for a parameter $R$, construct a roundtrip spanner $H$ so that if the roundtrip distance between $u$ and $v$ is at most $R$ in $G$, then their roundtrip distance is at most $O(Rk\log\log n)$ in $H$.

Our approach is based on growing inballs and outballs in the graph $G$. Fix a vertex $v$, and let $B^{\mathrm{in}}_{i},B^{\mathrm{out}}_{i}$ denote the inball and outball of radius $iR$ around $v$, and let $|B^{\mathrm{in}}_{i}|,|B^{\mathrm{out}}_{i}|$ denote the number of vertices in the balls and fix $d=O(k\log\log n).$ We start by growing and inball and outball around $v$. First, if $|B^{\mathrm{in}}_{d}\cap B^{\mathrm{out}}_{d}|\geq\frac{n}{2}$, then we can build a roundtrip ball of radius $2dR+R$ and delete $B^{\mathrm{in}}_{d}\cap B^{\mathrm{out}}_{d}$ from our graph. This is safe essentially by our observation above. Otherwise, we find an index $i$ such that $|B^{\mathrm{in}}_{i+1}|$ isn’t much larger than $|B^{\mathrm{in}}_{i}|$, we recursively build a roundtrip cover on $B^{\mathrm{in}}_{i+1}$ and then delete $B^{\mathrm{in}}_{i}$. This is safe to do by our observation above. Similarly, if there is an index $i$ such that $|B^{\mathrm{out}}_{i+1}|$ isn’t much larger than $|B^{\mathrm{out}}_{i}|$, we recursively build a roundtrip cover on $B^{\mathrm{out}}_{i+1}$ and then delete $B^{\mathrm{out}}_{i}$. Through standard ball cutting inequalities we can show that such an index $i$ exists (Lemma 4.2). We would like to elaborate on a few points. First, when we compare the sizes of $|B^{\mathrm{in}}_{i+1}|$ and $|B^{\mathrm{in}}_{i}|$, we compare both the number of vertices and edges, the former to control the size of the roundtrip spanner constructed, and the latter to control runtime. Second, we grow the inball and outball at the same rate, i.e. we alternately add an edge at a time to the inball and outball to maintain that the work spent on each is the same.

4.2 Main Algorithm

We first give a high-level description of our algorithm for computing Roundtrip Covers, RoundtripCover, which is presented formally as Algorithm 3.

High-level Description of Algorithm.

As discussed in Sections 1.3 and 4.1, our algorithm is based on ball growing along with the following observation: if for a radius $r^{\prime}$ we compute a roundtrip cover of $B^{\mathrm{in}}_{v}(r^{\prime}+R)$ and add all the balls in the computed roundtrip cover on $B^{\mathrm{in}}_{v}(r^{\prime}+R)$ to our final cover, then we can safely delete all vertices $u\in B^{\mathrm{in}}_{v}(r^{\prime})$ from our graph and recurse on the rest of graph; the deleted vertices are already satisfied in the sense that for every $u^{\prime}\in V(G)$ with $d(u\leftrightarrows u^{\prime})\leq R$ there is a ball $B$ in the cover such that $u,u^{\prime}\in B$. Indeed, if $u\in B^{\mathrm{in}}_{v}(r^{\prime})$ and $d(u\leftrightarrows u^{\prime})\leq R$ then $u,u^{\prime}\in B^{\mathrm{in}}_{v}(r^{\prime}+R)$ and therefore we are guaranteed that the roundtrip cover on $B^{\mathrm{in}}_{v}(r^{\prime}+R)$ contains a ball $B$ such that $u,u^{\prime}\in B$. Using this observation, we grow inballs and outballs around vertices in our graph $G$ to “partition” our graph into pieces that possibly overlap, where the overlap corresponds to the boundary $B^{\mathrm{in}}_{v}(r^{\prime}+R)\backslash B^{\mathrm{in}}_{v}(r^{\prime})$ in our example.

We describe our algorithm in more detail now. Consider any vertex $v$. We grow an inball and outball around $v$ at the same rate, spending the same time on the inball and outball. First, we consider the case that $|V(B^{\mathrm{in}}_{v}(r))|,|V(B^{\mathrm{out}}_{v}(r))|\geq\frac{3n}{4}$ for some $r=O(Rk\log\log n)$, as was done in Pachocki et al. [PRS*+*18]. Then we know that $|V(B^{\mathrm{in}}_{v}(r))\cap V(B^{\mathrm{out}}_{v}(r))|\geq\frac{n}{2}.$ By our observation above, we can add the ball $B_{v}(2r+R)$ to our roundtrip cover, delete $B^{\mathrm{in}}_{v}(r)\cap B^{\mathrm{out}}_{v}(r)$ from $G$, and recurse on the remainder. Otherwise, if we find a radius $r^{\prime}$ such that say $B^{\mathrm{in}}_{v}(r^{\prime})$ and $B^{\mathrm{in}}_{v}(r^{\prime}+R)$ satisfy the conditions of GoodCut (Algorithm 4), then we recurse on $B^{\mathrm{in}}_{v}(r^{\prime}+R)$ and delete $B^{\mathrm{in}}_{v}(r^{\prime})$ from our graph and recurse on the remaining graph. This is safe to do by our observation above. We can also do an analogous process on $B^{\mathrm{out}}_{v}(r^{\prime})$ and $B^{\mathrm{out}}_{v}(r^{\prime}+R).$ By a variant of the standard ball-growing inequality (Lemma 4.2) we can show that a good cut always exists.

We now will give some intuition about the condition in GoodCut and the (somewhat strange) appearance of the $O(\log\log n)$ in our algorithm. First, we remark that the condition in GoodCut must track both the number of vertices and edges in the ball: the former to control recursion depth and roundtrip cover size, and the latter to control runtime. Now we give intuition for why we require an $O(k\log\log n)$ approximation factor in our algorithm. Consider growing inballs $B^{\mathrm{in}}_{v}(r)$ from $v$ for various radii $r$, and recall that we make a cut depending on the relative sizes of $|V(B^{\mathrm{in}}_{v}(r))|$ and $|V(B^{\mathrm{in}}_{v}(r+R))|$. Now, note that if for example $|V(B^{\mathrm{in}}_{v}(r))|=O(1)$, we can afford to have $|V(B^{\mathrm{in}}_{v}(r+R))|=O(n^{1/k})$, as we can simply run a naive algorithm on $B^{\mathrm{in}}_{v}(r+R)$ now. On the other hand, if for example $|V(B^{\mathrm{in}}_{v}(r))|=\Omega(n)$, we can essentially only afford to have $|V(B^{\mathrm{in}}_{v}(r+R))|\leq\left(1+\frac{1}{k}\right)|V(B^{\mathrm{in}}_{v}(r))|.$ To see the latter, note that the recurrence $T(m)=\left(1+\frac{1}{k}\right)(T(m/2)+T(m/2))$ has solution $T(m)=m^{1+O(1/k)}.$ Now, interpolating between these two extremes allows us to compute the optimal way to do ball cutting (which is done in GoodCut). This leads to a ball cutting procedure with $O(k\log\log n)$ levels, and thus results in an $O(k\log\log n)$ approximation ratio.

Explanation of Algorithm 3:

We now explain what each piece of Algorithm 3 is doing. Here, $i_{\mathrm{in}}$ and $i_{\mathrm{out}}$ track the radius of the inball and outball that we are growing. We grow the balls at the same rate. If we notice that at any point we are in position to make a good cut (see lines 7, 9) then we do so. Otherwise, we know that both balls will eventually contain many vertices (see line 5). In this case, we add $B_{v}(2r+R)$ to our roundtrip cover, delete $B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R)\cap B^{\mathrm{out}}_{v}(i_{\mathrm{out}}R)$ from our graph, and recurse. To grow the inball and outball at the same rate, we run Dijkstra to grow the inball and outball, alternately processing an edge at a time from the inball and outball. We check the condition of GoodCut on a ball when we have certified that we have processed all vertices up to distance $i_{\mathrm{in}}R$ or $i_{\mathrm{out}}R$ respectively.

4.3 Analysis of RoundtripCover and proof of Theorem 7

In this section we prove Theorem 7, bounding the performance of our roundtrip cover algorithm Algorithm 3. We start by showing that $1+\max(i_{\mathrm{in}},i_{\mathrm{out}})\leq 5k\log\log n$ at all points in the algorithm, hence some condition in lines 5, 7, 9 will trigger eventually.

Lemma 4.2**.**

At all points during Algorithm 3, we have that $1+\max(i_{\mathrm{in}},i_{\mathrm{out}})\leq 5k\log\log n.$

Proof.

We show $1+i_{\mathrm{in}}\leq 5k\log\log n$, and the bound on $1+i_{i_{\mathrm{out}}}$ is analogous. To prove this we assume that none of the conditions in the inner loop of the algorithm trigger, and compute the resulting vertex and edge sizes of $B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R)$ and $B^{\mathrm{out}}_{v}(i_{\mathrm{out}}R)$. To this end, assume that $|V(B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R))|\leq\frac{3n}{4}$ and $|E(B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R))|\leq m.$ By the conditions of lines 5, 7, and 11 we know that each time we increment $i_{\mathrm{in}}$ either

[TABLE]

or

[TABLE]

We first show that Eq. 1 can only hold for $2k\log 4\log n$ values of $i_{\mathrm{in}}$. To this end, define a sequence $\{x_{i}\}_{i\geq 0}$ as $x_{0}=1$ and $x_{i+1}=x_{i}^{\frac{k-1}{k}}n^{\frac{1}{k}}.$ By induction it follows that $x_{i}=n^{1-\left(\frac{k-1}{k}\right)^{i}}.$ In particular,

[TABLE]

This shows that the condition in Eq. 1 can only hold at most $2k\log 4\log n$ times. Similarly, after Eq. 2 holds for $2k\log 4\log n$ different $i_{\mathrm{in}}$, we will have that $|E(B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R))|\geq\frac{3m}{4}.$ At this point, Eq. 3 can hold at most $k$ times. This gives us that in total

[TABLE]

as desired. ∎

Now we proceed to proving Theorem 7.

Proof of Theorem 7.

We first show that the algorithm indeed returns a $(O(k\log\log n),R)$ roundtrip cover. Then we bound the total size of balls in the roundtrip cover, as well as the runtime.

Returns a $(O(k\log\log n),R)$ roundtrip cover.

We analyze lines 6, 8, and 10. In line 6, note that by Lemma 4.2, we know that $(i_{\mathrm{in}}+1)R,(i_{\mathrm{out}}+1)R\leq r.$ Therefore, we know that $B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R)\cap B^{\mathrm{out}}_{v}(i_{\mathrm{out}}R)\subseteq B_{v}(2r).$ Additionally, it is clear that for any vertex $u\in B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R)\cap B^{\mathrm{out}}_{v}(i_{\mathrm{out}}R)$, if another vertex $u^{\prime}$ satisfies $d(u\leftrightarrows u^{\prime})\leq R$ then $u^{\prime}\in B_{v}(2r+R).$ Therefore, the ball $B_{v}(2r+R)$ contains both $u$ and $u^{\prime}$, so we can safely delete $B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R)\cap B^{\mathrm{out}}_{v}(i_{\mathrm{out}}R)$ from $G$ and recurse. This is exactly what is happening in line 6. In line 8, note that for any vertex $u\in B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R)$, if another vertex $u^{\prime}$ satisfies $d(u\leftrightarrows u^{\prime})\leq R$ then $u^{\prime}\in B^{\mathrm{in}}_{v}((i_{\mathrm{in}}+1)R).$ Therefore, if we construct a roundtrip cover on $B^{\mathrm{in}}_{v}((i_{\mathrm{in}}+1)R)$, then we can safely delete $B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R)$ from $G$ and recurse. This is exactly what occurs in line 8. The same argument now applies to line 10. Finally, note that all balls we create are of radius $2r+R=O(Rk\log\log n).$

Total sizes of balls is $n^{1+O(1/k)}$.

We show by induction that the total number of vertices among all balls in the rountrip cover computed is at most $10n^{\frac{k}{k-1}}$ for an input graph $G$ with $n$ vertices. We show this by analyzing lines 6, 8, and 10. For line 6, note that because $\min(|V(B^{\mathrm{in}}_{v}((i_{\mathrm{in}}+1)R))|,|V(B^{\mathrm{out}}_{v}((i_{\mathrm{out}}+1)R))|)\geq\frac{3n}{4}$, we know that $|V(B^{\mathrm{in}}_{v}((i_{\mathrm{in}}+1)R))\cap V(B^{\mathrm{out}}_{v}((i_{\mathrm{out}}+1)R))|\geq\frac{n}{2}$. Therefore, it suffices to verify

[TABLE]

which is clear. For line 8, for simplicity let $s=|V(B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R))|.$ Then by the condition of GoodCut, it suffices to note that

[TABLE]

The same argument now applies to line 10.

Can be implemented to run in time $m^{1+O(1/k)}$.

We can implement the algorithm to grow $B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R)$ and $B^{\mathrm{out}}_{v}(i_{\mathrm{out}}R)$ at the same rate, i.e., we process a single inedge and outedge at a time, and increment $i_{\mathrm{in}}$ and $i_{\mathrm{out}}$ when we are sure that we’ve processed the whole inball or outball. This can be done with Dijkstra’s algorithm. We stop growing a ball once it contains at least $\frac{3n}{4}$ vertices. This way, any time we recurse, the total amount of work we have done to this point is at most twice the number of edges in the piece we are recursing on in lines 6, 8, and 10. To bound the runtime, we imagine lines 8 and 10 as partitioning the graph into pieces of the form $B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R)$ or $B^{\mathrm{out}}_{v}(i_{\mathrm{out}}R)$ and then recursing on $B^{\mathrm{in}}_{v}((i_{\mathrm{in}}+1)R)$ or $B^{\mathrm{out}}_{v}((i_{\mathrm{out}}+1)R)$. This way, the depth of the recursion is at most $O(\log n)$ because we know that $|V(B^{\mathrm{in}}_{v}((i_{\mathrm{in}}+1)R))|,|V(B^{\mathrm{out}}_{v}((i_{\mathrm{out}}+1)R))|\leq\frac{3n}{4}$ when we recurse.

We will now show that the total number of edges in level $\ell$ of the recursion is bounded by $\left(1+\frac{2}{k}\right)^{\ell}m^{\frac{k}{k-1}}$, where the top level is level [math]. We proceed by induction on $\ell.$ Say that the algorithm partitions $G$ into $G=G_{1}\cup G_{2}\cup\dots\cup G_{j},$ where each $G_{i}$ is either of the form $B^{\mathrm{in}}_{v}(i_{\mathrm{in}}R)$ or $B^{\mathrm{out}}_{v}(i_{\mathrm{out}}R).$ For simplicity, let $s_{i}=|E(G_{i})|$ and let $t_{i}=|E(B^{\mathrm{in}}_{v}((i_{\mathrm{in}}+1)R))|$ or $t_{i}=|E(B^{\mathrm{out}}_{v}((i_{\mathrm{out}}+1)R))|$ corresponding to what $G_{i}$ was. We know by the condition of GoodCut that $t_{i}\leq\max(\left(1+\frac{1}{k}\right)s_{i},s_{i}^{\frac{k-1}{k}}m^{\frac{1}{k}}).$ By induction, we know that the total number of edges processed in level $\ell$ is at most

[TABLE]

as $\sum_{i}s_{i}\leq m$ obviously.

Now, it is clear that the total work done on a graph $G$ at some node of the recursion tree is $\tilde{O}(|E(G)|)$ as line 6 only occurs $O(\log n)$ times. Now taking $\ell=O(\log n)$ in the above claim completes the proof. ∎

4.4 Proofs of Theorem 3 and Theorem 4

Both theorems follow easily from Theorem 7.

Proof of Theorem 3.

We first show the result for unweighted graphs. To show this, run

[TABLE]

Now, set our estimate $g^{\prime}$ of the girth to be the smallest radius of any nontrivial ball that we had in a roundtrip cover. By the guarantees of RoundtripCover, it is clear that $g\leq g^{\prime}\leq O(k\log\log n)\cdot g$ as desired. It is clear that the algorithm runs in time $\tilde{O}(m^{1+\frac{1}{k}})$ by Theorem 7. We can extend this to weighted graphs by instead taking $0\leq i\leq O(\log nW)$, where $W$ is the maximum edge weight. This can be improved to $O(\log n)$ by the same method as done in [PRS*+*18], where they give a general reduction by contracting small weight strongly connected components and deleting large weight edges (see Section 5.1 in [PRS*+*18] for more details). ∎

Proof of Theorem 4.

We first show the result for unweighted graphs. It is easy to see that

[TABLE]

is an $O(k\log\log n)$ spanner with $\tilde{O}(n^{1+1/k})$ edges by Theorem 7. It is clear that the algorithm runs in time $\tilde{O}(m^{1+\frac{1}{k}}).$ The extension to weighted graphs follows as in the above paragraph (proof of Theorem 3). ∎

5 An $O(k\log k)$ Approximation in $\tilde{O}(m^{1+1/k})$ Time

In this section we explain how to combine the ideas from Algorithm 3 and Algorithm 1 to give an algorithm for $(O(k\log k),R)$-roundtrip covers with $\tilde{O}(n^{1+1/k})$ edges in time $\tilde{O}(m^{1+1/k})$. Then Theorem 5 and Theorem 6 follow from this in the same way that Theorem 3 and Theorem 4 followed from Theorem 7.

Theorem 8** (Improved Randomized Roundtrip Cover).**

For an $n$-vertex $m$-edge graph $G$, an execution of $\textsc{RoundtripCover2}(G,k,R)$ returns a collection $C$ of balls that form a $(O(k\log k),R)$ roundtrip cover of a weighted directed graph $G$ in time $m^{1+O(1/k)}$ where $\sum_{B\in C}|V(B)|=n^{1+O(1/k)}.$

The remainder of the section is organized as follows. We first give an overview for our approach, which combines the complementary approaches of sections Section 4 and Section 3. We then state our main algorithm, Algorithm 5. Afterwards, we analyze Algorithm 5 to prove Theorem 8 in Section 5.2. Finally, we apply Theorem 8 to prove Theorem 5 and Theorem 6.

Overview of approach.

Throughout this section, we assume that we have applied Lemma 3.1 to make our graph $G$ approximately regular. Here we give a high level overview for the ideas behind the algorithm. Let $G$ be an $n$-vertex $m$-edge graph and let $K:=10k\log k$ for integer $k$. We start by generalizing Algorithm 1 and Algorithm 2 slightly, where we consider the case where the sampled sets $S_{i}$ have size $\tilde{O}(n^{1/k})$ instead of $\tilde{O}(n^{1/2}).$ To elaborate, we first view Algorithm 1 and Algorithm 2 as algorithms with the following guarantees. They add $\tilde{O}(n^{3/2})$ edges towards a spanner, and then for each vertex $v$ which is not yet in a cycle of length $4R$ using the current spanner edges builds a data structure $D_{v}$ (corresponding to Algorithm 2) which certifies that for all but at most $O(n^{1/2})$ other vertices $u$ we have that $d(v\leftrightarrows u)>4R$. We can generalize this as follows. There is a corresponding algorithm (Algorithm 6) which has the following guarantees. It adds $\tilde{O}(n^{1+1/k})$ edges towards a spanner, and then for each vertex $v$ which is not yet in a cycle of length $2KR$ using the current spanner edges builds a data structure $D_{v}$ which certifies that for all but at most $O(n^{\frac{k-1}{k}})$ other vertices $u$ we have that $d(v\leftrightarrows u)>KR$.

After running this generalized algorithm (Algorithm 6), for a vertex $v$, we can define $i$-similar vertices to $v$, which are intuitively the vertices that the data structure $D_{v}$ thinks could still possibly be in a cycle of length $kR$ with $v$ and which are within distance $iR$ of $v$. Then we define a sequence $E_{v}^{0},E_{v}^{1},\cdots,E_{v}^{K}$ of “balls” centered at $v$, where $E_{v}^{i}$ is the outball from $v$ consisting of $i$-similar vertices. The following important conditions hold: $v\in E_{v}^{0},$ and $E_{v}^{i}\subseteq E_{v}^{i+1}$ for all $0\leq i<K.$ Finally, if $u\in E_{v}^{i}$ and $d(u\leftrightarrows u^{\prime})\leq R$, then $u^{\prime}\in E_{v}^{i+1}.$ This allows us to apply the ball-growing procedure in Algorithm 3 but using the balls $E_{v}^{i}$. Note that by our choice of $K$ and a variant of Lemma 4.2, there exists a good cut. This is because

[TABLE]

Hence, we can make this good cut and then recurse. Here, our cutting condition is simpler (only checks vertices, not edges) because we have reduced to the case of regular graphs through Lemma 3.1.

5.1 Explanation of algorithms

Explanation of Algorithm 5, Algorithm 6, Algorithm 7, Algorithm 8, Algorithm 9.

Throughout, we let $\hat{n}$ be the number of vertices at the top level of recursion in the algorithms and we let $K:=10k\log k$ for integer $k$.

We start by explaining Algorithm 6 (BuildSimilar), which builds a data structure which allows efficient similarity queries. It follows the same blueprint as Algorithm 2. The algorithm first selects sets $S^{i}$ for $1\leq i\leq 100\log\hat{n}$, where $|S^{i}|=100n^{1/k}\log^{2}\hat{n}$ for all $i$. It then computes shortest path trees to and from all vertices in all $S^{i}$. The algorithm then adds roundtrip balls of radius $O(KR)$ centered at each $u\in S^{i}$ to our roundtrip cover. The algorithm then marks all vertices $v$ from the graph that are within distance $2KR$ both to and from some vertex $u$ in some $S^{i}$ as not turned on anymore. Then for all vertices $v\in V(G)$ the algorithm builds sets $T_{v}^{i}$ and a uniform sample $S_{v}^{i}$ of $T_{v}^{i}$ of size $O(\log\hat{n})$ that allow us to “test” whether another vertex $u$ is similar to $v$, i.e. could potentially be in a cycle of length $O(KR)$ with $v$. Eventually, $|T_{v}^{i}|$ gets small, and the algorithm stops processing vertex $v$. Finally, it returns the graph $G^{\prime}$ of all still on vertices, the updated roundtrip cover, and the data structure $D$ for similarity testing consisting of all the $S_{v}^{i}$ for each vertex $v$ and shortest path trees from all $u\in S^{i}$.

Now we explain Algorithm 8 (Similar), which uses the data structure $D$ computed by BuildSimilar to decide whether vertex $u$ is $i$-similar to vertex $v$. It returns true if and only if

[TABLE]

Intuitively, this contains a ball around $v$ of distance $iR$ that contains all vertices which could potentially be in a cycle of length $KR$ with $v$, according to the algorithm.

Now we explain Algorithm 9 (GoodCut2), which decides whether cutting out ball $B_{1}$ and recursing on $B_{2}$ constitutes good enough progress. This simply takes as input two balls $B_{1}$ and $B_{2}$ and decides whether recursing on $B_{2}$ and then deleting $B_{1}$ is good enough progress in trying to achieve a $\tilde{O}(n^{1+O(k^{-1})})$ total size of roundtrip covers. Here, we check only the vertex condition instead of the edge condition (different from Algorithm 4 GoodCut) because we have already reduced to the case where our graph $G$ is approximately regular (Lemma 3.1).

Now we explain Algorithm 7 (BallGrow), which grows the balls $E_{v}^{i}$. $\mathrm{on}[v]=\textbf{false}$ if vertex $v$ has been resolved, i.e. we can ensure that for any $u$ with $d(v\leftrightarrows u)\leq R$, that $v$ and $u$ are in a roundtrip ball of diameter $O(KR).$ Otherwise, $\mathrm{on}[v]=\textbf{true}.$ We now grow balls $E_{v}^{0},E_{v}^{1},\cdots,E_{v}^{K}$ around $v$, up until line 8 is satisfied. Our main claim is that when we recurse on $E_{v}^{i+1}$, then we can safely remove all vertices in $E_{v}^{i}$. While the definition in line 6

[TABLE]

may seem recursive, all we mean is to say that we run a search from $v$, only keeping vertices which are $i$-similar, i.e. $\textsc{Similar}(G,u,v,D,i,R)$ is true.

Finally, our main algorithm Algorithm 5 (RoundtripCover2) first calls BuildSimilar to build the similarity data structure needed for BallGrow. It also removes vertices from $G$ that were already resolved (i.e. in cycles of length $2KR$) to get a graph $G^{\prime}$. Then it grows balls to partition $G^{\prime}$ and recurse.

5.2 Analysis

In this section we analyze the above algorithms. We first show that the number of similar vertices to any vertex $v$ in $G^{\prime}$ (line 4) is at most $n^{\frac{k-1}{k}}$ with high probability.

Lemma 5.1**.**

Consider an execution of $\textsc{RoundtripCover2}(G_{0},k,r)$ on an $\hat{n}$-vertex vertex graph $G_{0}$. Consider a recursive execution of $\textsc{RoundtripCover2}(G,k,r)$ on an $n$-vertex $m$-edge graph $G$. Consider the resulting execution $\textsc{BallGrow}(G^{\prime},k,R,D)$ (line 4). With probability at least $1-\hat{n}^{-7}$ we have that for all $v\in V(G^{\prime})$ that the number of vertices $u\in V(G^{\prime})$ satisfying

[TABLE]

is at most $n^{\frac{k-1}{k}}.$

Proof.

We follow the same approach as the proofs in Appendix B. Consider a vertex $v\in V(G)$. Define

[TABLE]

i.e. all vertices $u\in V(G)$ which would “pass” the $i$-th level similarity test for $v$. Our main claim is that if $|H_{v}^{i}|\geq n^{\frac{k-1}{k}}$, then we have that $\frac{|H_{v}^{i+1}|}{|H_{v}^{i}|}\leq\frac{9}{10}$ with high probability. This implies the result, because if $|H_{v}^{100\log\hat{n}}|\geq n^{\frac{k-1}{k}}$ still, then we have that

[TABLE]

an obvious contradiction.

Now we show that if $|H_{v}^{i}|\geq n^{\frac{k-1}{k}}$, then we have that $\frac{|H_{v}^{i+1}|}{|H_{v}^{i}|}\leq\frac{9}{10}$ with high probability. Note that by definition that $T_{v}^{i}=S^{i}\cap H_{v}^{i}$. It is direct to verify by a Chernoff bound that $|T_{v}^{i}|\geq 50\log\hat{n}$ with probability at least $1-\hat{n}^{-10}$ assuming that $|H_{v}^{i}|\geq n^{\frac{k-1}{k}}.$ By the definition of $S_{v}^{i}$ (a uniformly random subset of $T_{v}^{i}$ of size $50\log\hat{n}$) and symmetry we can think of $S_{v}^{i}$ simply as a uniformly random subset of $H_{v}^{i}$ of size $50\log\hat{n}.$

We now argue that for at least $\frac{9}{10}$ fraction of vertices in $w\in H_{v}^{i}$ we have that

[TABLE]

i.e. only $\frac{4}{5}$ fraction of vertices $w^{\prime}\in H_{v}^{i}$ satisfy $d(w,w^{\prime})\leq 2KR$. Assume the contrary for contradiction. By the Pigeonhole principle, there are at least

[TABLE]

(unordered) pairs of vertices $w,w^{\prime}\in H_{v}^{i}$ such that both $d(w,w^{\prime})\leq 2KR$ and $d(w^{\prime},w)\leq 2KR$. By the Pigeonhole principle again, there must be a vertex $w\in H_{v}^{i}$ for which at least $.44|H_{v}^{i}|$ vertices $w^{\prime}$ satisfy both $d(w,w^{\prime})\leq 2KR$ and $d(w^{\prime},w)\leq 2KR$, so $d(w,w^{\prime})\leq 4KR.$ Now, note that $.44|H_{v}^{i}|\geq.44n^{\frac{k-1}{k}}$ by our condition. We argue that this is impossible because $v$ should have been marked as not on with high probability in line 7. Indeed, the probability that $v$ failed to get marked as not on is at most

[TABLE]

as desired.

Now, consider the $\frac{9}{10}$ fraction of vertices $w\in H_{v}^{i}$ with

[TABLE]

For each of these vertices, the probability that $d(w,w^{\prime})$ for all $w^{\prime}\in S_{v}^{i}$ is at most $\left(\frac{4}{5}\right)^{50\log\hat{n}}\leq 1-\hat{n}^{-10}.$ By definition then, we have that $\frac{|H_{v}^{i+1}|}{|H_{v}^{i}|}\leq\frac{1}{10}$ by definition, as the $\frac{9}{10}$ fraction of vertices in $H_{v}^{i}$ discussed in this paragraph will with high probability not be in $H_{v}^{i+1}.$ ∎

We next claim that the ball growing scheme of Algorithm 7 satisfies some important conditions, which intuitively make the $E_{v}^{i}$ look like balls of radius $iR$.

Lemma 5.2**.**

Consider an execution of $\textsc{RoundtripCover2}(G_{0},k,R)$ on $n$-vertex $m$-edge graph $G_{0}$. Now, consider the resulting execution of $\textsc{BallGrow}(G,k,R,D)$ on graph $G$. We have that in the execution for all $v\in V(G)$ that

$v\in E_{v}^{0}$. 2. 2.

$E_{v}^{i}\subseteq E_{v}^{i+1}$* for $0\leq i\leq K-1$.* 3. 3.

For $0\leq i\leq K-1$, if $u\in E_{v}^{i}$ and $d(u\leftrightarrows u^{\prime})\leq R$, then $u^{\prime}\in E_{v}^{i+1}$.

Proof.

For the first claim, note that vertices $w\in S_{v}^{j}$ for all $j$ satisfy $d(v,w)\leq KR$ by line 11 of BuildSimilar. Therefore, $v$ satisfies all conditions of being in $E_{v}^{i}$ on line 6 of BallGrow.

The second claim is obvious from looking at the the definition of $E_{v}^{i}$ in line 6 of BallGrow.

For the third claim, note that if $u\in E_{v}^{i}$ and $d(u\leftrightarrows u^{\prime})\leq R$ then $d(v,u^{\prime})\leq d(v,u)+R=(i+1)R$. Also, for any $w\in S_{v}^{j}$ for $1\leq j\leq 100\log\hat{n}$ we have that $d(u^{\prime},w)\leq d(u,w)+R\leq(i+1+K)R.$ Hence $u^{\prime}\in E_{v}^{i+1}$ as desired. ∎

We now show the analogue to Lemma 4.2, specifically that for some iteration $0\leq i\leq K-1$ in BallGrow, we have that the condition in line 8 triggers.

Lemma 5.3**.**

Consider an execution of $\textsc{RoundtripCover2}(G_{0},k,R)$ on $n$-vertex $m$-edge graph $G_{0}$. Now, consider the resulting execution of $\textsc{BallGrow}(G,k,R,D)$ on graph $G$. For some $0\leq i\leq K-1$ we have that the condition in line 8 is true, i.e. we get a good cut.

Proof.

The computation proceeds the same way as in Lemma 4.2. Assume for contradiction that the condition in line 8 is never true, so

[TABLE]

By Lemma 5.2, we know that $|V(E_{v}^{0})|\geq 1$, as $v\in E_{v}^{0}.$ Therefore, one can check by induction that

[TABLE]

For $K=10k\log k$ we have that

[TABLE]

which contradicts Lemma 5.1. ∎

We turn to proving Theorem 8.

Proof.

We break the analysis into pieces. We show that executing $\textsc{RoundtripCover2}(G,k,R)$ on a $n$-vertex $m$-edge graph $G$ returns a $(O(k\log k),R)$ roundtrip cover $C$ with total size of all balls at most $n^{1+O\left(\frac{1}{k}\right)}$ in time $m^{1+O\left(\frac{1}{k}\right)}$ with high probability.

Returns a $(O(k\log k),R)$ roundtrip cover.

We first argue that in a call to $\textsc{BuildSimilar}(G,k,R)$ that for all vertices $v$ where we marked $\mathrm{on}[v]=\textbf{false}$ that $v$ is properly resolved, i.e. for any vertex $u$ with $d(v\leftrightarrows u)\leq R$ that $u$ and $v$ are in a roundtrip ball of radius at most $(4K+1)R.$ Indeed, note that if we mark $\mathrm{on}[v]=\textbf{false}$, then there must have been a vertex $w$ for which $w\in S^{j}$ for some $j$, and $d(v\leftrightarrows w)\leq 2KR+2KR=4KR.$ Then $d(u\leftrightarrows w)\leq(4K+1)R$. We have added the ball $B_{w}((4K+1)R)$ to our roundtrip cover $C$, as desired (line 5).

The only other piece to verify is that when we mark $\mathrm{on}[v]=\textbf{false}$ in an execution of $\textsc{BallGrow}(G,k,R,D)$ that $v$ is properly resolved, i.e. that in some recursive subproblem we have that for all $u$ with $d(v\leftrightarrows u)\leq R$ that $v$ and $u$ are in a roundtrip ball of radius at most $O(KR).$ But this holds immediately by Lemma 5.2: if $v\in E_{w}^{i}$ for some $w$, and $d(v\leftrightarrows u)\leq R$, then $u\in E_{w}^{i+1}$ as desired.

Total size of balls in $C$ is $n^{1+O\left(\frac{1}{k}\right)}$ with high probability.

The analysis here follows closely to the corresponding paragraph in Section 4. We will show that the total size of all graphs processed in a single level of recursion the algorithm is at most $n^{\frac{k}{k-1}}$, where our initial call was $\textsc{RoundtripCover2}(G,k,R)$ for a $n$-vertex $m$-edge graph $G$. Then, the total size of all graphs processed in the recursion is $\tilde{O}(n^{\frac{k}{k-1}})$, as the recursion depth is at most logarithmic. Then the bound on total size of balls in $C$ follows as for a graph $G$ with $n$ vertices, the total size of balls added to $C$ during $\textsc{BuildSimilar}(G,k,R)$ is at most

[TABLE]

To show that the total size of all graphs processed at recursion depth $\ell$ in the algorithm is at most $n^{\frac{k}{k-1}}$, we use induction. Indeed, this holds at the bottom level of recursion. Consider an execution of $\textsc{BallGrow}(G,k,R,D)$ on an $n$-vertex $m$-edge graph $G$. Let $F_{1}^{1},F_{2}^{1},\cdots,F_{t}^{1}$ be all the balls $E_{v}^{i}$ for which line 8 was satisfied (and we know that line 8 is satisfied for some $i$ by Section 5.2). Let $F_{1}^{2},F_{2}^{2},\cdots,F_{t}^{2}$ be the corresponding balls $E_{v}^{i+1}$. We have that $\sum_{i=1}^{t}|V(F_{i}^{1})|\leq n$, as we marked all vertices in $E_{v}^{i}$ as not on anymore if line 8 was satisfied for $E_{v}^{i}$ and $E_{v}^{i+1}$. Additionally, by the condition of GoodCut2, we have that $|V(F_{i}^{2})|\leq n^{\frac{1}{k}}|V(F_{i}^{1})|^{\frac{k-1}{k}}.$ By induction, the total sizes of all graphs processed at depth $\ell$ through recursion on $F_{1}^{2},F_{2}^{2},\cdots,F_{t}^{2}$ is at most

[TABLE]

as desired.

Can be implemented to run in time $m^{1+O\left(\frac{1}{k}\right)}$ with high probability.

The analysis in the above section on the total size of balls, we know that the total number of vertices in all graphs processed during the algorithm $\textsc{RoundtripCover2}(G,k,R)$ is at most $n^{1+O\left(\frac{1}{k}\right)}.$ As we have reduced to the case of regular graphs through Lemma 3.1, the total number of edges in all graphs processed during $\textsc{RoundtripCover2}(G,k,R)$ is at most $\tilde{O}(\delta n^{1+O\left(\frac{1}{k}\right)})\leq\tilde{O}(m^{1+O\left(\frac{1}{k}\right)})$ for $\delta=O(m/n).$

We now argue that the non-recursive runtime of $\textsc{RoundtripCover2}(G,k,R)$ on a graph $G$ with $n$ vertices and $m$ edges is $\tilde{O}(m^{1+1/k})$. We start by analyzing Algorithm 6 (BuildSimilar). We have that in $\textsc{BuildSimilar}(G,k,R)$ that $\sum_{i=1}^{100\log\hat{n}}|S^{i}|\leq\tilde{O}(n^{1/k})$, where $\hat{n}$ is the number of vertices in the graph at the top level of recursion. Therefore, building a shortest path tree to and from all vertices in $\bigcup_{i}S^{i}$ takes $\tilde{O}(m^{1+1/k})$ time using Dijkstra’s algorithm. Computing all the sets $T^{i}_{v}$ clearly takes time

[TABLE]

We proceed to analyze Algorithm 8 (Similar). This clearly takes $\tilde{O}(1)$ time per call, as we have precomputed all shortest path trees and distances to and from all vertices $u\in S^{i}$ in Algorithm 6. Also, Algorithm 9 (GoodCut2) also obviously takes $O(1)$ time per call.

Now we analyze Algorithm 7 (BallGrow). We can build the sets $E_{v}^{i}$ by running any search from $v$, only keeping vertices $u$ that satisfy $\textsc{Similar}(G,u,v,D,i,R).$ This takes time proportional to $\tilde{O}(\delta|E_{v}^{i+1}|)$, where we have used that each call to Similar takes $\tilde{O}(1)$ time. In accounting for this runtime, we can push the contribution to the next recursion level (as we are recursing on $E_{v}^{i+1}$). Therefore, the total non-recursive runtime used is $\tilde{O}(m^{1+1/k})$ as claimed for an input graph with $m$ edges.

Now, as the total number of edges over all graphs is $\tilde{O}(m^{1+O\left(\frac{1}{k}\right)})$, the total runtime would also be $\tilde{O}(m^{1+O\left(\frac{1}{k}\right)})$ as desired. ∎ We now use Theorem 8 to get multiplicative girth approximation and roundtrip spanners, proving Theorem 5 and Theorem 6.

Proof of Theorem 5.

We first show the result for unweighted graphs. To show this, run

[TABLE]

Now, set our estimate $g^{\prime}$ of the girth to be the smallest radius of any nontrivial ball that we had in a roundtrip cover. By the guarantees of RoundtripCover2, it is clear that $g\leq g^{\prime}\leq O(k\log k)\cdot g$ as desired. It is clear that the algorithm runs in time $\tilde{O}(m^{1+\frac{1}{k}})$ by Theorem 8. We can extend this to weighted graphs by instead taking $0\leq i\leq O(\log nW)$, where $W$ is the maximum edge weight. This can be improved to $O(\log n)$ by the same method as done in [PRS*+*18], where they give a general reduction by contracting small weight strongly connected components and deleting large weight edges (see Section 5.1 in [PRS*+*18] for more details). ∎

Proof of Theorem 6.

We first show the result for unweighted graphs. It is easy to see that

[TABLE]

is an $O(k\log k)$ spanner with $\tilde{O}(n^{1+\frac{1}{k}})$ edges by Theorem 8. It is clear that the algorithm runs in time $\tilde{O}(m^{1+\frac{1}{k}}).$ The extension to weighted graphs follows as in the above paragraph (proof of Theorem 5). ∎

6 Conclusion and Open Problems

In this paper we provided multiple results on computing round-trip spanners and multiplicative approximations to the girth of an arbitrary directed graph. Our results all either improve running times, decrease the use of randomness, or improve the approximation quality of previous results. Ultimately, this work brings the state-of-the art performance of roundtrip spanners algorithms on directed graphs closer to matching that for undirected graphs.

An immediate open problem left open by our work is to fully close the gap between algorithmic guarantees for spanners of undirected graphs and roundtrip spanners of directed graphs and provide a deterministic algorithm which for all $k$ in $\tilde{O}(mn^{1/k})$ time computes a $O(k)$ roundtrip spanner with $\tilde{O}(n^{1+1/k})$ edges. This paper resolves this problem for $k=\Omega(\log n)$ and makes progress on it for smaller values of $k$; it is still open to resolve it for all $k$.

Another key open problem is to further clarify the complexity of approximating the girth of a directed graph. Currently the only algorithms which provably outperform APSP for approximating the girth of a graph are Pachocki et. al. [PRS*+*18] and this paper. Consequently, all known girth approximation algorithms for directed graphs leverage techniques immediately applicable for spanner computation (with the sole possible exception of the algorithms of Section 3). Therefore, beyond improving roundtrip spanner routines to obtain an algorithm which can compute an $O(k)$-multiplicative approximation to the girth in $\tilde{O}(mn^{1/k})$, this suggests the even more challenging open problem of circumventing this “spanner barrier” to obtaining even faster running times. For undirected graphs, it possible to overcome this barrier in certain cases [IR77, LL09, RW12, DKS17]. However, some of the techniques used in these results are known not to extend to directed graphs, see e.g. [RW12, PRS*+*18]. Consequently, further clarifying the complexity of girth approximation beyond the spanner barrier with either improved algorithms or new conditional lower bounds remains an difficult and interesting frontier.

One final open problem is to improve the parallel complexity of these routines. Previous work on the efficient construction of roundtrip spanners [PRS*+*18] provided such a result. Further, there have been recent advances in the efficient parallel computation of reachability in directed graphs [Fin18, JLS19] and commute times of random walks. The combination of the ideas from these works with the results of this paper could be useful for obtaining further improvements for the efficient parallel computation of girth and roundtrip spanners [CKP*+*17].

7 Acknowledgements

We thank the anonymous reviewers for helpful feedback and suggestion of many of the open problems discussed in Section 6. We thank Jakub Pachocki, Liam Roditty, Roei Tov, and Virginia Vassilevska Williams for helpful discussions.

Appendix A Deferred proofs

A.1 Proof of Lemma 3.1

Proof.

The reduction is as follows. Let $\delta=\lceil{|E|/|V|}\rceil$. Replace all the outgoing edges from $v$ by a balanced $\delta$-tree with all weights of internal edges 0 (a balanced tree with degree $\delta$ where $v$ is the root of the tree and all edges of the tree are directed from the root) where each leaf in this tree is “responsible” for $d$ of the outgoing edges of $v$, that is, each leaf has $d$ outgoing edges to $\delta$ (different) neighbors of $v$. The weight of these edges are the original corresponding weight of the edges of $v$. We set the weight of all edges in the balanced $\delta$-tree to be 0. A similar process is done for the incoming edges of $v$ for every node $v\in V$. It is not hard to verify that the number of new nodes created is proportional to the number of edges divided by $\delta$, that is, the number of new nodes is $O(m/\delta)=O(n)$. In addition, every two original nodes $u$ and $v$ that have a directed path in $G$, also have a directed path in the modified graph. It is not hard to verify that all round trip distances in $G$ and $H$ are the same (this implies also that the girth of $H$ and $G$ is the same). Moreover, given a cycle $C$ in $H$ one can easily find a cycle of the same length in $G$ by simply contracting the $\delta$-trees of each vertex. Finally, given a subgraph $H^{\prime}$ of $H$, one can obtain a subgraph $G^{\prime}$ of $G$ by simply contracting the $\delta$-trees of each vertex. It is not hard to verify that all roundtrip distances (for pairs of vertices in $G$) in $H^{\prime}$ and $G^{\prime}$ are the same. ∎

Appendix B Constant Approximation Roundtrip Spanner in $\tilde{O}(m\sqrt{n})$ time

In this section we provide a procedure that given a directed weighted graph $G$ and a target distance $R$, returns in $\tilde{O}(m\sqrt{n})$ time a subgraph $H$ with $\tilde{O}(n^{3/2})$ expected number of edges such that $d_{H}(u\leftrightarrows v)\leq 8R$ for every two vertices $u$ and $v$ such that $d_{G}(u\leftrightarrows v)\leq R$.

The pseudocode of the algorithm is given in Figure 10.

B.1 Analysis

We next analyze the running time and correctness of our algorithm.

The sets $G_{i}(v)$ are defined similarly as in the previous section but restricted on vertices in $Z$. That is, for a vertex $v$, define $G_{0}(v)=\{s\in Z\mid d(v,s)\leq R/2\}$ and $G_{i}(v)=\{s\in Z\mid d(v,s)\leq R/2\text{ and }d(s,t)\leq 3R/2\text{ for all }t\in\cup_{j\in[0,...,i-1]}{R_{j}(v)}\}$.

We start with bounding the stretch of the returned spanner.

Lemma B.1**.**

For every two vertices $u$ and $v$ such that $d_{G}(u\leftrightarrows v)\leq R$, $d_{H}(u\leftrightarrows v)\leq 8R$.

Proof.

As $d_{G}(u\leftrightarrows v)\leq R$ there must be a shortest cycle $C$ of length at most $R$ that contains both $u$ and $v$. If all the vertices on $C$ belong to $Z$ then using similar analysis to the proof in Lemma 3.2 one can show that $C\subseteq A_{v}^{\mathrm{out}}\cup A_{v}^{\mathrm{in}}$. And as shortest path tree from $v$ in the induced graph $\subseteq A_{v}^{\mathrm{out}}\cup A_{v}^{\mathrm{in}}$ is added to $H$, it follows that $d_{H}(v,u)\leq d_{C}(v,u)$. Similarly, we can show that $d_{H}(u,v)\leq d_{C}(u,v)$. We now get that $d_{H}(v\leftrightarrows u)\leq d_{C}(v,u)+d_{C}(u,v)\leq R$.

Now assume there exists a vertex $x$ on $C$ such that $x\notin Z$. As $x\notin Z$ then by construction there is a vertex $y\in U$ such that $d_{G}(y\leftrightarrows x)\leq 3R$.

As the algorithm adds a shortest path tree from and to $y$ then the roundtrip distances from $y$ to all vertices in $V$ are the same in $H$ as in $G$.

We get that $d_{H}(y\leftrightarrows v)=d_{G}(y\leftrightarrows v)\leq d_{G}(y\leftrightarrows x)+d_{G}(x\leftrightarrows v)\leq 3R+R=4R$. Similarly, we can show that $d_{H}(y\leftrightarrows u)\leq 4R$. It follows that $d_{H}(u\leftrightarrows v)\leq d_{H}(y\leftrightarrows v)+d_{H}(y\leftrightarrows u)\leq 8R$, as required. ∎

We next turn to the analysis of the running time and the number of edges in the constructed spanner $H$.

We say that a vertex $v$ is $R$-cycle-rich if there are at least $50\sqrt{n}\log{n}$ other vertices $z$ such that $v$ and $z$ are on a cycle of length at most $3R$, namely, $|\{z\in V\mid d_{G}(v\leftrightarrows x)\leq 3R\}|\geq 50\sqrt{n}\log{n}$.

The next lemma shows that with high probability $Z$ does not contain any $R$-cycle-rich vertices.

Lemma B.2**.**

With probability at least $1-1/n^{9}$, $Z$ does not contain $R$-cycle-rich vertices.

Proof.

Consider an $R$-cycle-rich vertex $v$. Note that by construction if $U$ contains a vertex from the set $\{x\in V\mid d_{G}(v\leftrightarrows x)\leq 3R\}$ then $v\notin Z$. By definition we have $|\{x\in V\mid d_{G}(v\leftrightarrows x)\leq 3R\}|\geq 50\log{n}\sqrt{n}$. For a fixed vertex $x\in\{x\in V\mid d_{G}(v\leftrightarrows x)\leq 3R\}$ the probability that $x\notin U$ is $(1-p^{\prime})$ for $p^{\prime}=\frac{100\log{n}}{n^{\frac{1}{2}}}$. The probability that none of the vertices in $\{x\in V\mid d_{G}(v\leftrightarrows x)\leq 3R\}$ belongs to $U$ is $(1-p^{\prime})^{|Y|}\leq(1-\frac{100\log{n}}{n^{\frac{1}{2}}})^{50\log{n}\sqrt{n}}<1/n^{10}$.

By union bound on all $R$-cycle-rich vertices, the probability that $Z$ contains an $R$-cycle-rich vertex is at most $1/n^{9}$ ∎

The next lemma essentially shows that w.h.p. $|G_{i+1}(v)|\leq 0.8|G_{i}(v)|$ for every $v\in V$ and $i\in[M]$ such that $|G_{i}(v)|\geq 200\sqrt{n}\log{n}$.

Lemma B.3**.**

Assume $Z$ does not contain $R$-cycle-rich vertices and that for every $v$ and every $i$ all vertices in $G_{i+1}(v)$ are $(v,i)$-dense. Then, for every vertex $v$, index $i\in[M]$ such that $|G_{i}(v)|\geq 200\sqrt{n}\log{n}$ we have $|G_{i+1}(v)|\leq 0.8|G_{i}(v)|$.

Proof.

Assume, towards contradiction, that there exists a vertex $v$ and index $i$ such that $|G_{i+1}(v)|\geq 0.8|G_{i}(v)|$.

Similarly to the proof of Lemma 3.3, let $H^{\prime}$ be the directed graph $H^{\prime}$ whose set of vertices is $G_{i}(v)$ and set of edges is the following. For every vertex $u$ in $G_{i}(v)$ add an outgoing edge for every vertex $s$ such that $d(u,s)\leq 3R/2$. And as was shown in Lemma 3.3 the number of edges in $E(H^{\prime})$ is at least $0.71|G_{i}(v)|^{2}$, that is, $|E(H^{\prime})|\geq 0.71|G_{i}(v)|^{2}$.

We again give a credit of half for the endpoint of every edge in $H^{\prime}$. As there are no $R$-cycle-rich vertices we claim that the maximal credit a vertex $z$ can get is less than $|G_{i}(v)|/2+50\log{n}\sqrt{n}/2\leq|G_{i}(v)|/2+|G_{i}(v)|/8=5|G_{i}(v)|/8$. To see this, note there are less than $50\log{n}\sqrt{n}$ vertices in $G_{i}(v)$ for which $z$ has both incoming and outgoing edge, so at most $50\log{n}\sqrt{n}$ credit for these vertices. For the rest of the vertices $y$ in $G_{i}(v)$ the maximum credit for $z$ is $1/2$ (as there could be at most one incident edge between $y$ and $z$ ). Overall, we get that the total credit of $z$ is less than $|G_{i}(v)|/2+50\log{n}\sqrt{n}/2\leq 5|G_{i}(v)|/8$.

It follows that the total credit for all vertices, which is equal to the number of edges in $H^{\prime}$, is less than $5|G_{i}(v)|^{2}/8<0.71|G_{i}(v)|^{2}$, contradiction. ∎

The next lemma shows that the shortest path tree $T(v)$ for a vertex $v\in Z$ constructed in Line 13 of the algorithm contains w.h.p. at most $200\sqrt{n}\log{n}$. This lemma will be used both to prove our running time and the total number of edges in the constructed spanner $H$.

Lemma B.4**.**

With probability at least $1-1/n^{8}$ the shortest paths tree $T(v)$ contains at most $200\sqrt{n}\log{n}$ vertices for every $v\in V$.

Proof.

By Lemma B.2 with probability at least $1/1-n^{9}$, $Z$ does not contain $R$-cycle-rich vertices.

By union bound on all vertices $v\in V$ on Lemma  3.3 (that also applies here), with probability at least $1-2/n^{9}$, all vertices in $G_{i+1}(v)$ are $(v,i)$-dense.

That is, with probability at least $1-(1/n^{9}+2/n^{9})>1-1/n^{8}$ both

1. $Z$ does not contain $R$-cycle-rich vertices and
2. all vertices $u\in G_{i+1}(v)$ are $(v,i)$-dense for every $v\in Z$ and $i\in[M]$.

Assume this indeed the case.

By Lemma B.3 for every vertex $v$, index $i\in[M]$ such that $|G_{i}(v)|\geq 200\sqrt{n}\log{n}$ we have $|G_{i+1}(v)|\leq 0.8|G_{i}(v)|$.

Consider such a vertex $v\in Z$. As $G_{i+1}(v)\subseteq G_{i}(v)$ and $|G_{i+1}(v)|\leq 0.8|G_{i}(v)|$ for every $i\in[M]$ then this implies that there exists an index $M^{\prime}$ in $[M]$ such that $|G_{M^{\prime}}(v)|<200\sqrt{n}\log{n}$. As the shortest path tree $T(v)$ contains only vertices from $G_{M^{\prime}}(v)$ the lemma follows. ∎

Lemma B.5**.**

The expected running time of Algorithm SpannerApprox is $O(m\sqrt{n}\log{n}+n\sqrt{n}\log^{3}{n})=\tilde{O}(m\sqrt{n})$.

Proof.

Procedure SpannerApprox invokes twice Procedure SimilarSetSpanner on the graph $G$ and on the reversed graph of $G$.

Consider one call for Procedure SpannerApprox. The expected size of the set $U$ is $O(\log{n}\sqrt{n})$. For each vertex $v$ in $U$ the algorithm computes Dijkstra in $O(m+n\log{n})$ time. Therefore the expected time for computing Dijkstra from all vertices in $U$ is $O(m\sqrt{n}\log{n}+n\sqrt{n}\log^{2}{n})$.

As in the analysis of Lemma 3.5 computing Dijkstra from all vertices in $\cup_{i\in M}{S_{i}}$ takes additional $O(m\sqrt{n}\log{n}+n\sqrt{n}\log^{2}{n})$ time.

By Lemma B.4 with probability at least $1-1/n^{8}$ the shortest paths tree $T(v)$ contains at most $200\sqrt{n}\log{n}$ vertices for every $v\in Z$. Hence, with probability $1-1/n^{8}$ computing all trees take $O(n\sqrt{n}\delta\log{n})=O(m\sqrt{n}\log{n})$.

With probability at most $1/n^{8}$ there exists a tree $T(v)$ that contains more $200\sqrt{n}\log{n}$, in any case the total computation in this case is bounded by $O(mn)$. Since this happens with small probability it does effect the asymptotic bound of the expected running time.

The lemma follows. ∎

Finally, we conclude that the number of edges in the constructed spanner $H$ is $\tilde{O}(n^{3/2})$

Lemma B.6**.**

The expected number of edges in the constructed spanner $H$ is $O(n^{3/2}\log{n})$.

Proof.

First note that Procedure SpannerApprox adds the set of edges $H^{\mathrm{out}}$ and $H^{\mathrm{in}}$ returned from the calls to Procedure SimilarSetSpanner to the spanner $H$.

We show that $H^{\mathrm{out}}$ (similarly $H^{\mathrm{in}}$) contains in expectation $O(n^{3/2}\log{n})$ number of edges. The expected size of the set $U$ is $O(\sqrt{n}\log{n})$ for each vertex $v$ in $U$ the algorithm adds $O(n)$ edges (for the shortest path from $v$ and to $v$). Thus, $O(n^{3/2}\log{n})$ edges are added to $H^{\mathrm{out}}$ for all vertices in $U$.

Procedure SpannerApprox adds for every vertex $v\in Z$ a shortest paths tree in the induced graph of $A_{v}^{\mathrm{out}}\cup A_{v}^{\mathrm{in}}$. By Lemma B.4 with probability at least $1-1/n^{8}$ the set $A_{v}^{\mathrm{out}}\cup A_{v}^{\mathrm{in}}$ contains at most $O(\sqrt{n}\log{n})$ vertices for every $v\in V$. Hence, with probability at least $1-1/n^{8}$ the number of edges in each tree $T(v)$ is at most $O(\sqrt{n}\log{n})$ for every $v\in Z$. Therefore, at most $O(n^{3/2}\log{n})$ number of edges added to $H$ in total.

With probability at most $1/n^{8}$ there is a vertex $v$ such that $A_{v}^{\mathrm{out}}\cup A_{v}^{\mathrm{in}}$ contains more than $O(\sqrt{n}\log{n})$ vertices. In any case the number of edges added to $H$ in this case is bounded by $m$ and since this happens with very small probability it does not affect the asymptotic bound of the expected size of the spanner. The lemma follows. ∎

We conclude this section with a proof of Theorem 2.

Proof of Theorem 2.

The algorithm invokes procedure $\textsc{SpannerApprox}(G,R)$ for every $R=(1+\epsilon)^{i}$ and takes as a spanner the union of the returned spanners from all these calls.

Now, the theorem easily follows from Lemmas B.1, B.5 and B.6. ∎