Improved Algorithms for Computing the Cycle of Minimum Cost-to-Time Ratio in Directed Graphs

TL;DR

This paper introduces new algorithms for finding the minimum cost-to-time ratio cycle in directed graphs, improving efficiency especially for sparse graphs and graphs with certain structures, with applications in optimization and verification.

Contribution

It presents the first improvement over Megiddo's classic algorithm for sparse graphs and introduces parallel algorithms for negative cycle detection and shortest paths.

Findings

Achieved a running time of  O(m^{3/4} n^{3/2}) for sparse graphs

Developed an algorithm with n^3 / 2^{\u03a9(\u221a{\log n})} time for general graphs

Created an  O(n) time algorithm for graphs with constant treewidth

Abstract

We study the problem of finding the cycle of minimum cost-to-time ratio in a directed graph with $ n $ nodes and $ m $ edges. This problem has a long history in combinatorial optimization and has recently seen interesting applications in the context of quantitative verification. We focus on strongly polynomial algorithms to cover the use-case where the weights are relatively large compared to the size of the graph. Our main result is an algorithm with running time $ \tilde O (m^{3/4} n^{3/2}) $, which gives the first improvement over Megiddo's $ \tilde O (n^3) $ algorithm [JACM'83] for sparse graphs. We further demonstrate how to obtain both an algorithm with running time $ n^3 / 2^{\Omega{(\sqrt{\log n})}} $ on general graphs and an algorithm with running time $ \tilde O (n) $ on constant treewidth graphs. To obtain our main result, we develop a parallel algorithm for negative cycle detection and single-source shortest paths that might be of independent interest.

Equations

$$\mathcal{S}=\{V({\pi }^{\lfloor h/2\rfloor }(u,v))\mid u,v\in V\text{ with }{d}_G^{\lfloor h/2\rfloor }(u,v)<\infty \text{ and }|E({\pi }^{\lfloor h/2\rfloor }(u,v))|=\lfloor h/2\rfloor \}$$

$$d_G(s,t)=\sum _{0\le i\le k-1}{d}_G(x_i,x_{i+1})$$

$$\displaystyle=\Big{(}\sum_{0\leq i\leq k-2}w_{H}(x_{i},x_{i+1})\Big{)}+d_{G}^{h}(x_{k-1},t)$$

$$\ge d_H(x_0,x_{k-1})+d_G^h(x_{k-1},t)$$

$$=d_H(s,x_{k-1})+d_G^h(x_{k-1},t)$$

$$\ge \underset{x\in C\cup \{s\}}{\min }(d_H(s,x)+d_G^h(x,t))=\delta (t).\text{qed}$$

Full text

1 Introduction

We revisit the problem of computing the cycle of minimum cost-to-time ratio (short: minimum ratio cycle) of a directed graph in which every edge has a cost and a transit time. The problem has a long history in combinatorial optimization and has recently become relevant to the computer-aided verification community in the context of quantitative verification and synthesis of reactive systems [Cha+03, CDH10, DKV09, Blo+09, Cer+11, Blo+14, CIP15]. The shift from quantitative to qualitative properties is motivated by the necessity of taking into account the resource consumption of systems (such as embedded systems) and not just their correctness. For algorithmic purposes, these systems are usually modeled as directed graphs where vertices correspond to states of the system and edges correspond to transitions between states. Weights on the edges model the resource consumption of transitions. In our case, we allow two types of resources (called cost and transit time) and are interested in optimizing the ratio between the two quantities. By giving improved algorithms for finding the minimum ratio cycle we contribute to the algorithmic progress that is needed to make the ideas of quantitative verification and synthesis applicable.

From a purely theoretic point of view, the minimum ratio problem is an interesting generalization of the minimum mean cycle problem.222In the minimum cycle mean problem we assume the transit time of each edge is $1$. A natural question is whether the running time for the more general problem can match the running time of computing the minimum cycle mean (modulo lower order terms). In terms of weakly polynomial algorithms, the answer to this question is yes, since a binary search over all possible values reduces the problem to negative cycle detection. In terms of strongly polynomial algorithms, with running time independent of the encoding size of the edge weights, the fastest algorithm for the minimum ratio cycle problem is due to Megiddo [Meg83] and runs in time $\tilde{O}(n^{3})$, whereas the minimum mean cycle can be computed in $O(mn)$ time with Karp’s algorithm [Kar78]. This has left an undesirable gap in the case of sparse graphs for more than three decades.

Our results.

We improve upon this situation by giving a strongly polynomial time algorithm for computing the minimum ratio cycle in time $O(m^{3/4}n^{3/2}\log^{2}n)$ (Theorem 4.3 in Section 4). We obtain this result by designing a suitable parallel negative cycle detection algorithm and combining it with Megiddo’s parametric search technique [Meg83]. We first present a slightly simpler randomized version of our algorithm with one-sided error and the same running time (Theorem 3.6 in Section 3).

As a side result, we develop a new parallel algorithm for negative cycle detection and single-source shortest paths (SSSP) that we use as a subroutine in the minimum ratio cycle algorithm. This new algorithm has work $\tilde{O}(mn+n^{3}h^{-3})$ and depth $O(h)$ for any $\log{n}\leq h\leq n$. Our algorithm uses techniques from the parallel transitive closure algorithm of Ullman and Yannakakis [UY91] (in particular as reviewed in [KS97]) and our contribution lies in extending these techniques to directed graphs with positive and negative edge weights. In particular, we partially answer an open question by Shi and Spencer [Spe97] who previously gave similar trade-offs for single-source shortest paths in undirected graphs with positive edge weights. We further demonstrate how the parametric search technique can be applied to obtain minimum ratio cycle algorithms with running time $\tilde{O}(n)$ on constant treewidth graphs (Corollary 5.3 in Section 5). Our algorithms do not use fast matrix multiplication. We finally show that if fast matrix multiplication is allowed then slight further improvements are possible, specifically we present an $n^{3}/2^{\Omega{(\sqrt{\log n})}}$ time algorithm on general graphs (Corollary 6.2 in Section 6).

Prior Work.

The minimum ratio problem was introduced to combinatorial optimization in the 1960s by Dantzig, Blattner, and Rao [DBR67] and Lawler [Law67]. The existing algorithms can be classified according to their running time bounds as follows: strongly polynomial algorithms, weakly polynomial algorithms, and pseudopolynomial algorithms. In terms of strongly polynomial algorithms for finding the minimum ratio cycle we are aware of the following two results:

• •

$O(n^{3}\log{n}+mn\log^{2}{n})$ time using Megiddo’s second algorithm [Meg83] together with Cole’s technique to reduce a factor of $\log{\log{n}}$ [Col87],

• •

$O(mn^{2})$ time using Burn’s primal-dual algorithm [Bur91].

For the class of weakly polynomial algorithms, the best algorithm is to follow Lawler’s binary search approach [Law67, Law76], which solves the problem by performing $O(\log{(nW)})$ calls to a negative cycle detection algorithm. Here $W=O(CT)$ if the costs are given as integers from $1$ to $C$ and the transit times are given as integers from $1$ to $T$. Using an idea for efficient search of rationals [Pap79], a somewhat more refined analysis by Chatterjee et al. [CIP15] reveals that it suffices to call the negative cycle detection algorithm $O(\log(|a\cdot b|))$ times when the value of the minimum ratio cycle is $\tfrac{a}{b}$. Since the initial publication of Lawler’s idea, the state of the art in negative cycle detection algorithms has become more diverse. Each of the following five algorithms gives the best known running time for some range of parameters (and the running times have to be multiplied by the factor $\log{(nW)}$ or $\log(|a\cdot b|)$ to obtain an algorithm for the minimum ratio problem):

• •

$O(mn)$ time using a variant of the Bellman-Ford algorithm [For56, Bel58, Moo59],

• •

$n^{3}/2^{\Omega(\sqrt{\log n})}$ time using a recent all-pairs shortest paths (APSP) algorithm by Williams [Wil14, CW16],

• •

$\tilde{O}(n^{\omega}W)$ time using fast matrix multiplication [San05, YZ05], where $2\leq\omega<2.3728639$ is the matrix multiplication coefficient [Gal14],

• •

$O(m\sqrt{n}\log W)$ time using Goldberg’s scaling algorithm [Gol95],

• •

$\tilde{O}(m^{10/7}\log W)$ time using the interior point method based algorithm of Cohen et al. [Coh+17]

The third group of minimum ratio cycle algorithms has a pseudopolynomial running time bound. After some initial progress [ILP91, GHH92, IP95], the state of the art is an algorithm by Hartmann and Orlin [HO93] that has a running time of $O(mnT)$.333Note that the more fine-grained analysis of Hartmann and Orlin actually gives a running time of $O(m(\sum_{u\in V}\max_{e=(u,v)}t(e)))$. Other algorithmic approaches, without claiming any running time bounds superior to those reported above, were given by Fox [Fox69], v. Golitschek [Gol82], and Dasdan, Irani, and Gupta [DIG99].

Recently, the minimum ratio problem has been studied specifically for the special case of constant treewidth graphs by Chatterjee, Ibsen-Jensen, and Pavlogiannis [CIP15]. The state of the art for negative cycle detection on constant treewidth graphs is an algorithm by Chaudhuri and Zaroliagis with running time $O(n)$ [CZ00], which by Lawler’s binary search approach implies an algorithm for the minimum ratio problem with running time $O(n\log{(nW)})$. Chatterjee et al. [CIP15] report a running time of $O(n\log(|a\cdot b|))$ based on the more refined binary search mentioned above and additionally give an algorithm that uses $O(\log{n})$ space (and hence polynomial time).

As a subroutine in our minimum ratio cycle algorithm, we use a new parallel algorithm for negative cycle detection and single-source shortest paths. The parallel SSSP problem has received considerable attention in the literature [Spe97, KS97, Coh97, BTZ98, SS99, Coh00, MS03, Mil+15, Ble+16], but we are not aware of any parallel SSSP algorithm that works in the presence of negative edge weights (and thus solves the negative cycle detection problem). To the best of our knowledge, the only strongly polynomial bounds reported in the literature are as follows: For weighted, directed graphs with non-negative edge weights, Broda, Träff, and Zaroliagis [BTZ98] give an implementation of Dijkstra’s algorithm with $O(m\log{n})$ work and $O(n)$ depth. For weighted, undirected graphs with positive edge weights, Shi and Spencer [SS99] gave (1) an algorithm with $O(n^{3}t^{-2}\log{n}\log{(nt^{-1})}+m\log{n})$ work and $O(t\log{n})$ depth and (2) an algorithm with $O((n^{3}t^{-3}+mnt^{-1})\log{n})$ work and $O(t\log{n})$ depth, for any $\log{n}\leq t\leq n$.

2 Preliminaries

In the following, we review some of the tools that we use in designing our algorithm.

2.1 Parametric Search

We first explain the parametric search technique as outlined in [AST94]. Assume we are given a property $\mathcal{P}$ of real numbers that is monotone in the following way: if $\mathcal{P}(\lambda)$ holds, then also $\mathcal{P}(\lambda^{\prime})$ holds for all $\lambda^{\prime}<\lambda$. Our goal is to find $\lambda^{*}$, the maximum $\lambda$ such that $\mathcal{P}(\lambda)$ holds. In this paper for example, we will associate with each $\lambda$ a weighted graph $G_{\lambda}$ and $\mathcal{P}$ is the property that $G_{\lambda}$ has no negative cycle. Assume further that we are given an algorithm $\mathcal{A}$ for deciding, for a given $\lambda$, whether $\mathcal{P}(\lambda)$ holds. If $\lambda$ were known to only assume integer or rational values, we could solve this problem by performing binary search with $O(\log{W})$ calls to the decision algorithm, where $W$ is the number of possible values for $\lambda$. However, this solution has the drawback of not yielding a strongly polynomial algorithm.

In parametric search we run the decision algorithm ‘generically’ at the maximum $\lambda^{*}$. As the algorithm does not know $\lambda^{*}$, we need to take care of its control flow ourselves and any time the algorithm performs a comparison we have to ‘manually’ evaluate the comparison on behalf of the algorithm. If each comparison takes the form of testing the sign of an associated low-degree polynomial $p(\lambda)$, this can be done as follows. We first determine all roots of $p(\lambda)$ and check if $\mathcal{P}(\lambda^{\prime})$ holds for each such root $\lambda^{\prime}$ using another instance of the decision algorithm $\mathcal{A}$. This gives us an interval between successive roots containing $\lambda^{*}$ and we can thus resolve the comparison. With every comparison we make, the interval containing $\lambda^{*}$ shrinks and at the end of this process we can output a single candidate. If the decision algorithm $\mathcal{A}$ has a running time of $T$, then the overall algorithm for computing $\lambda^{*}$ has a running time of $O(T^{2})$.

A more sophisticated use of the technique is possible, if in addition to a sequential decision algorithm $\mathcal{A}_{\text{s}}$ we have an efficient parallel decision algorithm $\mathcal{A}_{\text{p}}$. The parallel algorithm performs its computations simultaneously on $P_{\text{p}}$ processors. The number of parallel computation steps until the last processor is finished is called the depth $D_{\text{p}}$ of the algorithm, and the number of operations performed by all processors in total is called the work $W_{\text{p}}$ of the algorithm.444To be precise, we use an abstract model of parallel computation as formalized in [FL16] to avoid distraction by details such as read or write collisions typical to PRAM models. For parametric search, we actually only need parallelism w.r.t. comparisons involving the input values. We denote by the comparison depth of $\mathcal{A}_{\text{p}}$ the number of parallel comparisons (involving input values) until the last processor is finished.

We proceed similar to before: We run $\mathcal{A}_{\text{p}}$ ‘generically’ at the maximum $\lambda^{*}$ and (conceptually) distribute the work among $P_{\text{p}}$ processors. Now in each parallel step, we might have to resolve up to $P_{\text{p}}$ comparisons. We first determine all roots of the polynomials associated to these comparisons. We then perform a binary search among these roots to determine the interval of successive roots containing $\lambda^{*}$ and repeat this process of resolving comparisons at every parallel step to eventually find out the value of $\lambda^{*}$. If the sequential decision algorithm $\mathcal{A}_{\text{s}}$ has a running time of $T_{\text{s}}$ and the parallel decision algorithm runs on $P_{\text{p}}$ processors in $D_{\text{p}}$ parallel steps, then the overall algorithm for computing $\lambda^{*}$ has a running time of $O(P_{\text{p}}D_{\text{p}}+D_{\text{p}}T_{\text{s}}\log{P_{\text{p}}})$. Formally, the guarantees of the technique we just described can be summarized as follows.

Theorem 2.1** ([AST94, Meg83]).**

Let $\mathcal{P}$ be a property of real numbers such that if $\mathcal{P}(\lambda)$ holds, then also $\mathcal{P}(\lambda^{\prime})$ holds for all $\lambda^{\prime}<\lambda$ and let $\mathcal{A}_{\text{p}}$ and $\mathcal{A}_{\text{s}}$ be algorithms deciding for a given $\lambda$ whether $\mathcal{P}(\lambda)$ holds such that

• •

the control flow of $\mathcal{A}_{\text{p}}$ is only governed by comparisons that test the sign of an associated polynomial in $\lambda$ of constant degree,

• •

$\mathcal{A}_{\text{p}}$* is a parallel algorithm with work $W_{\text{p}}$ and comparison depth $D_{\text{p}}$, and*

• •

$\mathcal{A}_{\text{s}}$* is a sequential algorithm with running time $T_{\text{s}}$.*

Then there is a (sequential) algorithm for finding the maximum value $\lambda$ such that $\mathcal{P}(\lambda)$ holds with running time $O(W_{\text{p}}+D_{\text{p}}T_{\text{s}}\log{W_{\text{p}}})$.

Note that $\mathcal{A}_{\text{p}}$ and $\mathcal{A}_{\text{s}}$ need not necessarily be different algorithms. In most cases however, the fastest sequential algorithm might be the better choice for minimizing running time.

2.2 Characterization of Minimum Ratio Cycle

We consider a directed graph $G=(V,E,c,t)$, in which every edge $e=(u,v)$ has a cost $c(e)$ and a transit time $t(e)$. We want to find the cycle $C$ that minimizes the cost-to-time ratio $\sum_{e\in C}c(e)/\sum_{e\in C}t(e)$.

For any real $\lambda$ define the graph $G_{\lambda}=(V,E,w_{\lambda})$ as the modification of $G$ with weight $w_{\lambda}(e)=c(e)-\lambda t(e)$ for every edge $e\in E$. The following structural lemma is the foundation of many algorithmic approaches towards the problem.

Lemma 2.2** ([DBR67, Law76]).**

Let $\lambda^{*}$ be the value of the minimum ratio cycle of $G$.

• •

For $\lambda>\lambda^{*}$, the value of the minimum weight cycle in $G_{\lambda}$ is $<0$.

• •

The value of the the minimum weight cycle in $G_{\lambda^{*}}$ is [math]. Each minimum weight cycle in $G_{\lambda^{*}}$ is a minimum ratio cycle in $G$ and vice versa.

• •

For $\lambda<\lambda^{*}$, the value of the minimum weight cycle in $G_{\lambda}$ is $>0$.

The obvious algorithmic idea now is to find the right value of $\lambda$ with a suitable search strategy and reduce the problem to a series of negative cycle detection instances.

2.3 Characterization of Negative Cycle

Definition 2.3**.**

A potential function $p\colon V\to\text{R}$ assigns a value to each vertex of a weighted directed graph $G=(V,E,w)$. We call a potential function $p$ valid if for every edge $e=(u,v)\in E$, the condition $p(u)+w(e)\geq p(v)$ holds.

The following two lemmas outline an approach for negative cycle detection.

Lemma 2.4** ([EK72]).**

A weighted directed graph contains a negative cycle if and only if it has no valid potential function.

Lemma 2.5** ([Joh77]).**

Let $G=(V,E,w)$ be a weighted directed graph and let $G^{\prime}=(V^{\prime},E^{\prime},w^{\prime})$ be the supergraph of $G$ consisting of the vertices $V^{\prime}=V\cup\{s^{\prime}\}$ (i.e. with an additional super-source $s^{\prime}$), the edges $E^{\prime}=E\cup\{s^{\prime}\}\times V$ and the weight function $w^{\prime}$ given by $w^{\prime}(s^{\prime},v)=0$ for every vertex $v\in V$ and $w^{\prime}(u,v)=w(u,v)$ for all pairs of vertices $u,v\in V$. If $G$ does not contain a negative cycle, then the potential function $p$ defined by $p(v)=d_{G^{\prime}}(s^{\prime},v)$ for every vertex $v\in V$ is valid for $G$.

Thus, an obvious strategy for negative cycle detection is to design a single-source shortest paths algorithm that is correct whenever the graph contains no negative cycle. If the graph contains no negative cycle, then the distances computed by the algorithm can be verified to be a valid potential. If the graph does contain a negative cycle, then the distances computed by the algorithm will not be a valid potential (because a valid potential does not exist) and we can verify that the potential is not valid.

2.4 Computing Shortest Paths in Parallel

In our algorithm we use two building blocks for computing shortest paths in the presence of negative edge weights in parallel. The first such building block was also used by Megiddo [Meg83].

Observation 2.6**.**

By repeated squaring of the min-plus matrix product, all-pairs shortest paths in a directed graph with real edge weights can be computed using work $O(n^{3}\log{n})$ and depth $O(\log{n})$.

The second building block is a subroutine for computing the following restricted version of shortest paths.

Definition 2.7**.**

The shortest $h$-hop path from a vertex $s$ to a vertex $t$ is the path of minimum weight among all paths from $s$ to $t$ with at most $h$ edges.

Note that a shortest $h$-hop path from $s$ to $t$ does not exist, if all paths from $s$ to $t$ use more than $h$ edges. Furthermore, if there is a shortest path from $s$ to $t$ with at most $h$ edges, then the $h$-hop shortest path from $s$ to $t$ is a shortest path as well. Shortest $h$-hop paths can be computed by running $h$ iterations of the Bellman-Ford algorithm [For56, Bel58, Moo59].555The first explicit use of the Bellman-Ford algorithm to compute shortest $h$-hop paths that we are aware of is in Thorup’s dynamic APSP algorithm [Tho05]. Similar to shortest paths, shortest $h$-hop paths need not be unique. We can enforce uniqueness by putting some arbitrary but fixed order on the vertices of the graph and sorting paths according to the induced lexicographic order on the sequence of vertices of the paths. Note that the Bellman-Ford algorithm can easily be adapted to optimizing lexicographically as its second objective.

Observation 2.8**.**

By performing $h$ iterations of the Bellman-Ford algorithm, the lexicographically smallest shortest $h$-hop path from a designated source vertex $s$ to each other vertex in a directed graph with real edge weights can be computed using work $O(mh)$ and depth $O(h)$.

We denote by $\pi(s,t)$ the lexicographically smallest shortest path from $s$ to $t$ and by $\pi^{h}(s,t)$ the lexicographically smallest shortest $h$-hop path from $s$ to $t$. We denote by $V(\pi^{h}(s,t))$ and $E(\pi^{h}(s,t))$ the set of nodes and edges of $\pi^{h}(s,t)$, respectively.

2.5 Approximate Hitting Sets

Definition 2.9**.**

Given a collection of sets $\mathcal{S}\subseteq 2^{U}$ over a universe $U$, a hitting set is a set $T\subseteq H$ that has non-empty intersection with every set of $\mathcal{S}$ (i.e., $S\cap T\neq\emptyset$ for every $S\in\mathcal{S}$).

Computing a hitting set of minimum size is an NP-hard problem. For our purpose however, rough approximations are good enough. The first method to get a sufficiently small hitting set uses a simple randomized sampling idea and was introduced to the design of graph algorithms by Ullman and Yannakakis [UY91]. We use the following formulation.

Lemma 2.10**.**

Let $c\geq 1$, let $U$ be a set of size $s$ and let $\mathcal{S}=\{S_{1},S_{2},\ldots,S_{k}\}$ be a collection of sets over the universe $U$ of size at least $q$. Let $T$ be a subset of $U$ that was obtained by choosing each element of $U$ independently with probability $p=\min(x/q,1)$ where $x=c\ln{(ks)}+1$. Then, with high probability (whp), i.e., probability at least $1-1/s^{c}$, the following two properties hold:

For every $1\leq i\leq k$, the set $S_{i}$ contains an element of $T$, i.e., $S_{i}\cap T\neq\emptyset$. 2. 2.

$|T|\leq 3xs/q=O(cs\log{(ks)}/q)$.

The second method is to use a heuristic to compute an approximately minimum hitting set. In the sequential model, a simple greedy algorithm computes an $O(\log{n})$-approximation [Joh74, ADP80]. We use the following formulation.

Lemma 2.11**.**

Let $U$ be a set of size $s$ and let $\mathcal{S}=\{S_{1},S_{2},\ldots,S_{k}\}$ be a collection of sets over the universe $U$ of size at least $q$. Consider the simple greedy algorithm that picks an element $u$ in $U$ that is contained in the largest number of sets in $\mathcal{S}$ and then removes all sets containing $u$ from $\mathcal{S}$, repeating this step until $\mathcal{S}=\emptyset$. Then the set $T$ of elements picked by this algorithm satisfies:

For every $1\leq i\leq k$, the set $S_{i}$ contains an element of $T$, i.e., $S_{i}\cap T\neq\emptyset$. 2. 2.

$|T|\leq O(s\log{(k)}/q)$.

Proof.

We follow the standard proof of the approximation ratio $O(\log n)$ for the greedy set cover heuristic. The first statement is immediate, since we only remove sets when they are hit by the picked element. Since each of the $k$ sets contains at least $q$ elements, on average each element in $U$ is contained in at least $kq/s$ sets. Thus, the element $u$ picked by the greedy algorithm is contained in at least $kq/s$ sets. The remaining number of sets is thus at most $k-kq/s=k(1-q/s)$. Note that the remaining sets still have size at least $q$, since they do not contain the picked element $u$. Inductively, we thus obtain that after $i$ iterations the number of remaining sets is at most $k(1-q/s)^{i}$, so after $O(\log(k)\cdot s/q)$ iterations the number of remaining sets is less than 1 and the process stops. ∎

The above greedy algorithm is however inherently sequential and thus researchers have studied more sophisticated algorithms for the parallel model. The state of the art in terms of deterministic algorithms is an algorithm by Berger et al. [BRS94]666Berger et al. actually give an approximation algorithm for the following slightly more general problem: Given a hypergraph $H=(V,E)$ and a cost function $c\colon V\to\text{R}$ on the vertices, find a minimum cost subset $R\subseteq V$ that covers $H$, i.e., an $R$ that minimizes $c(R)=\sum_{v\in R}c(v)$ subject to the constraint $e\cap R\neq\emptyset$ for all $e\in E$..

Theorem 2.12** ([BRS94]).**

Let $\mathcal{S}=\{S_{1},S_{2},\ldots,S_{k}\}$ be a collection of sets over the universe $U$, let $n=|U|$ and $m=\sum_{1\leq i\leq k}|S_{i}|$. For $0<\varepsilon<1$, there is an algorithm with work $O((m+n)\varepsilon^{-6}\log^{4}{n}\log{m}\log^{6}{(nm)})$ and depth $O(\varepsilon^{-6}\log^{4}{n}\log{m}\log^{6}{(nm)})$ that produces a hitting set of $\mathcal{S}$ of size at most $(1+\varepsilon)(1+\ln{\Delta})\cdot\mathit{OPT}$, where $\Delta$ is the maximum number of occurrences of any element of $U$ in $\mathcal{S}$ and $\mathit{OPT}$ is the size of a minimum hitting set.

3 Randomized Algorithm for General Graphs

3.1 A Parallel SSSP Algorithm

In the following we design a parallel SSSP algorithm that can be used to check for negative cycles. Formally, we will in this subsection prove the following statement.

Theorem 3.1**.**

There is an algorithm that, given a weighted directed graph G = (V, E, w) containing no negative cycles, computes the shortest paths from a designated source vertex $s$ to all other vertices spending $O(mn\log{n}+n^{3}h^{-3}\log^{4}{n})$ work with $O(h+\log{n})$ depth for any $1\leq h\leq n$. The algorithm is correct with high probability and all its comparisons are performed on sums of edge weights on both sides.

The algorithm proceeds in the following steps:

Let $C\subseteq V$ be a set containing each vertex $v$ independently with probability $p=\min(3ch^{-1}\ln{n},1)$ for a sufficiently large constant $c$. 2. 2.

If $|C|>9cnh^{-1}\ln{n}$, then terminate. 3. 3.

For every vertex $x\in C\cup\{s\}$ and every vertex $v\in V$, compute the shortest $h$-hop path from $x$ to $v$ in $G$ and its weight $d_{G}^{h}(x,v)$. 4. 4.

Construct the graph $H=(C\cup\{s\},(C\cup\{s\})^{2},w_{H})$ whose set of vertices is $C\cup\{s\}$, whose set of edges is $(C\cup\{s\})^{2}$ and for every pair of vertices $x,y\in C\cup\{s\}$ the weight of the edge $(x,y)$ is $w_{H}(x,y)=d_{G}^{h}(x,y)$. 5. 5.

For every vertex $x\in C$, compute the shortest path from $s$ to $x$ in $H$ and its weight $d_{H}(s,x)$. 6. 6.

For every vertex $t\in V$, set $\delta(t)=\min_{x\in C\cup\{s\}}(d_{H}(s,x)+d_{G}^{h}(x,t))$.

3.1.1 Correctness

In order to prove the correctness of the algorithm, we first observe that as a direct consequence of Lemma 2.10 the randomly selected vertices in $C$ with high probability hit all lexicographically smallest shortest $\lfloor h/2\rfloor$-hop paths of the graph.

Observation 3.2**.**

Consider the collection of sets

[TABLE]

containing the vertices of the lexicographically smallest shortest $\lfloor h/2\rfloor$-hop paths with exactly $\lfloor h/2\rfloor$ edges between all pairs of vertices. Then, with high probability, $C$ is a hitting set of $\mathcal{S}$ of size at most $9cnh^{-1}\ln{n}$.

Lemma 3.3**.**

If $G$ contains no negative cycle, then $\delta(t)=d_{G}(s,t)$ for every vertex $t\in V$ with high probability.

Proof.

First note that the algorithm incorrectly terminates in Step 2 only with small probability. We now need to show that, for every vertex $t\in V$, $\delta(t):=\min_{x\in C\cup\{s\}}(d_{H}(s,x)+d_{G}^{h}(x,t))=d_{G}(s,t)$. First observe that every edge in $H$ corresponds to a path in $G$ (of the same weight). Thus, the value $\delta(t)$ corresponds to some path in $G$ from $s$ to $t$ (of the same weight) which implies that $d_{G}(s,t)\leq\delta(t)$ (as no path can have weight less than the distance).

Now let $\pi(s,t)$ be the lexicographically smallest shortest path from $s$ to $t$ in $G$. Subdivide $\pi$ into consecutive subpaths $\pi_{1},\ldots,\pi_{k}$ such that $\pi_{i}$ for $1\leq i\leq k-1$ has exactly $\lfloor h/2\rfloor$ edges, and $\pi_{k}$ has at most $\lfloor h/2\rfloor$ edges. Note that if $\pi$ itself has at most $\lfloor h/2\rfloor$ edges, then $k=1$. Since every subpath of a lexicographically smallest shortest path is also a lexicographically smallest shortest path, the paths $\pi_{1},\ldots,\pi_{k}$ are lexicographically smallest shortest paths as well. As the subpaths $\pi_{1},\ldots,\pi_{k-1}$ consist of exactly $\lfloor h/2\rfloor$ edges, each of them is contained in the collection of sets $\mathcal{S}$ of Observation 3.2. Therefore, each subpath $\pi_{i}$, for $1\leq i\leq k-1$, contains a vertex $x_{i}\in C$ with high probability.

Set $x_{0}=s$ and $x_{k}=t$, and observe that for every $0\leq i\leq k-1$, the subpath of $\pi(s,t)$ from $x_{i}$ to $x_{i+1}$ is a shortest path from $x_{i}$ to $x_{i+1}$ with at most $h$ edges and thus $d_{G}^{h}(x_{i},x_{i+1})=d_{G}(x_{i},x_{i+1})$. We now get the following chain of inequalities:

[TABLE]

Note that we have formally argued only that the algorithm correctly computes the distances from $s$. It can easily be checked that the shortest paths can be obtained by replacing the edges of $H$ with their corresponding paths in $G$.

3.1.2 Running Time

Lemma 3.4**.**

The algorithm above can be implemented with $O(mn\log{n}+n^{3}h^{-3}\log^{4}{n})$ and $O(h+\log{n})$ depth such that all its comparisons are performed on sums of edge weights on both sides.

Proof.

Clearly, in Steps 1–2, the algorithm spends $O(m+n)$ work with $O(1)$ depth. Step 3 can be carried out by running $h$ iterations of Bellman-Ford for every vertex $x\in C$ in parallel (see Lemma 2.8), thus spending $O(|C|\cdot mh)$ work with $O(h)$ depth. Step 4 can be carried out by spending $O(|C|^{2})$ work with $O(1)$ depth. Step 5 can be carried out by running the min-plus matrix multiplication based APSP algorithm (see Lemma 2.6), thus spending $O(|C|^{3}\log{n})$ work with $O(\log{n})$ depth. The naive implementation of Step 6 spends $O(n|C|)$ work with $O(|C|)$ depth. Using a bottom-up ‘tournament’ approach where in each round we pair up all values and let the maximum value of each pair proceed to the next round, this can be improved to work $O(n|C|)$ and depth $O(\log{n})$.

It follows that by carrying out the steps of the algorithm sequentially as explained above, the overall work is $O(|C|\cdot mh+|C|^{3}\log{n})$ and the depth is $O(h+\log{n})$. As the algorithm ensures that $|C|\leq 9cnh^{-1}\ln{n}$ for some constant $c$, the work is $O(mn\log{n}+n^{3}h^{-3}\log^{4}{n})$ and the depth is $O(h+\log{n})$. ∎

3.1.3 Extension to Negative Cycle Detection

To check whether a weighted graph $G=(V,E,w)$ contains a negative cycle, we first construct the graph $G^{\prime}$ (with an additional super-source $s^{\prime}$) as defined in Lemma 2.5. We then run the SSSP algorithm of Theorem 3.1 from $s^{\prime}$ in $G^{\prime}$ and set $p(v)=d_{G^{\prime}}(s^{\prime},t)$ for every vertex $t\in V$. We then check whether the function $p$ defined in this way is a valid potential function for $G$ testing for every edge $e=(u,v)$ (in parallel) whether $p(u)+w(u,v)\geq p(v)$. If this is the case, then we output that $G$ contains no negative cycle, otherwise we output that $G$ contains a negative cycle.

Corollary 3.5**.**

There is a randomized algorithm that checks whether a given weighted directed graph contains a negative cycle with $O(mn\log{n}+n^{3}h^{-3}\log^{4}{n})$ work and $O(h+\log{n})$ depth for any $1\leq h\leq n$. The algorithm is correct with high probability and all its comparisons are performed on sums of edge weights on both sides.

Proof.

Constructing the graph $G^{\prime}$ and checking whether $p$ is a valid potential can both be carried out with $O(m+n)$ work and $O(1)$ depth. Thus, the overall work and depth bounds are asymptotically equal to the SSSP algorithm of Theorem 3.1.

If $G$ contains no negative cycle, then the SSSP algorithm correctly computes the distances from $s^{\prime}$ in $G^{\prime}$. Thus, the potential $p$ is valid by Lemma 2.5 and our algorithm correctly outputs that there is no negative cycle. If $G$ contains a negative cycle, then it does not have any valid potential by Lemma 2.4. Thus, the potential $p$ defined by the algorithm cannot be valid and the algorithm outputs correctly that $G$ contains a negative cycle. ∎

3.2 Finding the Minimum Ratio Cycle

Using the negative cycle detection algorithm as a subroutine, we obtain an algorithm for computing a minimum ratio cycle in time $\tilde{O}(n^{3/2}m^{3/4})$.

Theorem 3.6**.**

There is a randomized one-sided-error Monte Carlo algorithm for computing a minimum ratio cycle with running time $O(n^{3/2}m^{3/4}\log^{2}{n})$.

Proof.

By Lemma 2.2 we can compute the value of the minimum ratio cycle by finding the largest value of $\lambda$ such that $G_{\lambda}$ contains no negative-weight cycle. We want to apply Theorem 2.1 to find this maximum $\lambda^{*}$ by parametric search. As the sequential negative cycle detection algorithm $A_{\text{s}}$ we use Orlin’s minimum weight cycle algorithm [Orl17] with running time $T(n,m)=O(mn)$. The parallel negative cycle detection algorithm $A_{\text{p}}$ of Corollary 3.5 has work $W(n,m)=O(mn\log{n}+n^{3}h^{-3}\log^{4}{n})$ and depth $D(n,m)=O(h+\log{n})$, for any choice of $1\leq h\leq n$. Any comparison the latter algorithm performs is comparing sums of edge weights of the graph. Since in $G_{\lambda}$ edge weights are linear functions in $\lambda$, the control flow only depends on testing the sign of degree-1 polynomials in $\lambda$. Thus, Theorem 2.1 is applicable777Formally, Theorem 2.1 only applies to deterministic algorithms. However, only step 1 of our parallel algorithm is randomized, but this step does not depend on $\lambda$. All remaining steps are deterministic. We can thus first perform steps 1 and 2, and invoke Theorem 2.1 only on the remaining algorithm. The output guarantee then holds with high probability. and we arrive at a sequential algorithm for finding the value of the minimum ratio cycle with running time $O(mn\log{n}(h+\log{n})+n^{3}h^{-3}\log^{4}{n})$. Finally, to output the minimum ratio cycle and not just its value, we run Orlin’s algorithm for finding the minimum weight cycle in $G_{\lambda^{*}}$, which takes time $O(mn)$. By setting $h=n^{1/2}m^{-1/4}\log{n}$ the overall running time becomes $O(n^{3/2}m^{3/4}\log^{2}{n})$. ∎

4 Deterministic Algorithm for General Graphs

We now present a deterministic variant of our minimum ratio cycle algorithm, with the same running time as the randomized algorithm up to logarithmic factors.

4.1 Deterministic SSSP and Negative Cycle Detection

We can derandomize our SSSP algorithm by combining a preprocessing step with the parallel hitting set approximation algorithm of [BRS94]. Formally, we will prove the following statement.

Theorem 4.1**.**

There is a deterministic algorithm that, given a weighted directed graph containing no negative cycles, computes the shortest paths from a designated source vertex $s$ to all other vertices spending $O(mn\log^{2}{n}+n^{3}h^{-3}\log^{7}{n}+n^{2}h\log^{11}{n})$ work with $O(h+\log^{11}{n})$ depth for any $1\leq h\leq n$.

From this, using Lemmas 2.4 and 2.5 analogously to the proof of Corollary 3.5, we get the following corollary for negative cycle detection.

Corollary 4.2**.**

There is a deterministic algorithm that checks whether a given weighted directed graph contains a negative cycle with $O(mn\log^{2}{n}+n^{3}h^{-3}\log^{7}{n}+n^{2}h\log^{11}{n})$ work and $O(h+\log^{11}{n})$ depth for any $1\leq h\leq n$.

Our deterministic SSSP algorithm does the following:

For all pairs of vertices $u,v\in V$, compute the shortest $\lfloor h/2\rfloor$-hop path $\pi^{\lfloor h/2\rfloor}(u,v)$ from $u$ to $v$ in $G$.888Note that in case there are multiple shortest $\lfloor h/2\rfloor$-hop paths from $u$ to $v$, any tie-breaking is fine for the algorithm and its analysis. 2. 2.

Compute an $O(\log{n})$-approximate set cover $C$ of the system of sets

$\mathcal{S}=\{V(\pi^{\lfloor h/2\rfloor}(u,v))\mid u,v\in V\text{ with }d_{G}^{\lfloor h/2\rfloor}(u,v)<\infty\text{ and }|E(\pi^{\lfloor h/2\rfloor}(u,v))|=\lfloor h/2\rfloor\}$. 3. 3.

Proceed with steps 3 to 6 of the algorithm in Section 3.1.

4.1.1 Correctness

Correctness is immediate: In the previous proof of Lemma 3.3 we relied on the fact that $C$ is a hitting set of $\mathcal{S}$. In the above algorithm, this property is guaranteed directly.

4.1.2 Running Time

Step 8 can be carried out by running $h$ iterations of the Bellman-Ford algorithm for every vertex $v\in V$. By Lemma 2.8 this uses $O(mnh)$ work and $O(h)$ depth. We carry out Step 2 by running the algorithm of Theorem 2.12 to compute an $O(\log{n})$-approximate hitting set of $\mathcal{S}$ with work $O(n^{2}h\log^{11}{n})$ and depth $O(\log^{11}{n})$. Lemma 2.10 gives a randomized process that computes a hitting set of $\mathcal{S}$ of expected size $O(nh^{-1}\log{n})$. By the probabilistic method, this implies that there exists a hitting set of size $O(nh^{-1}\log{n})$. We can therefore use the algorithm of Theorem 2.12 to compute a hitting set $\mathcal{S}$ of size $O(nh^{-1}\log^{2}{n})$. The work is $O(n^{2}h\log^{11}{n})$ and the depth is $O(\log^{11}{n})$. Carrying out the remaining steps with a hitting set $C$ of size $O(nh^{-1}\log^{2}{n})$ uses work $O(mh|C|+|C|^{3}\log{n})=O(mn\log^{2}{n}+n^{3}h^{-3}\log^{7}{n})$ and depth $O(h+\log{n})$. Thus, our overall SSSP algorithm has work $O(mn\log^{2}{n}+n^{3}h^{-3}\log^{7}{n}+n^{2}h\log^{11}{n})$ and depth $O(h+\log^{11}{n})$.

4.2 Minimum Ratio Cycle

We again obtain a minimum ratio cycle algorithm by applying parametric search (Theorem 2.1). We obtain the same running time bound as for the randomized algorithm.

Theorem 4.3**.**

There is a deterministic algorithm for computing a minimum ratio cycle with running time $O(n^{3/2}m^{3/4}\log^{2}n)$.

Proof sketch.

The proof is analogous to the proof of Theorem 3.6, with the only exception that we use the deterministic parallel negative cycle detection algorithm of Corollary 4.2. However, we do not necessarily need to run the algorithm of Theorem 2.12 to compute an approximate hitting set. Instead we can also run the greedy set cover heuristic (Lemma 2.11) for this purpose. The reason is that at this stage, the greedy heuristic does not need to perform any comparisons involving the edge weights of the input graph, which are the only operations that are costly in the parametric search technique. This means that finding an approximate hitting set $C$ of size $O(nh^{-1}\log n)$ can be implemented with $O(\sum_{S\in\mathcal{S}}|S|)=O(n^{2}h)$ work and $O(1)$ comparison depth. Thus, we use a parallel negative cycle detection algorithm $A_{\text{p}}$ which has work $W(n,m)=O(mh|C|+|C|^{3}\log{n}+n^{2}h)=O(mn\log n+n^{3}h^{-3}\log^{4}n+n^{2}h)$ and depth $D(n,m)=O(h+\log n)$, for any choice of $1\leq h\leq n$. We thus obtain a sequential minimum ratio cycle algorithm with running time $O(mn\log n+n^{3}h^{-3}\log^{4}n+n^{2}h+mn\log{n}(h+\log n))$, for any choice of $1\leq h\leq n$. Note that the summands $mn\log n$ and $n^{2}h$ are both dominated by the last summand $mn\log{n}(h+\log n)$. Setting $h=n^{1/2}m^{-1/4}\log n$ to optimize the remaining summands, the running time becomes $O(n^{3/2}m^{3/4}\log^{2}{n})$. ∎

5 Near-Linear Time Algorithm for Constant Treewidth Graphs

In the following we demonstrate how to obtain a nearly-linear time algorithm (in the strongly polynomial sense) for graphs of constant treewidth. We can use the following results of Chaudhuri and Zaroliagis [CZ00] who studied the shortest paths problem in graphs of constant treewidth.999The first result of Chaudhuri and Zaroliagis [CZ00] has recently been complemented with a space-time trade-off by Chatterjee, Ibsen-Jensen, and Pavlogiannis [CIP16] at the cost of polynomial preprocessing time that is too large for our purposes.

Theorem 5.1** ([CZ00]).**

There is a deterministic algorithm that, given a weighted directed graph containing no negative cycles, computes a data structure that after $O(n)$ preprocessing time can answer, for any pair of vertices, distance queries in time $O(\alpha(n))$, where $\alpha(\cdot)$ is the inverse Ackermann function. It can also report a corresponding shortest path in time $O(\ell\alpha(n))$, where $\ell$ is the number of edges of the reported path.

Theorem 5.2** ([CZ98]).**

There is a deterministic negative cycle algorithm for weighted directed graphs of constant treewidth with $O(n)$ work and $O(\log^{2}{n})$ depth.

We now apply the reduction of Theorem 2.1 to the algorithm of Theorem 5.2 to find $\lambda^{*}$, the value of the minimum ratio cycle, in time $O(n\log^{3}{n})$ (using $T_{\text{s}}(n)=W_{\text{p}}(n)=O(n)$, and $D_{\text{p}}(n)=O(\log^{2}{n})$). We then use the algorithm of Theorem 5.1 to find a minimum weight cycle in $G_{\lambda^{*}}$ in time $O(n\alpha(n))$: Each edge $e=(u,v)$ together with the shortest path from $v$ to $u$ (if it exists) defines a cycle and we need to find the one of minimum weight by asking the corresponding distance queries. For the edge $e=(u,v)$ defining the minimum weight cycle we query for the corresponding shortest path from $v$ to $u$. This takes time $O(n)$ as a graph of constant treewidth has $O(n)$ edges. We thus arrive at the following guarantees of the overall algorithm.

Corollary 5.3**.**

There is a deterministic algorithm that computes the minimum ratio cycle in a directed graph of constant treewidth in time $O(n\log^{3}{n})$.

6 Slightly Faster Algorithm for Dense Graphs

All our previous algorithm do not make use of fast matrix multiplication. We now show that if we allow fast matrix multiplication, despite the hidden constant factors being galactic, then slight further improvements are possible. Specifically, we sketch how the running time of $n^{3}/2^{\Omega{(\sqrt{\log n})}}$ of Williams’s recent APSP algorithm [Wil14] (with a deterministic version by Chan and Williams [CW16]) can be salvaged for the minimum ratio problem. In particular, we explain why Williams’ algorithm for min-plus matrix multiplication parallelizes well enough.

Theorem 6.1**.**

There is a deterministic algorithm that checks whether a given weighted directed graph contains a negative cycle with $n^{3}/2^{\Omega{(\sqrt{\log n})}}$ work and $O(\log{n})$ comparison depth.

Proof sketch.

First, note that the value of the minimum weight cycle in a directed graph can be found by computing $\min_{e=(u,v)\in E}w(u,v)+d_{G}(v,u)$, i.e., the cycle of minimum weight among all cycles consisting of first an edge $e=(u,v)$ and then the shortest path from $u$ to $v$ is the global minimum weight cycle. If all pairwise distances are already given, then computing the value of the minimum weight cycle (and thus also checking for a negative cycle) can therefore be done with $O(n^{2})$ work and $O(\log{n})$ depth (again by a ‘tournament’ approach).

The APSP problem can in turn be reduced to min-plus matrix multiplication [AHU76]. Let $M$ be the adjacency matrix of the graph where additionally all diagonal entries are set to [math]. Recall that the the all-pairs distance matrix is given $M^{n-1}$, where matrix multiplication is performed in the min-plus semiring. By repeated squaring, this matrix can be computed with $O(\log{n})$ min-plus matrix multiplications. Williams’s principal approach for computing the min-plus product $C$ of two matrices $A$ and $B$ is as follows.

1. (A1)

Split the matrices $A$ and $B$ into rectangular submatrices of dimensions $n\times d$ and $d\times n$, respectively, where $d=2^{\Theta(\sqrt{\log{n}})}$, as follows: For every $1\leq k\leq\lceil n/d\rceil-1$, $A_{k}$ contains the $k$-th group of $d$ consecutive columns of $A$ and $B_{k}$ contains the $k$-th group of $d$ consecutive rows of $B$; for $k=\lceil n/d\rceil$, $A_{k}$ contains the remaining columns of $A$ and $B_{k}$ contains the remaining rows of $B$. 2. (A2)

For each $1\leq k\leq\lceil n/d\rceil$, compute $C_{k}$, the min-plus product of $A_{k}$ and $B_{k}$ (using the algorithm described below). 3. (A3)

Determine the min-plus product of $A$ and $B$ by taking the entrywise minimum $C:=\min_{1\leq k\leq\lceil n/d\rceil}C_{k}$.

To carry out Step (A2), Williams first uses a preprocessing stage applied to each pair of matrices $A_{k}$ and $B_{k}$ (for $1\leq k\leq\lceil n/d\rceil$) individually. It consists of the following three steps:

1. (B1)

Compute matrices $A_{k}^{*}$ and $B_{k}^{*}$ of dimensions $n\times d$ and $d\times n$, respectively, as follows: Set $A_{k}^{*}[i,p]:=A_{k}[i,p]\cdot(n+1)+p$, for every $1\leq i\leq n$ and $1\leq p\leq d$, and set $B_{k}^{*}[q,j]:=B_{k}[q,j]\cdot(n+1)+q$, for every $1\leq q\leq d$ and $1\leq j\leq n$. 2. (B2)

Compute matrices $A_{k}^{\prime}$ and $B_{k}^{\prime}$ of dimensions $n\times d^{2}$ and $d^{2}\times n$, respectively, as follows: Set $A^{\prime}_{k}[i,(p,q)]:=A_{k}^{*}[i,p]-A_{k}^{*}[i,q]$, for every $1\leq i\leq n$ and $1\leq p,q\leq d$, and set $B_{k}^{\prime}[(p,q),j]:=B_{k}^{*}[q,j]-B_{k}^{*}[p,j]$, for every $1\leq j\leq n$, $1\leq p,q\leq d$. 3. (B3)

For every pair $p,q$ ($1\leq p,q\leq d)$, compute and sort the set $S_{k}^{p,q}:=\{A_{k}^{\prime}[i,(p,q)]\mid 1\leq i\leq n\}\cup\{B_{k}^{\prime}[(p,q),j]\mid 1\leq j\leq n\}$, where ties are broken such that entries of $A_{k}^{\prime}$ have precedence over entries of $B_{k}^{\prime}$. Then compute matrices $A_{k}^{\prime\prime}$ and $B_{k}^{\prime\prime}$ of dimensions $n\times d^{2}$ and $d^{2}\times n$, respectively, as follows: Set $A_{k}^{\prime\prime}[i,(p,q)]$ to the rank of the value $A_{k}^{\prime}[i,(p,q)]$ in the sorted order of $S_{k}^{p,q}$, for every $1\leq i\leq n$ and $1\leq p,q\leq d$, and set $B_{k}^{\prime\prime}[(p,q),j]$ to the rank of the value $B^{\prime}_{k}[(p,q),j]$ in the sorted order of $S_{k}^{p,q}$, for every $1\leq j\leq n$ and $1\leq p,q\leq d$.

This type of preprocessing is also known as Fredman’s trick [Fre76]. As Williams shows, the problem of computing $C_{k}$ now amounts to finding, for every $1\leq i\leq n$ and $1\leq j\leq n$, the unique $p^{*}$ such that $A^{\prime\prime}_{i,(p^{*},q)}\leq B^{\prime\prime}_{(p^{*},q),j}$ for all $1\leq q\leq d$. Using tools from circuit complexity and fast rectangular matrix multiplication, this can be done in time $\tilde{O}(n^{2})$, either with a randomized algorithm [Wil14], or, with slightly worse constants in the choice of $d$ (and thus the exponent of the overall algorithm), with a deterministic algorithm [CW16]. The crucial observation for our application is that after the preprocessing stage no comparisons involving the input values are performed anymore since all computations are performed with regard to the matrices $A_{k}^{\prime\prime}$ and $B_{k}^{\prime\prime}$, which only contain the ranks (i.e., integer values from $1$ to $2n$).

The claimed work bound follows from Williams’s running time analysis. We can bound the comparison depth as follows. First note that apart from Steps (A3) and (B3) we only incur $O(\log n)$ overhead in the depth. Step (A3) can be implemented with $O(\log{n})$ depth by using a tournament approach for finding the respective minima. For Step (B3) we can use a parallel version of merge sort on $n$ items that has work $O(n\log{n})$ and depth $O(\log{n})$ [Col88]. ∎

We now apply the reduction of Theorem 2.1 to the algorithm of Theorem 6.1 to find $\lambda^{*}$, the value of the minimum ratio cycle, in time $n^{3}/2^{\Omega{(\sqrt{\log n})}}$ (using $T_{\text{s}}(n)=W_{\text{p}}(n)=n^{3}/2^{\Omega{(\sqrt{\log n})}}$, and $D_{\text{p}}(n)=O(\log{n})$). We then use Williams’ APSP algorithm to find a minimum weight cycle in $G_{\lambda^{*}}$ in time $n^{3}/2^{\Omega{(\sqrt{\log n})}}$. We thus arrive at the following guarantees of the overall algorithm.

Corollary 6.2**.**

There is deterministic algorithm for computing a minimum ratio cycle with running time $n^{3}/2^{\Omega{(\sqrt{\log n})}}$.

7 Conclusion

We have presented a faster strongly polynomial algorithm for finding a cycle of minimum cost-to-time ratio, a problem which has a long history in combinatorial optimization and recently became relevant in the context of quantitative verification. Our approach combines parametric search with new parallelizable single-source shortest path algorithms and also yields small improvements for graphs of constant treewidth and in the dense regime. The main open problem is to push the running time down to $\tilde{O}(mn)$, nearly matching the strongly polynomial upper bound for the less general problem of finding a minimum mean cycle.