Breaking the Cubic Barrier for All-Pairs Max-Flow:
Gomory-Hu Tree in Nearly Quadratic Time

1. As noted earlier (and similar to state-of-the-art max-flow algorithms), we assume throughout the paper that edge weights are integers in the range $\{1,2,\ldots,W\}$. Throughout, the notation $\tilde{O}(\cdot)$ hides poly-logarithmic factors in $n$ and $W$.
2. Our result is unconditional, i.e., it does not need to assume a (near/almost) linear-time max-flow algorithm. We note that concurrent to our work, an almost-linear time max-flow algorithm has been announced [CKL⁺22]. Our improvement of the running time of GHtree/APMF is independent of this result: even with this result, the best GHtree/APMF bound was $m^{1+o(1)}n$ which is between $n^{2+o(1)}$ and $n^{3+o(1)}$ depending on the value of $m$, and we improve it to $\tilde{O}(n^{2})$. Moreover, we stress that we do not need any recent advancement in max-flow algorithms for breaking the cubic barrier: even using the classic Goldberg-Rao max-flow algorithm [GR98] in our (combinatorial) algorithm solves GHtree/APMF in subcubic time.

Our techniques also improve the bounds known for the GHtree problem in unweighted graphs, and even for simple graphs. For unweighted graphs, the best previous results were $\tilde{O}(mn)$ obtained by Bhalgat et al. [BHKP07] and by Karger and Levine [KL15], and an incomparable result that reduces the GHtree problem to $O(\sqrt{m})$ max-flow calls [AKT21b]. There has recently been much interest and progress on GHtree in simple graphs as well [AKT21c, AKT21a, LPS21, Zha22, AKT22], with the current best running time being $(m+n^{1.9})^{1+o(1)}$.

We give a reduction of the GHtree problem in unweighted graphs to $\mathrm{polylog}(n)$ calls of any max-flow algorithm. Note that this reduction is nearly optimal (i.e., up to the poly-log factor) since the all-pairs max-flow problem is at least as hard as finding a single-pair max-flow. Using the recent $m^{1+o(1)}$-time max-flow algorithm [CKL⁺22], this yields a running time of $m^{1+o(1)}$ for the GHtree problem in unweighted graphs.

Our results deliver a surprising message to a primordial question in graph algorithms: What is easier to compute, shortest paths or max-flows? Ignoring $n^{o(1)}$ factors, the single-pair versions are both solvable in linear-time and therefore equally easy; albeit, the shortest path algorithm [Dij59] is classical, elementary, and fits on a single page, whereas the max-flow algorithm [CKL⁺22] is very recent, highly non-elementary, and requires more than a hundred pages to describe and analyze. This and nearly all other evidence had supported the consensus that max-flows are at least as hard as (if not strictly harder than) shortest paths, and perhaps this can be established by looking at the more general all-pairs versions: APMF and APSP (All-Pairs Shortest-Paths). Much effort had gone into proving this belief (APMF $\geq$ APSP) using the tools of fine-grained complexity [AVY15, KT18, AGI⁺19, AKT21b, AKT20], with limited success: it was shown that (under popular assumptions) APMF is strictly harder than APSP in directed graphs, but the more natural undirected setting remained open. The first doubts against the consensus were raised in the aforementioned $n^{2+o(1)}$ algorithms for APMF in simple (unweighted) graphs that go below the $n^{\omega}$ bound of APSP [Sei95] (where $2\leq\omega<2.37286$ [AW21] denotes the fast matrix multiplication exponent). But if, as many experts believe, $\omega=2+o(1)$ then the only conclusion is that APMF and APSP are equally easy in simple graphs. In general (weighted) graphs, however, one of the central conjectures of fine-grained complexity states that the cubic bound for APSP cannot be broken (even if $\omega=2$). Under this “APSP Conjecture”, Theorem 1.3 proves that APMF is strictly easier than APSP! Alternatively, if one still believes that APMF $\geq$ APSP, then our paper provides strong evidence against the APSP Conjecture and against the validity of the dozens of lower bounds that are based upon it (e.g., [RZ04, WW18, AW14, AGW15, Sah15, AD16, BGMW20]) or upon stronger forms of it (e.g., [BT17, BDT16, CMWW19, ACK20, GMW21]).

The isolating cuts lemma stated above slightly generalizes the corresponding statement from [LP20, AKT21c]. In the previous versions, each of the sets $U_{1},U_{2},\ldots,U_{h}$ is a distinct singleton vertex in $V$. The generalization to disjoint sets of vertices is trivial because we can contract each set $U_{i}$ for $i\in[h]$ and then apply the original isolating cuts lemma to this contracted graph to obtain 2.1.

We call each $(U_{i},\cup_{j\neq i}U_{j})$-mincut $S_{i}$ a minimum isolating cut because it “isolates” $U_{i}$ from the rest of the terminal sets, using a cut of minimum size. The advantage of this lemma is that it essentially only costs $O(\log{h})$ max-flow calls, which is an exponential improvement over the naïve strategy of running $h$ max-flow calls, one for each $U_{i}$.

The next tool is the Cut-Threshold procedure of Li and Panigrahi, which has been used earlier in the approximate Gomory-Hu tree problem [LP21] and in edge connectivity augmentation and splitting off algorithms [CLP22].

We use the Cut-Threshold lemma to obtain the following lemma, which is an important component of our final algorithm.

Having introduced the main tools, we are now ready to present our SSMC algorithm (see Figure 1). The input to the algorithm is a graph $G=(V,E,w)$ containing a specified vertex $s$, a (guide) tree $T$ containing $s$, and a positive integer $k$. The algorithm is a recursive algorithm, and although the guide tree initially only contains vertices in $V$, there will be additional vertices (not in $V$) that are introduced into the guide tree in subsequent recursive calls. To distinguish between these two types of vertices, we define $R(T)$ as the subset of vertices of $T$ that are in $V$, and call these real vertices. We call the vertices of $T$ that are not in $V$ fake vertices.

We extend the definition of $k$-respecting (i.e., Definition 1.7) to fake vertices as follows:

We also note that even if all the vertices in $T$ are real vertices, $T$ may not be a subgraph of $G$.

Recall that our goal is to obtain a value $\tilde{\lambda}(t)\geq\lambda(s,t)$ for every terminal $t\in U\setminus\{s\}$ such that if an $(s,t)$-mincut $k$-respects $T$, then $\tilde{\lambda}(t)=\lambda(s,t)$. We will actually compute $\tilde{\lambda}(t)$ for every real vertex $t\in R(T)\setminus\{s\}$; clearly, this suffices since the input Steiner tree (i.e., at the top level of the recursion) spans all the vertices in $U$.

The algorithm maintains estimates $\tilde{\lambda}(t)$ of the mincut values $\lambda(s,t)$ for all $t\in R(T)\setminus\{s\}$. The values $\tilde{\lambda}(t)$ are initialized to $\infty$, and whenever we compute an $(s,t)$-cut in the graph, we “update” $\tilde{\lambda}(t)$ by replacing $\tilde{\lambda}(t)$ with the value of the $(s,t)$-cut if it is lower. Formally, we define $\textsc{Update}(t,x):\tilde{\lambda}(t)\leftarrow\min(\tilde{\lambda}(t),x)$.

We describe the algorithm below. The reader should use the illustration in Figure 1 as a visual description of each step of the algorithm.

1. 1.

   First, we describe a base case. If $|R(T)|$ is less than some fixed constant, then we simply compute the $(s,t)$-mincut in $G$ separately for each $t\in R(T)\setminus\{s\}$ using $|R(T)|-1=O(1)$ max-flow calls, and run $\textsc{Update}(t,\lambda(s,t))$.

2. From now on, assume that $|R(T)|$ is larger than some (large enough) constant.⁴⁴4For example, the constant $10$ is more than enough.

3. 2.

   Let $c$ be a centroid of the tree $T$, defined in the following manner: $c$ is a (possibly fake) vertex in $T$ such that if we root $T$ at $c$, then each subtree rooted at a child of $c$ has at most $|R(T)|/2$ real vertices.⁵⁵5A centroid always exists by the following simple argument: take the (real or fake) vertex of $T$ of maximum depth whose subtree rooted at $T$ has at least $|R(T)|/2$ real vertices. By construction, this vertex is a centroid of $T$, and it can be found in time linear in the number of vertices in the tree using a simple dynamic program.

4. If $c\in R(T)$ and $s\not=c$, then compute an $(s,c$)-mincut in $G$ (whose value is denoted $\lambda$) using a max-flow call and run $\textsc{Update}(c,\lambda(s,c))$.

5. 3.

   Root $T$ at $c$ and let $u_{1},\ldots,u_{\ell}$ be the children of $c$. For each $i\in[\ell]$, let $T_{i}$ be the subtree rooted at $u_{i}$. Recall that $R(T_{i})$ denotes the set of real vertices in the respective subtrees $T_{i}$ for $i\in[\ell]$. (For technical reasons, we ignore subtrees $T_{i}$ that do not contain any real vertex.) Use 2.1 to compute minimum isolating cuts in $G$ with the following terminal sets: (1) $U_{i}=R(T_{i})$ for $i\in[\ell]$. (2) If $c\in R(T)$, then we add an additional set $U_{\ell+1}=\{c\}$. Note that $\cup_{i}U_{i}=R(T)$ irrespective of whether $c\in R(T)$ or not.

6. Let $S_{i}\subseteq V$ be the $(U_{i},R(T)\setminus U_{i})$-mincut in $G$ obtained from 2.1. We ignore $S_{\ell+1}$ (if it exists) and proceed with the remaining sets $S_{i}$ for $i\in[\ell]$ in the next step.

7. 4.

   For each $i\in[\ell]$, define $G_{i}$ as the graph $G$ with $V\setminus S_{i}$ contracted to a single vertex. Now, there are two cases. In the first case, we have $s\in V\setminus S_{i}$. Then, the contracted vertex for $V\setminus S_{i}$ is labeled the new $s$ in graph $G_{i}$. Correspondingly, define $T^{\prime}_{i}$ as the tree $T_{i}$ with an added edge $(s,u_{i})$ (recall that $u_{i}$ is the root of $T_{i}$). In the second case, we have $s\in S_{i}$. Then, assign a new label $c_{i}$ to the contracted vertex for $V\setminus S_{i}$ in $G_{i}$. In this case, define $T^{\prime}_{i}$ as the tree $T_{i}$ with an added edge $(c_{i},u_{i})$, and keep the identity of vertex $s$ unchanged since it is in $T_{i}$. (Note that if $s=c$, the only difference is that the second case does not happen for any $i\in[\ell]$.)

8. In both cases above, make recursive calls $(G_{i},T^{\prime}_{i},k)$ for all $i\in[\ell]$. Call $\textsc{Update}(t,\lambda^{\prime}(s,t))$ for all $t\in R(T_{i})\setminus\{s\}$ where the recursive call returns the value $\lambda^{\prime}(s,t)$ for the variable $\tilde{\lambda}(t)$. Furthermore, if $s\in S_{i}$, call $\textsc{Update}(t,\lambda^{\prime}(s,c_{i}))$ for all $t\in R(T)\setminus R(T_{i})$ where the recursive call returns the value $\lambda^{\prime}(s,c_{i})$ for the variable $\tilde{\lambda}(c_{i})$.

9. If $k=1$, then we terminate the algorithm at this point, so from now on, assume that $k>1$.

10. 5.

    Sample each subtree $T_{i}$ independently with probability $1/2$ except the subtree containing $s$ (if it exists), which is sampled with probability $1$. (If $c=s$, then there is no subtree containing $s$, and all subtrees are sampled with probability $1/2$.) Let $T^{(\ref{step:5})}$ be the tree $T$ with all (vertices of) non-sampled subtrees deleted. Recursively call $(G,T^{(\ref{step:5})},k-1)$ and update $\tilde{\lambda}(t)$ for all $t\in R(T^{(\ref{step:5})})$. (Note that $R(T^{(\ref{step:5})})$ denotes the set of real vertices in tree $T^{(\ref{step:5})}$. Moreover, by the sampling procedure, $s$ is always in $R(T^{(\ref{step:5})})$ and hence, the recursion is valid.) Repeat this step for $O(\log n)$ independent sampling trials.

11. 6.

    Execute this step only if $s\neq c$, and let $T_{s}$ be the subtree from step (2) containing $s$. Using Lemma 2.3, compute the value $\lambda_{\max}=\max\{\lambda(s,t):t\in R(T)\setminus R(T_{s})\}$, as well as all vertices $t\in R(T)\setminus R(T_{s})$ attaining this maximum. Update $\tilde{\lambda}(t)=\lambda_{\max}$ for all such $t$, and arbitrarily select one such $t$ to be labeled $s^{\prime}$. Let $T^{(\ref{step:6})}$ be the tree $T$ with (the vertices of) subtree $T_{s}$ removed. Recursively call $(G,T^{(\ref{step:6})},k-1)$ where $s^{\prime}$ is treated as the new $s$, and update $\tilde{\lambda}(t)$ for all $t\in R(T^{(\ref{step:6})})$.