New algorithms for girth and cycle detection

Let $G=(V,E)$ be an unweighted undirected graph with $n$ vertices and $m$ edges. A set of vertices $C_{\ell}=\{v_{1},v_{2},\cdots,v_{\ell+1}\}$ in $G$, where $\ell\geq 2$, is a cycle of length $\ell$ if $v_{1}=v_{\ell+1}$ and $(v_{i},v_{i+1})\in E$, where $1\leq i\leq\ell$. A $C_{\leq\ell}$ is a cycle of length at most $\ell$. The girth $g$ of $G$ is the length of a shortest cycle in $G$. The girth of a graph has been studied extensively since the 1970s by researchers from both the graph theory and the algorithms communities.

Itai and Rodeh [6] showed that the girth can be computed in $O(mn)$ time or in $O(n^{\omega})$ time, where $\omega<2.371552$ [13], if Fast Matrix Multiplication (FMM) algorithms are used. They also proved that the problem of computing the girth is equivalent to the problem of deciding whether there is a $C_{3}$ (triangle) in the graph or not.

Interestingly, there is a close connection between the girth problem and the All Pairs Shortest Path (APSP) problem. Vassilevska W. and Williams [12] proved that a truly subcubic time algorithm that computes the girth, without FMM, implies a truly subcubic time algorithm that computes APSP, without FMM. Such an algorithm for APSP would be a major breakthrough. In light of this girth and APSP connection, it is natural to settle for an approximation algorithm for the girth instead of exact computation. An $(\alpha,\beta)$-approximation $\hat{g}$ of $g$ (where $\alpha\geq 1$ and $\beta\geq 0$), satisfies $g\leq\hat{g}\leq\alpha\cdot g+\beta$. We denote an approximation as an $\alpha$-approximation if $\beta=0$ and as a $(+\beta)$-approximation if $\alpha=1$.

Itai and Rodeh [6] presented a $(+1)$-approximation algorithm that runs in $O(n^{2})$ time. Notice that in contrast to the APSP problem, where a running time of $\Omega(n^{2})$ is inevitable since the output size is $\Omega(n^{2})$, in the girth problem the output is a single number, thus, there is no natural barrier for sub-quadratic time algorithms. Indeed, Lingas and Lundell [8] presented a $\frac{8}{3}$-approximation algorithm that runs in $\tilde{O}(n^{3/2})$ time, and Roditty and V. Williams [11] presented a $2$-approximation algorithm that runs in $\tilde{O}(n^{5/3})$ time. Dahlgaard, Knudsen and Stöckel [5] presented two tradeoffs between running time and approximation. One generalizes the algorithms of [8, 11] and computes a cycle of length at most $2\lceil\frac{g}{2}\rceil+2\lceil\frac{g}{2(\ell-1)}\rceil$ in $\tilde{O}(n^{2-1/\ell})$ time. The other computes, whp, a $C_{\leq 2^{\ell}g}$, for any integer $\ell\geq 2$, in $\tilde{O}(n^{1+1/\ell})$ time.

Kadria et al. [7] significantly improved upon the second algorithm of [5] and presented an algorithm, that for every integer $\ell\geq 1$, computes a $C_{\leq 2\ell\lceil g/2\rceil}$ in $\tilde{O}(n^{1+1/\ell})$ time. They also presented an algorithm, that for every $\varepsilon\in(0,1)$, computes a cycle of length at most $4\lceil\frac{g}{2}\rceil-2\lfloor\varepsilon\lceil\frac{g}{2}\rceil\rfloor\leq(2-\varepsilon)g+4$, in $\widetilde{O}(n^{1+1/(2-\varepsilon)})$ time, for every graph with $g={\rm polylog}(n)$.

These two algorithms of Kadria et al., as well as few other approximation algorithms (see for example, [8], [3], [9]), were obtained using a general framework for girth approximation in which a search is performed over the range of possible values of $g$, using some algorithm $\mathcal{A}$ that gets as an input an integer $\tilde{g}$ which is a guess for the value of $g$. In each step of the search $\mathcal{A}$ either returns a cycle $C_{\leq f(\tilde{g})}$, where $f$ is a non decreasing function, or determines that $g>\tilde{g}$. The goal of the search is to find the smallest $\tilde{g}$, for which $\mathcal{A}$ returns a cycle, because for this value we have $g>\tilde{g}-1$ (and thus $g\geq\tilde{g}$), and algorithm $\mathcal{A}$ returns a $C_{\leq f(\tilde{g})}$. This cycle is of length at most $f(g)$ since $g\geq\tilde{g}$ and $f$ is a non decreasing function. The two possible outcomes of $\mathcal{A}$ and its usage in the general girth approximation framework inspired us to formally define the notion of a $(\gamma,\delta)$-hybrid algorithm as follows:

When $\gamma=\delta$, the algorithm is referred to as a $\gamma$-hybrid algorithm. The girth approximation framework described above suggests that a possible approach for developing efficient girth approximation algorithms is by developing efficient $(\gamma,\delta)$-hybrid algorithms.

Kadria et al. [7] designed several algorithms that satisfy the definition of $(\gamma,\delta)$-hybrid algorithms. Their girth approximation algorithms mentioned above were obtained using two different $(f(\tilde{g}),\tilde{g})$-hybrid algorithms. Additionally, for every $k\geq 2$, they presented a $(2k,3)$-hybrid and a $(2k,4)$-hybrid algorithms that run in $O(\min\{n^{1+2/k},m^{1+1/(k+1)}\})$ time, and a $(\max\{2k,g\},5)$-hybrid algorithm that runs in $O(\min\{n^{1+3/k},m^{1+2/(k+1)}\})$ time. Therefore, for $k\geq 2$, $\tilde{g}\in\{3,4,5\}$ and $\alpha=\lceil\frac{\tilde{g}}{2}\rceil$, there is a $(\max\{2k,g\},\tilde{g})$-hybrid algorithm that runs in $O(\min\{n^{1+\frac{\alpha}{k}},m^{1+\frac{\alpha-1}{k+1}}\})$ time. A natural question is whether these three algorithms are only part of a general tradeoff between the running time, $\gamma$ and $\delta$.

In this paper we present a $(\max\{2k,g\},\tilde{g})$-hybrid algorithm that runs, whp, in $O((\frac{k+1}{\alpha-1}+\alpha)\cdot\min\{n^{1+\frac{\alpha}{k}},m^{1+\frac{\alpha-1}{k+1}}\})$ time. This algorithm provides an affirmative answer to Problem 1.1, albeit the $(\frac{k+1}{\alpha-1}+\alpha)$ factor in the running time.

Using our $(\max\{2k,g\},\tilde{g})$-hybrid algorithm we obtain a generalization of the $\widetilde{O}(n^{1+1/(2-\varepsilon)})$ time algorithm of Kadria et al. [7] that computes a cycle of length at most $4\lceil\frac{g}{2}\rceil-2\lfloor\varepsilon\lceil\frac{g}{2}\rceil\rfloor\leq(2-\varepsilon)g+4$. Our generalized algorithm runs in $\tilde{O}(\ell\cdot n^{1+1/(\ell-\varepsilon)})$ time, whp, and returns a cycle of length at most $2\ell\lceil\frac{g}{2}\rceil-2\lfloor\varepsilon\lceil\frac{g}{2}\rceil\rfloor\leq(\ell-\varepsilon)g+\ell+2$, where $\ell\geq 2$ is an integer and $\varepsilon\in[0,1]$, for every graph with $g={\rm polylog}(n)$. We also show that if the graph is sparse then the approximation can be improved. More specifically, we present an algorithm that runs in $\tilde{O}(\ell\cdot m^{1+1/(\ell-\varepsilon)})$ time, whp, and returns a cycle of length at most $(\ell-\varepsilon)g-\ell+2\varepsilon$, where $\ell\geq 3$ is an integer and $\varepsilon\in[0,1)$, for every graph with $g={\rm polylog}(n)$.

Our $\tilde{O}(\ell\cdot n^{1+1/(\ell-\varepsilon)})$-time algorithm also generalizes the $\tilde{O}(n^{1+1/\ell})$-time algorithm of Kadria et al. [7], which computes a $C_{\leq 2\ell\lceil g/2\rceil}$ for every integer $\ell\geq 1$. In our algorithm, the integer parameter $\ell$ that appears in the exponent of the running time is replaced by a real-valued parameter $\ell-\varepsilon$. Thus, we introduce many new points on the tradeoff curve between running time and approximation ratio. Specifically, for every integer $\ell\leq{\rm polylog}(n)$, up to $\lceil g/2\rceil-1$ additional tradeoff points are added (since for every such $\ell$, when $\varepsilon$ is a multiple of $\frac{1}{\lceil g/2\rceil}$, we get a $\tilde{O}(n^{1+1/(\ell-\varepsilon)})$-time algorithm which computes a $C_{\leq 2(\ell-\varepsilon)\lceil g/2\rceil}$). For example, consider $\ell=3$ and a graph with girth $g=5$ or $g=6$. Our algorithm yields two additional points on the tradeoff curve, corresponding to $\varepsilon=\frac{1}{3}$ and $\varepsilon=\frac{2}{3}$. For $\varepsilon=\frac{1}{3}$, we compute a $C_{\leq 16}$ in $\tilde{O}(n^{1+\frac{3}{8}})$ time, and for $\varepsilon=\frac{2}{3}$, we compute a $C_{\leq 14}$ in $\tilde{O}(n^{1+\frac{3}{7}})$ time. These points lie between the two points on the tradeoff curve given by the algorithm of Kadria et al. [7], which computes either a $C_{\leq 12}$ in $\tilde{O}(n^{1+\frac{3}{6}})$ time or a $C_{\leq 18}$ in $\tilde{O}(n^{1+\frac{3}{9}})$ time. See Figure 1 for a comparison.

The tradeoff curve to which we add new points encompasses many known algorithms, including those of Itai and Rodeh [6], Lingas and Lundell [8], and Kadria et al. [7] (and those of Roditty and V. Williams [11] for $g=4c$ and $g=4c-1$ when $c\geq 1$ is an integer, and Dahlgaard et al. [5] for some values of $g$ and $\ell$). Notably, some of these algorithms have resisted improvement for many years. The addition of new points to this curve reinforces the possibility that it captures a fundamental relationship between running time and approximation quality. This, in turn, motivates further investigation into whether a matching lower bound exists for this tradeoff.

The rest of this paper is organized as follows. In Section 2 we provide an overview. Preliminaries are in Section 3. In Section 4, we present a new cycle searching technique that is used by our algorithms. In Section 5 we present a $2k$-hybrid algorithm and then use it to obtain a $(+1)$-approximation algorithm for the girth. In Section 6 we generalize the $2k$-hybrid algorithm and present a $(\max\{2k,g\},\tilde{g})$-hybrid algorithm. In Section 7 we use the hybrid algorithm from Section 6 to obtain two more approximation algorithms for the girth.

Among the techniques that we develop to obtain our new algorithms, is a new cycle searching technique that might be of independent interest. Our new technique exploits the property that if $s\in V$ is not on a $C_{\leq 2k}$, then for any two neighbors $x$ and $y$ of $s$, the set of vertices at distance exactly $k-1$ from $x$ and $y$ that are also at distance $k$ from $s$ are disjoint (see Figure 2). This allows us to check efficiently for all the neighbors of $s$ if they are on a $C_{\leq 2k}$. Using this technique, together with more tools that we develop, we obtain two hybrid algorithms.

The first is a relatively simple $O(m^{1+\frac{k-1}{k+1}})$-time, $2k$-hybrid algorithm. We use this hybrid algorithm in the girth approximation framework described earlier, to obtain an $\tilde{O}(m^{1+\frac{\ell-1}{\ell+1}})$-time, $(+1)$-approximation of the girth, where $g=2\ell$ or $g=2\ell-1$. We remark that using an algorithm of [4] it is possible to obtain a $(+1)$-approximation in $\tilde{O}(\ell^{O(\ell)}\cdot m^{1+\frac{\ell-1}{\ell+1}})$ time.¹¹1[4] showed that a $C_{2k}$, if exists, can be found in $O(k^{O(k)}\cdot m^{\frac{2k}{k+1}})$ time, and if not then a $C_{2k-1}$, if exists, can be found in the same time. Thus, if we run their algorithm with increasing values of $k$ we can obtain a $(+1)$-approximation for the girth in $\tilde{O}(\ell^{O(\ell)}\cdot m^{1+\frac{\ell-1}{\ell+1}})$ time, where $g=2\ell$ or $g=2\ell-1$. However, the additional $\ell^{O(\ell)}$ factor might be significant even for small values of $\ell$.

The second is the $(\max\{2k,g\},\tilde{g})$-hybrid algorithm that solves Problem 1.1. Its main component is an $(2k,2\alpha)$-hybrid algorithm that runs in $\tilde{O}((\frac{k+1}{\alpha-1}+\alpha)\cdot m^{1+\frac{\alpha-1}{k+1}})$-time, whp, and generalizes the first $O(m^{1+\frac{k-1}{k+1}})$-time $2k$-hybrid algorithm, by introducing an additional parameter $\alpha\leq k$. Using $\alpha$ we can tradeoff between the running time and the lower bound on $g$ and obtain a faster running time at the price of a worse lower bound.

We compare our $(2k,2\alpha)$-hybrid algorithm to algorithm Cycle of Kadria et al. [7], an $O(m+n^{1+\frac{1}{\ell}})$-time²²2 Cycle runs in $O(n^{1+\frac{1}{\ell}}+m)$ time, which can be reduced to $O(n^{1+\frac{1}{\ell}})$ time, as shown in [7]. $(f(\tilde{g}),\tilde{g})$-hybrid algorithm, where $f(\tilde{g})=2\ell\lceil\tilde{g}/2\rceil=2\ell\alpha$, that they used to obtain the $\tilde{O}(n^{1+\frac{1}{\ell}})$-time, $2\ell\lceil g/2\rceil$-approximation algorithm. As we show later, the running time of our $(2k,2\alpha)$-hybrid algorithm can be bounded by $\tilde{O}((\frac{k+1}{\alpha-1}+\alpha)\cdot n^{1+\frac{\alpha}{k}})$. Since in our algorithm $k$ is not necessarily a multiple of $\alpha$ (compared to the $\ell\alpha$ of Cycle), our algorithm allows more flexibility, and we achieve many more possible tradeoffs between the running time and the output cycle length. For example, if we consider a multiplicative approximation better than $3$, when the value of $g$ is a constant known in advance, our algorithm can return longer cycles that are still shorter than $3g$, in a faster running time. See Figure 3 for a comparison.³³3 [7] presented also an $O((\alpha-c)\cdot n^{1+\frac{\alpha}{2\alpha-c}})$-time, $(4\alpha-2c,2\alpha)$-hybrid algorithm, where $0<c\leq\alpha$ are integers. For $c=2\alpha-k$, this is an $O((k-\alpha)\cdot n^{1+\frac{\alpha}{k}})$-time, $(2k,2\alpha)$-hybrid algorithm, similar to our $(2k,2\alpha)$-hybrid algorithm. However, since $0<c\leq\alpha$, the possible values of $k$ are restricted and must satisfy $\alpha\leq k<2\alpha$. By choosing $\alpha=\lceil\frac{g}{2}\rceil$ and an appropriate $k$ the two algorithms have a similar flexibility for a $2$-approximation, but since in our algorithm also larger values of $k$ are allowed, we can achieve a faster running time for a $t$-approximation where $t>2$.

The flexibility of our algorithm is also demonstrated in Figure 4. For a given constant value of $k$, if our $(2k,2\alpha)$-hybrid algorithm returns a cycle then its length is at most $2k$. If we want algorithm Cycle to output a $C_{\leq 2k}$, then $\lfloor\frac{k}{\alpha}\rfloor$ is the largest $\ell$ that we can choose, since $\ell$ must be an integer. The running time is $O(n^{1+1/\ell})=O(n^{1+1/\lfloor\frac{k}{\alpha}\rfloor})$. Our algorithm achieves a better running time if $k$ is not divisible by $\alpha$. (In Figure 4 we choose $\alpha=3$.)

Next, we overview our $(2k,2\alpha)$-hybrid algorithm that either finds a $C_{\leq 2k}$ or determines that $g>2\alpha$ in $\tilde{O}((\frac{k+1}{\alpha-1}+\alpha)\cdot m^{1+\frac{\alpha-1}{k+1}})$ time. To determine that $g\geq 2\alpha$, we can check for every $v\in V$ if $v$ is on a $C_{\leq 2\alpha}$. If $v$ is on a $C_{\leq 2\alpha}$, then all the vertices and edges of this $C_{\leq 2\alpha}$ are at distance at most $\alpha$ from $v$. If, for every $v\in V$, the number of edges at distance at most $\alpha$ is $O(deg(v)\cdot m^{\frac{\alpha-1}{k+1}})$ then using standard techniques we can check for every $v\in V$ if $v$ is on a $C_{\leq 2\alpha}$ in $O(m^{1+\frac{\alpha-1}{k+1}})$ time. However, this is not necessarily the case, and the region at distance at most $\alpha$ from some vertices might be dense. To deal with dense regions within the promised running time we develop an iterative sampling procedure (see BfsSample in Section 6), whose goal is to sparsify the graph, or to return a $C_{\leq 2k}$. One component of the iterative sampling procedure is a generalization of our new cycle searching technique mentioned above. In the generalization instead of checking whether a vertex $s$ and its neighbors are on a $C_{\leq 2k}$, we check whether all the vertices up to a possibly further distance from $s$ are on a $C_{\leq 2\alpha}$, for $\alpha\leq k$, and if not we mark them so that they can be removed later.

If the iterative sampling procedure ends without finding a $C_{\leq 2k}$ then there are two possibilities. Let $r=(k+1)\bmod(\alpha-1)$. If $r=0$ then it holds that the number of edges at distance at most $\alpha$ from every $v\in V$ is $O(deg(v)\cdot m^{\frac{\alpha-1}{k+1}})$, whp, as required. If $r>0$ then it holds that the number of edges at distance at most $r$ from every $v\in V$ is $O(m^{\frac{r}{k+1}})$, whp. This does not necessarily imply that the graph is sparse enough for checking whether $g>2\alpha$. In this case, we run another algorithm (see HandleReminder in Section 6) that continues to sparsify the graph until the number of edges at distance at most $\alpha$ from every $v\in V$ is $O(deg(v)\cdot m^{\frac{\alpha-1}{k+1}})$ and checking whether $g>2\alpha$ is possible within the required running time of $O(m^{1+\frac{\alpha-1}{k+1}})$.

Let $G=(V,E)$ be an unweighted undirected graph with $n$ vertices and $m$ edges. Let $U\subseteq V$ be a set of vertices and let $G\setminus U$ be the graph obtained from $G$ by deleting all the vertices of $U$ together with their incident edges. For two graphs $G=(V,E)$ and $G^{\prime}=(V^{\prime},E^{\prime})$, let $G\setminus G^{\prime}$ be $G\setminus V^{\prime}$. We say that $G\subseteq G^{\prime}$ if $V\subseteq V^{\prime}$ and $E\subseteq E^{\prime}$. For convenience, we use both $u\in V$ and $u\in G$ to say that $u\in V$. For every $u,v\in V$, let $d_{G}(u,v)$ be the length of a shortest path between $u$ and $v$ in $G$. The girth $g$ of $G$ is the length of a shortest cycle in $G$. Let $wt(C)$ be the length of a cycle $C$. For an integer $\ell$, we denote a cycle of length (at most) $\ell$ by ($C_{\leq\ell}$) $C_{\ell}$.⁴⁴4Both $C_{\ell}$ and $C_{\leq\ell}$ might not be simple cycles. However, the cycles that our algorithms return are simple. Let $E(v)$ be the edges incident to $v$ and $E(v,i)$ the $i$th edge in $E(v)$. Let $deg_{G}(v)$ be the degree of $v$ in $G$. Let $N(v)$ be the set of neighbors of $v$, namely $N(v)=\{w\mid(v,w)\in E\}$. For an edge set $S$, let $V(S)$ be the endpoints of $S$’s edges, that is, $V(S)=\{u\in V\mid\exists(u,v)\in S\}$. Let $e=(u,v)\in E$ and $w\in V$. The distance $d_{G}(w,e)$ between $w$ and $e$ is $\min\{d_{G}(w,u),d_{G}(w,v)\}+1$. For every $u\in V$ and a real number $k$ let $B(G,u,k)=(V_{u}^{k}(G),E_{u}^{k}(G))$ be the ball graph of $u$, where $V_{u}^{k}(G)=\{v\in V\mid d_{G}(u,v)\leq k\}$ and $E_{u}^{k}(G)=\{e\in E\mid d_{G}(u,e)\leq k\}$ [7].⁵⁵5When the graph is clear from the context, we sometimes omit $G$ from the notations.

We now turn to present several essential tools that are required in order to obtain our new algorithms. We first restate an important property of the ball graph $B(v,R)$.

We use procedure $\texttt{BallOrCycle}(G,v,R)$ [7, 8] (see Algorithm 1) that searches for a $C_{\leq 2R}$ in the ball graph $B(v,R)$. We summarize the properties of BallOrCycle in the next lemma.

Next, we obtain a simple $t$-hybrid algorithm, called AllVtxBallOrCycle, using BallOrCycle. AllVtxBallOrCycle (see Algorithm 2) gets a graph $G$ and an integer $t\geq 2$, and runs $\texttt{BallOrCycle}(v,t)$ from every $v\in G$ as long as no cycle is found by BallOrCycle. If BallOrCycle finds a cycle then AllVtxBallOrCycle stops and returns that cycle. If no cycle is found then AllVtxBallOrCycle returns null. We prove the next Lemma.

We now show that if the input graph satisfies a certain sparsity property then the running time of $\texttt{AllVtxBallOrCycle}(G,t)$ can be bounded as follows.

Next, we present procedure $\texttt{IsDense}(G,w,T,r)$ from [7]. IsDense (see Algorithm 3) gets a graph $G$, a vertex $w$, a budget $T\geq 1$ (real) and a distance $r\geq 0$ (integer). In the procedure a BFS is executed from $w$. The BFS counts the edges that are scanned as long as their total number is less than $T$ and the farthest vertex from $w$ is at distance at most $r$.