Abstract 1 Introduction 2 Technical Overview 3 Basic definitions 4 Finding good partitions induced by the large 𝑴-sets References

Computing the (k+2)-Edge-Connected Components in k-Edge-Connected Digraphs in Subquadratic Time

Loukas Georgiadis ORCID Department of Computer Science & Engineering, University of Ioannina, Greece    Evangelos Kipouridis ORCID Max Planck Institute for Informatics, Saarland Informatics Campus, Saarbrücken, Germany    Evangelos Kosinas ORCID Department of Computer Science & Engineering, University of Ioannina, Greece
Archimedes, Athena RC, Greece
   Charis Papadopoulos ORCID Department of Mathematics, University of Ioannina, Greece    Nikos Parotsidis ORCID Google Research, Zürich, Switzerland
Abstract

Computing edge-connected components in directed and undirected graphs is a fundamental and well-studied problem in graph algorithms. In a very recent breakthrough, Korhonen [STOC 2025] showed that for any fixed k, the k-edge connected components of an undirected graph can be computed in linear time. In contrast, the directed case remains significantly more challenging: linear-time algorithms are only known for k3, and for any fixed k>3, the best known bound for sparse or moderately dense graphs is still the O(mn)-time algorithm of Nagamochi and Watanabe (1993).

In this paper, we break the O(mn) barrier for all k=o(n1/4/logn). We present a randomized algorithm that computes the (k+2)-edge-connected components of a k-edge-connected directed graph in O(k2mnlogn) time, for any k. This constitutes the first improvement over the classic Nagamochi–Watanabe bound for any constant k>3. Our approach introduces new structural insights into directed edge-cuts and combines these with both new and existing techniques. A central contribution of our work is a substantial simplification and generalization of the framework introduced in [21], which achieved an O~(mm) bound for computing the 3-edge-connected components of a digraph. In addition, we develop a variant of our algorithm that achieves the same O(mnlogn) running time for computing the 4-edge-connected components of a general directed graph.

Keywords and phrases:
Graph connectivity, edge-connected components, directed edge-cuts
Category:
Track A: Algorithms, Complexity and Games
Copyright and License:
[Uncaptioned image] © Loukas Georgiadis, Evangelos Kipouridis, Evangelos Kosinas, Charis Papadopoulos,
and Nikos Parotsidis; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Mathematics of computing Graph algorithms
; Theory of computation Network flows
Related Version:
Full Version: http://arxiv.org/abs/2604.27474 [20]
Acknowledgements:
We thank an anonymous reviewer for suggesting the use of the Picard-Queyranne graph in the proof of Proposition 9.
Funding:
This work has been partially supported by project MIS 5154714 of the National Recovery and Resilience Plan Greece 2.0 funded by the European Union under the NextGenerationEU Program.
Editors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele Puppis

1 Introduction

Computing edge-connected components in directed and undirected graphs is a fundamental problem in graph algorithms, motivated by several applications (see, e.g., [35]), and has been extensively studied. Before discussing related work and our contributions, we begin with the necessary definitions.

Let G=(V,E) be a strongly connected directed graph (digraph) with n vertices and m edges. A set of edges CE is called a cut if the graph GC is not strongly connected. If |C|=k, we refer to C as a k-cut of G. For any pair of vertices v,wV, we say that a cut C separates v from w if there is no vw path in GC; in this case, we call C a (v,w)-cut. We denote by λ(v,w) the size of a minimum (v,w)-cut. A digraph G is said to be k-edge-connected if it has no cuts of size at most k1, that is, if λ(v,w)k for all pairs of vertices v,wV.

We say that two vertices v and w are k-edge-connected, denoted by vkw, if there exist k edge-disjoint directed paths from v to w and k edge-disjoint directed paths from w to v. (Note that a path from v to w and a path from w to v need not be edge-disjoint.) By Menger’s theorem [32], vkw if and only if the removal of any set of at most k1 edges leaves v and w in the same strongly connected component. A k-edge-connected component of a digraph G=(V,E) is a maximal subset UV such that ukv for all u,vU. The k-edge-connected components of G form a partition of V, since the relation k is an equivalence relation [18]. The same definition applies analogously to undirected graphs.

For undirected graphs, the problem of computing the k-edge-connected components is very well understood. Until recently, linear-time algorithms were known only for k5 [13, 15, 16, 25, 30, 33, 34, 40, 41]. In a significant recent breakthrough, Korhonen [29] introduced an algorithm with running time O(m+kO(k2)n) for computing the k-edge-connected components of an undirected graph, which is linear in the number of edges for any fixed k.

The directed case remains more challenging. Until recently, linear-time algorithms were known only for k2 [40, 19]. Georgiadis et al. [21] presented a randomized (Monte-Carlo) algorithm that computes the 3-edge-connected components of a digraph with m edges in O~(m3/2) time.111The O~() notation hides polylogarithmic factors. Their algorithm applies an involved extension of the framework of [12, 37] for deciding whether a digraph is (k+1)-edge-connected. It is based on a local search procedure [8, 12], initiated from sampled vertices, which identifies 2-out sets or 2-in sets, that is, vertex sets S that have 2 outgoing edges to VS or 2 entering edges from VS. After finding such a set S, [21] applies an efficient graph operation for replacing S with a gadget of small size that preserves the pairwise connectivity among the vertices of VS. Georgiadis, Italiano, and Kosinas [17] later presented a deterministic linear-time algorithm for computing the 3-edge-connected components of a digraph. This result is based on an adaptation of the minset-poset technique of Gabow [14] for identifying minimal k-in sets in (k1)-edge-connected digraphs, combined with a characterization of 2-in sets using the concept of strongly divergent spanning trees [22].

For any fixed k>3, the best known bound for computing the k-edge-connected components of a sparse or moderately dense digraph remains O(mn), as given by the algorithm of Nagamochi and Watanabe [36]. Unfortunately, both approaches proposed in [21] and [17] appear difficult to extend to the case k>3. Specifically, [21] applies a graph transformation that replaces a 2-in set or a 2-out set S with a small gadget that preserves the pairwise connectivity of the vertices in VS. The fast construction of this gadget relies crucially on the simple structure of 1-cuts. In contrast, [17] computes minimal 2-in set sets by exploiting properties of two strongly divergent spanning trees rooted at a designated vertex s. Extending this technique to k>3 would require, at minimum, an efficient method for computing k1 spanning trees with similar properties. However, Huck [27] showed that such spanning trees do not always exist: there are k-vertex-connected digraphs which, for a fixed start vertex s, do not have such collection of spanning trees.

Our results.

In this paper, we present the first improvement over the classical bound of Nagamochi and Watanabe [36] for any constant k>3 in k-edge-connected directed graphs. Specifically, we develop a novel randomized algorithm that computes the (k+2)-edge-connected components of a k-edge-connected digraph in O(k2mnlogn) time, for any k. Hence, we break the O(mn) barrier for k=o(n1/4/logn). Our first main result is summarized in the following theorem.

Theorem 1.

Let G be a k-edge-connected digraph, and let δ be a parameter with 0<δ<1. There exists a randomized algorithm that runs in O(k2mnlog(n/δ)) time and outputs a partition 𝒫 of V(G) satisfying the following guarantees:

  • Every two (k+2)-edge-connected vertices of G belong to the same set of 𝒫.

  • With probability at least 1δ, every two vertices of G that are not (k+2)-edge-connected are separated by 𝒫.

Hence, we achieve a significant improvement over the O(mn) bound of Nagamochi and Watanabe for all graph densities. Our approach introduces new structural insights into directed edge-cuts and combines these with both new and existing techniques. A key contribution of our work is a substantial simplification and generalization of the framework proposed in [21], which achieved an O~(mm) bound for computing the 3-edge-connected components of a digraph. We also give an extension of our algorithm that computes the (k+3)-edge-connected components of a given (k+2)-edge-connected component S of G in O(k3m|S|log(|S|/δ)) time.

Furthermore, we develop a variant of our algorithm that achieves O(mnlogn) running time for computing the 4-edge-connected components of a general directed graph.

Theorem 2.

Let G be a digraph, and let δ be a parameter with 0<δ<1. There exists a randomized algorithm that runs in O(mnlog(n/δ)) time and outputs a partition 𝒫 of V(G) satisfying the following guarantees:

  • Every two 4-edge-connected vertices of G belong to the same set of 𝒫.

  • With probability at least 1δ, every two vertices of G that are not 4-edge-connected are separated by 𝒫.

Note that Theorem 2 is not subsumed by Theorem 1, as we do not require the input digraph G to be 2-edge-connected. We also remark that all our results apply to multigraphs, that is, the input graph may contain parallel directed edges.

Our algorithm loosely follows the framework of Georgiadis et al. [21] in that it repeatedly performs local searches from sampled vertices. However, it replaces certain bottleneck computations of [21] by exploiting new structural insights into directed edge-cuts and combines both new and existing techniques, as detailed below.

Related work.

Connectivity-related problems are known to be much more difficult in directed graphs than in undirected graphs (see, e.g., [14, 24, 28]). Cuts in undirected graphs can be represented compactly by the Gomory-Hu tree (or cut tree), which can be used to identify the k-edge-connected components of undirected graphs, for any k. Furthermore, many efficient algorithms for computing Gomory-Hu trees are available (see e.g., [1, 2, 3, 9, 23, 31]). An O~(m+nk3)-time algorithm for computing the restricted version of the Gomory-Hu tree, that captures edge-cuts of size at most k, was presented by Hariharan, Kavitha, and Panigrahi [23]. In a breakthrough result, Korhonen [29] showed how to compute the k-edge-connected components of an undirected graph in O(m+kO(k2)n) time.

On the contrary, in directed graphs, edge cuts have a more complicated structure, and it was proved by Benczúr [7] that in this case, cut trees do not even exist. Linear-time algorithms for finding the 2-edge-connected components are given in [18, 19], and for finding the 3-edge-connected components in [17]. Schnorr [39] showed how to compute the minimum of 𝑓𝑙𝑜𝑤(u,v) and 𝑓𝑙𝑜𝑤(v,u), for all pairs of vertices u and v of a weighted digraph, using O(nlogn) max-flow computations. By computing k-bounded max-flow (i.e., the value min{k,𝑓𝑙𝑜𝑤(u,v)}) using k iterations of Ford-Fulkerson, this approach gives an O(mnklogn)-time algorithm for computing the k-edge-connected components of a digraph. If we use the O(m1+o(1)) max-flow algorithm of Chen et al. [9], we obtain an O(m1+o(1)n)-time algorithm, for any k. Nagamochi and Watanabe [36] presented an algorithm that computes the k-edge-connected components of a digraph in O(mnmin{k,n,m}) time. This remains the best bound for fixed k>3 and for sparse or moderately dense graphs. Cheung, Lau, and Leung [10] presented an algorithm that computes the edge connectivity between all pairs of vertices (i.e., λ(u,v) for all vertex pairs u,v) in O(mω) time, where ω<2.371339 is the matrix multiplication exponent [6]. Subsequently, Akmal and Jin [5] developed an O~((kn)ω)-time algorithm for computing the k-bounded edge connectivities between all vertex pairs, that is, the values min{k,λ(u,v)} for all u,vV (see also [4]). Note that knowing all k-bounded edge connectivities is sufficient to determine the i-edge-connected components of the graph for every ik.

Very recently, Hoppenworth, Saranurak, and Wang [26] established near-optimal bounds for a k-connectivity preserver of a directed graph G, that is, a subgraph H of G such that, for all ik, the i-edge-connected components of G and H coincide. They showed that any digraph with n vertices admits a k-connectivity preserver with O(k4knlogn) edges. Hence, a fast algorithm for constructing such a preserver would directly improve the running time bounds for computing k-edge-connected components. Still, the fast construction of these preservers remains an important open problem.

1.1 Overview of our techniques

A k-out set S is a set of vertices of G such that there are k edges from S to VS. Following [21], we base our algorithm on the notion of minimal (k+1)-out sets. Let G be the input digraph, and let UV(G) be a set of (k+1)-edge-connected vertices. We denote by λ(x,y) the size of the minimum (x,y)-cut in G. Let sU be a fixed vertex of G. Then, for any vU, we have λ(v,s)k+1. If there is a (k+1)-out set S with vS and sS, then we let M(v) denote the (inclusion-wise) minimum such (k+1)-out set. Otherwise, we let M(v)=. Then, for any vertex vU that is not (k+2)-edge-connected with s, the (k+2)-edge-connected component containing v is a subset of M(v). We use “MR” to denote the same concept as “M” in the reverse graph GR. We show that these M-sets are sufficient to determine the (k+2)-edge-connectivity relation for the vertices in U. Moreover, if the M-set of a vertex exists, we show how to compute it in time proportional to its volume using a variant of the local search procedure of [8].

We emphasize that the condition λ(v,s)k+1 for every vU is essential in order to correctly partition U into its (k+2)-edge-connected components. When refining a (k+1)-edge-connected component S into its constituent (k+2)-edge-connected components, we must carefully select a reference vertex sS. We address this issue by introducing the following decomposition.

(𝒌+𝟏)-edge-connected-component decomposition.

We begin by computing a decomposition of the input digraph G, into a collection H1,,Ht of directed graphs that preserve the (k+2)-edge-connected components of G. Each graph Hi contains two types of vertices, ordinary and auxiliary, where the ordinary vertices in Hi form a (k+1)-edge-connected component of G. Moreover, any two vertices u and v of G are (k+2)-edge-connected if and only if u and v are (k+2)-edge-connected ordinary vertices of a graph Hi.

Here, we present a randomized O~(k2m)-time algorithm that computes the (k+1)-edge-connected-component ((k+1)-ECC) decomposition of a k-edge-connected digraph, for any value of k. In addition, we provide a deterministic near-linear-time algorithm that computes the 3-edge-connected-component (3-ECC) decomposition of a general digraph. In both decompositions, the total size of the resulting graphs H1,,Ht is O(m). To achieve this, we exploit the computation of the nodes corresponding to a poset representation of the minimal k-out sets [14, 17] combined with a contraction operation for the (k+1)-ECC decomposition and the gadget substitution operation of [21] for the 3-ECC decomposition. Now, our goal is to partition the ordinary vertices in each graph Hi into (k+2)-edge-connected components.

Local search.

A (k)-out set S is a set of vertices of G such that there are at most k edges from S to VS. The volume of a vertex set S, denoted by 𝑣𝑜𝑙(S), is the number of edges (v,w) whose tail v is in S. Chechik et al. [8] considered the problem of computing a (k)-out set with the following restrictions: Given a graph G, a vertex v, and two integers Δ and k such that Δk1, the goal is to identify a (k)-out set S such that vS, all vertices in Sv are reachable from v in G[S], and vol(S)Δ, or to conclude that no such set S exists. [8] described a deterministic algorithm, 𝙻𝚘𝚌𝚊𝚕𝚂𝚎𝚊𝚛𝚌𝚑(G,v,k,Δ), with O(Δk2k) running time, for the following relaxation of the problem: (i) if there exists a (k)-out set S such that vS, all vertices in Sv are reachable from v in G[S], and vol(S)Δ, then 𝙻𝚘𝚌𝚊𝚕𝚂𝚎𝚊𝚛𝚌𝚑(G,v,k,Δ) returns a (k)-out set S such that vS, all vertices in Sv are reachable from v in G[S], and vol(S)(2k)k+2Δ, and (ii) otherwise it concludes that no such set S exists. Note that if a set S satisfying the constraints exists, then in this relaxed version, procedure 𝙻𝚘𝚌𝚊𝚕𝚂𝚎𝚊𝚛𝚌𝚑(G,v,k,Δ) returns a set S which satisfies all constraints except the bound on the volume of S, which can be larger by a factor of (2k)k+2. Later on, Forster et al. [12] presented a randomized algorithm for the relaxed version of the problem with O~(Δk2) running time.

Notice that the algorithms of [8, 12] are useful for Δ<m/k, as otherwise the whole vertex set V(G) may be returned. Here, we introduce a slight variant of the local search procedure of [8], that we refer to as 𝙻𝚘𝚌𝚊𝚕𝚂𝚎𝚊𝚛𝚌𝚑𝙵𝚘𝚛𝙼𝚂𝚎𝚝(G,v,s,k,Δ),which guarantees that the returned set S does not contain s. We make use of the following two simple observations: (i) the additional condition, sS, implies that we can use the local search procedure without any restriction on the volume Δ, i.e., it is not necessary to have Δ<m/k, and (ii) if λ(v,s)=k and 𝑣𝑜𝑙(M(v))Δ, then 𝙻𝚘𝚌𝚊𝚕𝚂𝚎𝚊𝚛𝚌𝚑𝙵𝚘𝚛𝙼𝚂𝚎𝚝(G,v,s,k,Δ) is guaranteed to return S=M(v).

Sampling for large 𝑴-sets.

We say that an M-set M(v) is “small” if its volume is at most m/n, and “large” otherwise. Using our modified local search from each vertex vs, we can afford to compute all small M-sets. In order to account for the partition of the ordinary vertices due to large M-sets, we sample the edges uniformly at random. Specifically, by sampling O~(n) edges, we can guarantee that for every M-set U with volume more than m/n, we have sampled at least one edge (v,w) whose tail v is in U with high probability.

Good partitions.

Since we cannot afford to compute all large M-sets explicitly, we must instead find a way to exploit the set M(v) associated with each sampled vertex v, i.e., the tail of a sampled edge (v,w). To this end, we define a partition 𝒫 of V to be good for v if:

  • 𝒫 maintains the (k+2)-edge-connected components, and

  • for every ordinary vertex u such that vM(u), the partition 𝒫 separates any ordinary vertex wM(u) from u.

We show that it suffices to compute a partition that is good for each sampled vertex v. To construct such partitions efficiently, we distinguish two cases depending on whether λ(v,s)>k or λ(v,s)k. In the former case, we exploit the directed acyclic graph (DAG) representation of all minimum cuts introduced by Picard and Queyranne [38]; in the latter, we leverage structural properties of latest minimum cuts. (A latest minimum (x,y)-cut is defined as the inclusion-wise maximum λ(x,y)-out set S such that xS and yS.)

1.2 Comparison to previous work

The linear-time algorithm of Georgiadis, Italiano, and Kosinas [17] relies on the concept of strongly divergent spanning trees [22], which is defined only for pairs of trees. Extending this approach to compute k-edge-connected components for k>3 would require k1 spanning trees with analogous edge- and vertex-disjointness properties. However, the result of Huck [27] implies that it may not be possible to find more than two spanning trees with these properties.

At a high level, our algorithm follows a framework similar to that of [21], but with several fundamental differences, which we highlight below.

Improved running time.

The framework in [21] required time O~(mm); the m factor appears by balancing the need to hit each component of interest (via random sampling) multiple times, and the time spent on the subsequent backward searches (that depended on the number of times each component was hit). In our framework, we overcome the need for backward searches and achieve a significant improvement in the running time, namely O~(mn) for any constant k.

Lack of gadgets.

The algorithm of Georgiadis et al. [21] repeatedly detects 2-out sets and 2-in sets, which are then replaced by connectivity-preserving gadgets of sufficiently small size. These gadgets possess the crucial property of reducing the (out- or in-)volume of the replaced component by a constant factor. This property enables [21] to perform Ω(n) local searches, each with a worst-case running time of Θ(m), without incurring a total cost of Ω(mn). Whenever a sequence of local searches becomes expensive, the corresponding gadget replacement significantly reduces the size of the graph, thereby ensuring a smaller amortized cost. For k4, however, no analogous gadget construction is known that would provide similar guarantees, making it unclear how to afford the time required for Ω(n) local searches.

No recursions.

The algorithm of [21] refines the current partition of the ordinary vertices after detecting an 2-out set or an 2-in set S, by simply separating the vertices inside S from those outside S. However, vertices inside S that are not 3-edge-connected can only be further separated through a recursive call that replaces VS with a gadget. A key technical difficulty of this approach is that the same edge may participate in multiple recursive calls, making the analysis tedious and heavily dependent on properties specific to the case k=3, which do not extend to k4. In contrast, our new framework leverages the structural properties of minimal k-out sets, eliminating the need for recursion entirely.

No triggered or backward searches.

Another major complication in [21] arises from handling intersecting 2-out sets. Consider a local search initiated from a sampled vertex v that identifies a large 2-out set S. There may exist several 2-out sets S1,,Sk that intersect S, such that the ordinary vertices in different sets Si are not 3-edge-connected. To separate these vertices, it is necessary to identify all such sets S1,,Sk; however, this cannot be achieved through sampling alone, since SiS may be very small. To address this issue, [21] employ a sequence of triggered and backward searches, that is, local searches initiated from specific vertices of previously identified 2-out set sets. Through a complex analysis, they show that it suffices to search for sets of volume O(m), resulting in an overall running time of O~(mm). In contrast, our framework completely avoids this complication by exploiting the structural properties of minimal k-out sets.

Simplicity.

Perhaps the two most technically involved contributions of [21] for the k=3 case were the gadget-substitution procedure and the backward searches. Our framework eliminates the need for both, giving an overall significantly simpler algorithm.

Extension for general 𝒌.

Although achieving an o(mn)-time algorithm for computing the k-edge-connected components of a general digraph, for any fixed constant k>4, remains out of reach, we believe that our techniques provide a promising step toward this goal. The main obstacles to attaining such a bound within our framework are the lack of (i) a fast decomposition of a general digraph into (k1)-edge-connected components, and (ii) an efficient algorithm for computing a good partition for a vertex v with λ(v,s)k2.

2 Technical Overview

In this section, we provide a high-level description of our algorithm and present the proof of our main result. Let G be a strongly connected graph with n vertices and m edges. In everything that follows, we assume that we work on the graph G, and all graph elements (e.g., vertices, edges, cuts, etc.) refer to G.

Let S be a set of vertices. Every edge of the form (x,y) with xS and yS is called an outgoing edge of S. The number of all outgoing edges of S is denoted as 𝑜𝑢𝑡(S). If 𝑜𝑢𝑡(S)=k, then S is called a k-out set. The tail of every outgoing edge of S is called a boundary point of S, and the head of every outgoing edge of S is called an exit point of S. We let 𝑣𝑜𝑙(S) denote the volume of S: i.e., the number of edges whose tail is in S. When we say that an edge e lies in a vertex set U, we mean that both endpoints of e are in U. Otherwise, we say that e does not lie in U.

Let X and Y be two disjoint sets of vertices. Then, every set of vertices S with XS and SY= is called an (X,Y)-cut. (Notice that the order of X and Y here is important.) We may also say that S separates X and Y (where, again, the order of X and Y in this expression is important). If X or Y consists of a single vertex, we may substitute it with the vertex that it consists of, and so we may speak of (x,Y)-cuts, or (x,y)-cuts, or (X,y)-cuts, where x and y are vertices. We denote by λ(X,Y) the size of the minimum (X,Y)-cut in G.

Let 𝒫 be a partition of V. If two vertices x and y belong to different sets from 𝒫, then we say that 𝒫 separates x and y. We say that 𝒫 maintains the (k+2)-edge-connected components if every two (k+2)-edge-connected vertices of G are in the same set of 𝒫.

2.1 (𝒌+𝟏)-edge-connected component decomposition

Our main approach is to exploit the notion of minimal (k+1)-out sets, defined with respect to a fixed source vertex s. To make this scheme work, we must ensure that every other ordinary vertex is (k+1)-edge-connected to s. We achieve this via the following decomposition.

Theorem 3 ((k+1)-Edge-Connected Component ((k+1)-ECC) Decomposition).

Let G be a k-edge-connected digraph with n vertices and m edges. In O~(k2m) time we can construct a collection H1,,Ht of graphs such that:

  • All graphs H1,,Ht are k-edge-connected.

  • The graphs H1,,Ht have O(n) vertices and O(m) edges in total.

  • The vertices V(Hi) of each graph Hi are partitioned into two sets of vertices, ordinary and auxiliary.

  • For each i{1,,t}, the ordinary vertices of V(Hi) are (k+1)-edge-connected.

  • For every vertex of G, there is exactly one graph among H1,,Ht that contains it as an ordinary vertex.

  • Every two vertices u and v of G are (k+2)-edge-connected if and only if there is an i{1,,t} such that u and v are (k+2)-edge-connected ordinary vertices of Hi.

The algorithm is randomized and returns a correct decomposition with probability at least 1δ, where δ(0,1) is a parameter specified by the user. If the algorithm fails to compute the correct decomposition, it detects this event and reports an error.

We note that for any constant k, we can avoid the use of randomization in the algorithm of Theorem 3, at the cost of an exponential dependency on k. Hence, we obtain a deterministic near-linear-time algorithm that computes a (k+1)-edge-connected-component ((k+1)-ECC) decomposition of a k-edge-connected digraph, for any constant k. Our algorithm exploits the computation of the nodes corresponding to a poset representation of the minimal k-out sets [14] combined with a contraction operation.

For k=2, we give a deterministic near-linear-time algorithm that computes a 3-edge-connected-component decomposition of a general digraph.

Theorem 4 (3-Edge-Connected Component (3-ECC) Decomposition).

Let G be a digraph with n vertices and m edges. In O~(m+n) time, we can construct a collection H1,,Ht of graphs such that:

  • All graphs H1,,Ht are strongly connected.

  • The graphs H1,,Ht have O(m) edges in total.

  • The vertices V(Hi) of each graph Hi are partitioned into two sets of vertices, ordinary and auxiliary.

  • For each i{1,,t}, the ordinary vertices of V(Hi) are 3-edge-connected.

  • For every vertex of G, there is exactly one graph among H1,,Ht that contains it as an ordinary vertex.

  • Every two vertices u and v of G are 4-edge-connected if and only if there is an i{1,,t} such that u and v are 4-edge-connected ordinary vertices of Hi.

Similarly to the (k+1)-ECC decomposition, we take advantage of the computation of the nodes corresponding to a poset representation of the minimal 2-out sets [17] combined with the gadget substitution operation of [21]. The details are provided in Section 5 in the full version of our paper [20].

2.2 Computing the (𝒌+𝟐)-edge-connected components through the minimum (𝒌+𝟏)-out sets

Theorem 3 implies that the computation of the (k+2)-edge-connected components of G reduces to that of the (k+2)-edge-connected components of the graphs H1,,Ht. Thus, from now on we may assume that the input graph G is k-edge-connected and satisfies the property that its vertex set can be partitioned into two kinds of vertices: ordinary and auxiliary. The ordinary vertices of G are (k+1)-edge-connected, and the goal is to compute a partition 𝒫 of V(G) such that two ordinary vertices are (k+2)-edge-connected if and only if they belong to the same set in 𝒫.

We achieve our goal through a randomized algorithm which may have a one-sided error: with probability at most δ (for any fixed δ>0 specified by the user), it may be that two ordinary vertices of G that are not (k+2)-edge-connected belong to the same set in 𝒫. However, if two ordinary vertices are (k+2)-edge-connected, then it is certain that they appear in the same set in 𝒫. The precise formulation of our main result is given in the following (where we assume that k is a fixed constant):

Theorem 5.

Let δ be a number with 0<δ<1. There is an algorithm (see Algorithm 1) that runs in O(mnlog(n/δ)) time, where n is the number of the ordinary vertices of G, and outputs a partition 𝒫 of V(G) with the following guarantees:

  • Every two (k+2)-edge-connected ordinary vertices of G are in the same set from 𝒫.

  • With probability at least 1δ, every two ordinary vertices of G that are not (k+2)-edge-connected are separated by 𝒫.

In order to establish Theorem 5, we utilize the concept of the minimum (k+2)-out sets. Specifically, we first fix an arbitrary ordinary vertex s of G. Then, for every ordinary vertex v such that there is a (k+1)-out set that separates v and s, we let M(v) denote the (inclusion-wise) minimum (k+1)-out set that contains v but not s. (The uniqueness of M(v) is guaranteed by Corollary 13.) If for an ordinary vertex v no such (k+1)-out set exists, then we let M(v)=. (In particular, we have M(s)=.) We use “MR” to denote the same concept as “M” in the reverse graph GR (where we have fixed the same ordinary vertex s in GR).

It should be clear that, if two ordinary vertices u and w are (k+2)-edge-connected, then we have M(u)=M(w) and MR(u)=MR(w). On the other hand, if u and w are not (k+2)-edge-connected, then Lemma 14 implies that either M(u)M(w) or MR(u)MR(w).

Thus, our approach is the following. First, we want to compute a partition 𝒫1 of V(G) with the property that two ordinary vertices have the same M-set if and only if they belong to the same set in 𝒫1. Then, we want to compute a partition 𝒫2 of V(GR) with the property that two ordinary vertices have the same MR-set if and only if they belong to the same set in 𝒫2. Then, the output 𝒫 is the common refinement of 𝒫1 and 𝒫2. The computation of 𝒫1 and 𝒫2 is performed independently on G and GR, using the same procedure. Thus, it is sufficient to describe the idea for computing 𝒫1.

Now we distinguish two types of M-sets w.r.t. their volume. We call a vertex set “small” if it has volume at most m/n. Otherwise, we call it “large”. The small M-sets can be computed explicitly using the following local-search-based procedure (which follows from an adaptation of techniques from [8]):

Proposition 6.

Let v be a vertex with vs and λ(v,s)k+1, and let Δ1 be an integer. There is an algorithm 𝙻𝚘𝚌𝚊𝚕𝚂𝚎𝚊𝚛𝚌𝚑𝙵𝚘𝚛𝙼𝚂𝚎𝚝(G,v,s,k+1,Δ) which runs in O(2k(k+1)!Δ) time and returns a set of vertices S (which may be ) with the following guarantees:

  • If S, then S=M(v).

  • If S=, then either M(v)= or 𝑣𝑜𝑙(M(v))>Δ.

Assuming that k is a fixed constant for our problem, we can use Proposition 6, in order to find all small M-sets in time O(n(m/n))=O(mn). Thus, we get a first partition of V(G) with the property that two ordinary vertices have the same small M-set if and only if they belong to the same set of that partition.

Notice that the dependency of the running time on k is exponential, but this can be improved to a polynomial dependence by using a randomized algorithm to perform the local searches (although this will incur a polylogarithmic overhead on the running time, in order to guarantee a sufficiently high probability of success).

Proposition 7.

Given that λ(v,s)k, there is a procedure (shown in Algorithm 5 in [20]) that has a running time of O(k2Δ) and returns a (possibly empty) set of vertices S with the following guarantees:

  • If S, then S=M(v).

  • If λ(v,s)=k and 𝑣𝑜𝑙(M(v))Δ, then, with probability at least 1/2, S.

For a randomized version of the local search, see Section 6.2 in [20]. We note that the local search procedure of choice can be plugged in as a black-box in Line 3 of Algorithm 1.

The case of the large M-sets is highly involved, because we cannot afford to compute all of them explicitly. We discuss how to handle those sets in the following section.

2.3 Sampling for large 𝑴-sets and computing good partitions

In order to account for the partition of the ordinary vertices due to the large M-sets, we rely on structural properties of the (k+1)-edge cuts of the graph. Our first step is to sample enough edges of the graph (uniformly at random, with repetitions allowed), so that, with sufficiently high probability, for every large M-set U, we have sampled at least one edge whose tail is in U. For this purpose, it is sufficient to sample O~(n) edges, due to the large volume of the large M-sets (see proof of Theorem 5).

Now, for every tail v of every sampled edge, we distinguish two possibilities: either λ(v,s)=k+1, or λ(v,s)k. (In the case λ(v,s)>k+1 we do nothing, because this implies that v is not included in a (k+1)-out set that separates v and s.)

In each of those cases, our goal is to provide a partition 𝒫 of V(G) with the property that (1) it maintains the (k+2)-edge-connected components, and (2) for every ordinary vertex u with M(u) and vM(u), and every ordinary vertex wM(u), we have that u and w are separated by 𝒫. More formally, we have:

Definition 8 (Good Partition).

Let v be any vertex such that λ(v,s)k+1. A partition 𝒫 of V is good for v if it satisfies the following properties:

  • 𝒫 maintains the (k+2)-edge-connected components.

  • For every ordinary vertex u with vM(u), and every ordinary vertex wM(u), we have that u and w are separated by 𝒫.

We provide a linear-time algorithm for computing a good partition when λ(v,s)=k+1, by exploiting the DAG representation of all minimum cuts introduced by Picard and Queyranne [38].

Proposition 9.

Let v be a vertex with λ(v,s)=k+1. Then there is an algorithm that runs in O(km) time and returns a good partition for v.

To obtain Proposition 9, we construct the Picard–Queyranne DAG representation of all minimum v-s cuts. This representation corresponds to the residual graph obtained after computing any maximum (v,s)-flow – which has value k+1, since λ(v,s)=k+1 – and contracting its strongly connected components (SCCs). The resulting SCCs define a partition of V, which we show satisfies Definition 8. The connection between the Picard–Queyranne DAG and the M-sets follows from a simple observation: for any ordinary vertex u with λ(u,s)=k+1, if vM(u), then M(u) is also a minimum v-s cut, and is therefore represented in the DAG. Full details are provided in Section 4.1.

The case where λ(v,s)=k is more involved. In this setting, we leverage structural properties of latest minimum cuts.

Proposition 10.

Let v be a vertex with λ(v,s)=k. Then there is an algorithm that runs in O(k2m) time and returns a good partition for v.

Let S be the latest mincut that separates v and s. This is the (inclusion-wise) maximum λ(v,s)-out set that separates v and s. The reason that we consider the latest mincut is that, first, this can be computed in linear time, and second, it captures the notion of having made the utmost progress before increasing the edge-connectivity. (This idea is made precise in Lemma 19.)

Note that S contains only auxiliary vertices (that is, λ(x,s)=k for all xS), so we may contract S into a single auxiliary vertex z with out-degree k. Now consider a set M(u) such that vM(u), and let U=M(u)S. For any ordinary vertex wM(u), we also have wU. To separate u and w, we distinguish two cases: (1) all k outgoing edges e1,,ek of z belong to E(U,VU); or (2) at least one outgoing edge ei of z lies inside U. In the former case, it suffices to compute the 2-edge-connected components of G{e1,,ek}, which can be done in linear time [18, 19]. In the latter case, we can contract ei, thereby reducing the problem to the case λ(v,s)=k+1.

2.4 Proof of the main theorem

We now present the proof of our first main result, stated in Theorem 1. We begin with the case where k is a fixed constant. In this setting, we can apply the deterministic version of the (k+1)-ECC-decomposition (see the paragraph right after the statement of Theorem 3), which runs in O~(m) time.

After this decomposition, we can consider a k-edge-connected graph G with n vertices and m edges, that consists of two kinds of vertices: ordinary and auxiliary. The ordinary vertices of G are (k+1)-edge-connected. Now, we provide the proof of Theorem 5.

Proof of Theorem 5.

Let s be a fixed ordinary vertex of G. First, we compute all M-sets with volume at most m/n. Specifically, for every ordinary vertex vs, we apply the algorithm 𝙻𝚘𝚌𝚊𝚕𝚂𝚎𝚊𝚛𝚌𝚑𝙵𝚘𝚛𝙼𝚂𝚎𝚝(G,v,s,k+1,Δ), whose guarantees are stated in Proposition 6. Thus, we get a vertex set S(v) such that, if M(v) and 𝑣𝑜𝑙(M(v))m/n, then S(v)=M(v). Otherwise, we may still get M(v), or . (In any case, we will not get a non-empty output which is distinct from M(v).) Since we apply this procedure for every ordinary vertex vs (and the number of such ordinary vertices may be as large as n1), by Proposition 6 we get an O((n1)m/n)=O(mn) time bound for this step. The total output is a collection of O(n) sets of vertices with O(m/n) vertices in each set. We can sort those sets in O(nm/n)=O(mn) time with bucket sort, and determine the partition 𝒫1 of the ordinary vertices that have the same M-set with volume O(m/n). To be more precise, if for two distinct ordinary vertices v and v we have S(v)=S(v), then we put v and v in the same set in 𝒫1. (And we can put all auxiliary vertices of G in a single set in this partition.) Thus, if two ordinary vertices are (k+2)-edge-connected, then they appear in the same set in 𝒫1.

Now we have to consider the separations induced by the M-sets of ordinary vertices with volume larger than m/n. To do this, we first sample enough edges (uniformly, with repetitions allowed) so that, with probability at least 1δ, we have that, for every such “large” M-set U, we have sampled at least one edge whose tail is in U. Thus, it is sufficient to sample N=nlog2(n/δ) edges. To see this, consider an M-set U with volume more than m/n. This means that there are more than m/n edges whose tail is in U. Then, the probability that a randomly chosen edge does not have its tail in U is less than 1(m/n)/m=11/n. Thus, the probability that, after N samples, we have not sampled an edge whose tail is in U is less than

(11/n)N2N/n2nlog2(n/δ)/n=2log2(n/δ)=δ/n.

Thus, since n is a trivial upper bound on the number of distinct M-sets, by the union bound we have that: the probability that there is an M-set U with volume more that m/n for which we have not sampled an edge whose tail is in U is less than δ.

Thus, from now on, we may assume that: for every M-set U with volume more than m/n, we have sampled at least one edge whose tail is in U ().

Now, for every tail v of an edge that we have sampled, we do the following. First, we perform at most k+2 iterations of Ford-Fulkerson’s algorithm, in order to determine whether λ(v,s)k, or λ(v,s)=k+1, or λ(v,s)>k+1. (This takes time O(km).) In the first and second case, we apply Proposition 10 and Proposition 9, respectively, on v, in order to get a partition 𝒫(v) of V(G) with the guarantess provided by the respective proposition. (Again, this step takes O(m) time.) In the third case (i.e., if λ(v,s)>k+1), we do nothing. Thus, we get a collection of O(N) partitions of V(G) in total time O(Nm)=O(nlog(n/δ)m). We compute the common refinement 𝒫2 of those partitions with bucket sort, and this takes time O(nN). Then, we return the common refinement of 𝒫1 and 𝒫2, which takes O(n) time to be computed. This is how we get a partition 𝒬. Notice that, by the guarantees of Propositions 10 and 9, we have that 𝒬 maintains the (k+2)-edge-connected components of G.

Now we repeat the same process on the reverse graph GR, with the same fixed vertex s, and thus we get a partition 𝒬R. Our final output is the common refinement of 𝒬 and 𝒬R.

In order to establish correctness, it remains to show that: if two ordinary vertices u and w are not (k+2)-edge-connected, then they appear in distinct sets in the final output. So let u and w be two ordinary vertices that are not (k+2)-edge-connected. Then, by Lemma 14 we have that either M(u)M(w) or MR(u)MR(w). Let us assume, w.l.o.g., that M(u)M(w). Now, if either 𝑣𝑜𝑙(M(u))m/n or 𝑣𝑜𝑙(M(w))m/n, then u and w are separated by 𝒫1, and thus by the final output. Otherwise, for each of u and w we have that its M-set is either , or it has volume more than m/n, but they cannot both be . Now, since M(u)M(w), by Lemma 15 we have that either M(u) and wM(u), or M(w) and uM(w). Thus, we may assume, w.l.o.g., that M(u) and wM(u). Now, since 𝑣𝑜𝑙(M(u))>m/n, our assumption () implies that we have sampled at least one edge whose tail v is in M(u). Then, we obviously have that λ(v,s)k+1, and therefore one of Propositions 10 and 9 (depending on whether λ(v,s)k or λ(v,s)=k+1, respectively), implies that 𝒫(v) separates u and w. Thus, u and w are separated by the final output.

(Notice that our assumption () holds on G with probability more than 1δ. However, we want the same assumption to hold simultaneously for G and GR with probability more than 1δ. Thus, we should have chosen δ to be half of the desired probability of failure, so that, by the union bound, this assumption is satisfied simultaneously in G and GR with the desired probability of success.)

Algorithm 1 Compute the (k+2)-edge-connected components of G, with probability at least 1δ.

If we drop the assumption that k is a fixed constant, then, by relying throughout on the deterministic local search procedure of Proposition 6, there is an exponential dependency on k in the time bound for computing the (k+2)-edge-connected components. We can improve this dependency to polynomial, by using instead the randomized local search procedure of Proposition 7. The local search procedure is used in two different places in our framework: in the algorithm for computing the (k+1)-ECC-decomposition (Theorem 3), and in the search for small M-sets in Line 3 of Algorithm 1.

In particular, if we want to have the same guarantees for Algorithm 1 as in the statement of Theorem 5, but with a running time of O(k2mnlog(n/δ)), then we must replace the local search procedure in Line 3 with that provided by Proposition 7, and repeat it for log(4n/δ) times for every vertex vs. This is in order to get a δ/(4n) bound on the probability of failure for every vertex vs, for the search for small M-sets in each direction (i.e., in G and in GR), so that the union bound gives a δ/2 bound on the probability of failure for this search in both directions. Furthermore, we must increase the sampling rate in Line 5 from nlog2(2n/δ) to nlog2(4n/δ), in order to also get a δ/2 bound on the probability of failure for the search for large M-sets (in both directions). Thus, by the union bound, the total probability of failure of Algorithm 1 can be bounded by δ.

Overall, in order to establish Theorem 1, we need as input the graph G, and the parameters k and δ. First, we employ the randomized decomposition of Theorem 3, which runs in O~(k2m) time and produces a correct decomposition H1,,Ht with probability at least 1δ/2. Then, for each graph Hi, we apply Algorithm 1 with bound δ/(2n) on the probability of failure. This is because: first, there are at most n graphs Hi on which we apply this algorithm, and second, each of those graphs has at most n ordinary vertices (that correspond to vertices of the original graph). Thus, the union bound establishes the δ bound on the probability of failure for computing the (k+2)-edge-connected components of the original graph G.

2.5 Computing the 𝟒-edge-connected components

In order to establish Theorem 2, we use the same framework that we applied in order to establish Theorem 1, with some crucial differences that we will discuss here. (Notice that Theorem 2 is not an immediate consequence of Theorem 1, because here we assume that the input graph G is any general digraph, i.e., not necessarily k-edge-connected.)

First, Theorem 4 implies that the computation of the 4-edge-connected components of G reduces to that of the 4-edge-connected components of the graphs (of the 3-ECC decomposition) H1,,Ht. Thus, from now on we may assume that the input graph G is strongly connected and has two kinds of vertices: ordinary and auxiliary, where the ordinary vertices are 3-edge-connected. The goal is to compute a partition 𝒫 of V(G) such that two ordinary vertices are 4-edge-connected if and only if they belong to the same set in 𝒫.

Now we fix an ordinary vertex s, and we apply Algorithm 1, with the following modification in Line 10: instead of using Proposition 10, we use Proposition 11. This is because here we may have λ(v,s){1,2} (whereas with the assumption that the graph is k-edge-connected, only the case λ(v,s)=k can arise).

Proposition 11.

Let G be a strongly connected graph that has two kinds of vertices: ordinary and auxiliary, where the ordinary vertices are 3-edge-connected. Let s be an ordinary vertex, and let v be a vertex with λ(v,s)2. Then there is an algorithm that runs in O(m) time and returns a partition 𝒫 of V(G) with the following properties:

  • 𝒫 maintains the 4-edge-connected components of G.

  • For every two ordinary vertices u and w with vM(u) and wM(u), we have that u and w are separated by 𝒫.

(Here “M(u)” is the minimum 3-out set that separates u from s.)

We note that Line 10 is the only place in which the use of Algorithm 1 for the computation of the 4-edge-connected components differs from that for the computation of the (k+2)-edge-connected components. In particular, in Lines 3, 7 and 9, we just replace “k” with “2”. The analysis is the same as in Sections 2.2 and 2.4, where the “M” sets here have the meaning of minimal 3-out sets that separate ordinary vertices from s. The proof of Proposition 11 is discussed in Section 4.2.

3 Basic definitions

3.1 The operator of local edge connectivity

Let X and Y be two disjoint sets of vertices. If there is a k-out set S with XS and SY=, then we say that S is a k-cut that separates X and Y. (We note that the order of X and Y here is important.) Furthermore, if there is no k-out set S with k<k such that XS and SY=, then we say that S is an (X,Y)-mincut. If there is an (X,Y)-mincut S with 𝑜𝑢𝑡(S)=k, then we write λ(X,Y)=k. (We note that the operator λ does not necessarily act symmetrically on sets of vertices.)

If either of X and Y consists of a single vertex, then we may substitute it in the expression “λ(X,Y)” with the vertex that it consists of. (E.g., if X={x}, then we may denote λ(X,Y) simply as λ(x,Y).) Furthermore, we may write “λG” instead of just “λ”, if we want to specify the reference graph G.

Lemma 12.

Let X and Y be two disjoint sets of vertices with λ(X,Y)=k, and let S and S be two k-out sets that separate X and Y. Then, both SS and SS are k-out sets.

Proof.

Due to the submodularity of the cut function, we have 𝑜𝑢𝑡(SS)+𝑜𝑢𝑡(SS)𝑜𝑢𝑡(S)+𝑜𝑢𝑡(S), and therefore 𝑜𝑢𝑡(SS)+𝑜𝑢𝑡(SS)2k. Notice that both SS and SS are cuts that separate X and Y. Thus, since λ(X,Y)=k, we have 𝑜𝑢𝑡(SS)k and 𝑜𝑢𝑡(SS)k. Therefore, we have 2k𝑜𝑢𝑡(SS)+𝑜𝑢𝑡(SS), and thus we infer that 𝑜𝑢𝑡(SS)=k and 𝑜𝑢𝑡(SS)=k.

We will be using the following corollary throughout, without explicitly invoking it.

Corollary 13.

Let X and Y be two disjoint sets of vertices with λ(X,Y)=k. Then there is an inclusion-wise minimum k-out set that separates X and Y. Furthermore, there is an inclusion-wise maximum k-out set that separates X and Y.

Proof.

Consider the collection 𝒮 of all k-out sets that separate X and Y. Then, Lemma 12 implies that 𝒮 is a k-out set that separates X and Y. Similarly, Lemma 12 implies that 𝒮 is a k-out set that separates X and Y.

Let Z be a set of vertices of G, and let GZ be the graph that is formed by contracting Z into a single vertex z. If X is a set of vertices of GZ, then we let X denote X if zX, and (X{z})Z otherwise. (I.e., X is the “uncontraction” of X in G.) Then it is easy to see that, for every set of vertices S of GZ, we have 𝑜𝑢𝑡GZ(S)𝑜𝑢𝑡G(S). This implies that, for every two disjoint sets of vertices X and Y of GZ, we have λGZ(X,Y)λG(X,Y). (I.e., the process of contracting vertices can only increase the edge connectivity.)

3.2 Minimum (𝒌+𝟏)-out sets

In everything that follows, we will use “s” to denote a fixed ordinary vertex of G. We will use s in order to consider minimum (k+1)-out sets that separate vertices from it. Specifically, let v be a vertex with λ(v,s)k+1. If there is a (k+1)-out set S with vS and sS, then we let M(v) denote the (inclusion-wise) minimum such (k+1)-out set. Otherwise, we let M(v)=. We use “MR” to denote the same concept as “M” in the reverse graph GR.

The reason that we consider the M-sets is twofold. First, those sets are sufficient in order to determine the relation of (k+1)-edge-connectivity, as shown in Lemma 14.222A similar observation was utilized in [17], in order to compute the 3-edge-connected components in linear time. Specifically, [17] also uses a concept of M-sets, which are the minimum 2-in sets that separate s from a vertex. Lemma 14 is analogous to Proposition III.5 in [17]. And second, if the M-set of a vertex exists, then it can be computed in time proportional to its volume using a local search procedure (see Proposition 6).

Lemma 14.

Let u and w be two ordinary vertices that are not (k+2)-edge-connected. Then, either M(u)M(w), or MR(u)MR(w).

Proof.

Since u and w are not (k+2)-edge-connected (but they are (k+1)-edge-connected), we may assume, w.l.o.g., that there is a (k+1)-cut S that separates u and w. Now there are two possibilities: either sS, or sS. Let us first consider the case that sS. Then, S is a (k+1)-cut that separates u and s, and therefore M(u) exists and M(u)S. Then, since wS, we have wM(u). Therefore, we infer that either M(w) does not exist, or M(w)M(u) (because, if M(w) exists, it satisfies wM(w)). Now let us assume that sS. Then, VS is a (k+1)-cut in GR that separates w and s. Thus, we have MR(w)VS, and uMR(w). Therefore, we infer, as previously, that either MR(u) does not exist, or MR(u)MR(w).

Lemma 15.

Let u and w be two ordinary vertices such that M(u)M(w). Then, either M(u) and wM(u), or M(w) and uM(w).

Proof.

Since M(u)M(w), we cannot have M(u)= and M(w)=. Thus, we may assume, w.l.o.g., that M(u). Now, if wM(u), then we are done. So let us assume that wM(u). Then, M(u) is a (k+1)-out set that separates w and s, and therefore M(w). Then, due to the minimality of M(w), we have M(w)M(u). Now, if we assume that uM(w), then, due to the minimality of M(u), we get M(u)M(w), and therefore we have M(u)=M(w), which contradicts the assumption in the statement of the lemma. Thus, we conclude that uM(w).

In order to compute M-sets of “small” volume (and, later on, separations of vertices induced by M-sets of “large” volume), we rely on the following local search procedure.

Proposition 6. [Restated, see original statement.]

Let v be a vertex with vs and λ(v,s)k+1, and let Δ1 be an integer. There is an algorithm 𝙻𝚘𝚌𝚊𝚕𝚂𝚎𝚊𝚛𝚌𝚑𝙵𝚘𝚛𝙼𝚂𝚎𝚝(G,v,s,k+1,Δ) which runs in O(2k(k+1)!Δ) time and returns a set of vertices S (which may be ) with the following guarantees:

  • If S, then S=M(v).

  • If S=, then either M(v)= or 𝑣𝑜𝑙(M(v))>Δ.

(Notice that the guarantees of Proposition 6 imply that if M(v) and 𝑣𝑜𝑙(M(v))Δ, then the output S will be M(v).)

We note that Proposition 6 follows from a straightforward adaptation of ideas contained in [8], for computing minimal sets of vertices with a bounded number of outgoing edges, through a local search procedure. In order to understand the relation between Proposition 6 and the local search procedure of [8], we recall the following concept from [8]. Let u be a vertex of a graph G, and let k0 be an integer. Then, a set of vertices S is called a k-edge-out component of u if uS and 𝑜𝑢𝑡(S)k, and there is no set of vertices S with uSS such that 𝑜𝑢𝑡(S)𝑜𝑢𝑡(S). The number of edges of G[S] is called the volume of S. Now, given a vertex u and two integers k and Δ, we have the following:

Lemma 16 ([8]).

In O((2k)k+1Δ) time we can find a (k1)-edge-out component of u with volume less than (2k1)(Δ+1), or determine that there is no (k1)-edge-out component of u with volume at most Δ.

The idea behind Lemma 16 is roughly the following. If there is a (k1)-edge-out component S of u with volume at most Δ, then there is a DFS-based procedure, that starts from u, explores O(kΔ) edges, and finds a set of O(k) paths with the property that at least one of them starts from u and ends outside of S. Then, by reversing the direction of the edges of such a path, S becomes a (k2)-edge-out component in the resulting graph. Thus, if we repeat this process O(k) times, in the end it is sufficient to just explore the reachability set of u in the resulting graph, and this provides S.

There is an obvious similarity between the guarantees of Lemma 16 for k=k+2 and Proposition 6. Specifically, it is easy to see that, if we have a vertex vs with λ(v,s)=k+1, then M(v) is a (k+1)-edge-out component of v. Therefore, if G[M(v)] has volume at most Δ, then Lemma 16 will be able to identify a (k+1)-edge-out component of v in O(Δ) time. However, the (k+1)-edge-out component of v returned by Lemma 16 may have less than k+1 outgoing edges. This is because there may exist a k-out set with k<k+1 that contains both v and s and has sufficiently small volume. (In fact, the whole graph is a 0-edge-out component of v, and thus for sufficiently large Δ we just get the whole graph as output.) But here it helps precisely that we know that s is outside of M(v). Thus, whenever we happen to meet s during the (DFS-based) local search procedure, we can immediately pick and reverse the discovered path from v to s. This is the crux of the adaptation that we had to make to the local search procedure from [8]. The full proof of Proposition 6 is given in [20].

3.3 Latest mincuts

Let s and t be two distinct vertices with λ(s,t)=k. By Corollary 13, there is an inclusion-wise maximum k-out set S that separates s and t. We call S the latest (s,t)-mincut. (We note that the order of s and t is important.)

The intuitive reason that we consider latest mincuts is because these are the furthest that we can cut, without exceeding the value of the minimum cut; a precise formulation of this property is provided in Lemma 19. Furthermore, the latest mincuts for pairs of vertices with bounded edge-connectivity can be computed in linear time, as shown in the following lemma. We note that the notion of the latest (s,t)-mincut was introduced by Ford and Fulkerson [11], who showed how to compute it using the residual graph of the corresponding flow problem. For completeness – and because we will later use similar arguments – we provide a self-contained proof that does not rely on flow-based techniques.

Lemma 17.

Let s and t be two distinct vertices of G with λ(s,t)=k. Then, the latest (s,t)-mincut can be computed in O(km) time.

Proof.

Let S be the latest (s,t)-mincut. Now we apply the following procedure (essentially k iterations of Ford-Fulkerson’s algorithm for computing an (s,t)-maxflow). First, we compute a path P1 in G0:=G from s to t. Then we reverse the direction of the edges of P1, and let G1 be the resulting graph. Now suppose that we have computed a path Pi from s to t in Gi1 and a graph Gi using the same process, for some i{1,,k1}. Then, we compute a path Pi+1 from s to t in Gi, we reverse the direction of the edges of Pi+1 in Gi, and let Gi+1 be the resulting graph. Finally, we compute the set of vertices S of Gk that cannot reach t. Obviously, this whole procedure can be completed in O(km) time.

Our goal is to show that S=S. First, a repeated application of Lemma 58 in [20] implies that 𝑜𝑢𝑡Gk(S)=0. Thus, no vertex from S can reach t in Gk, and therefore SS. Since S is an (s,t)-cut and S is the inclusion-wise maximum k-out set in G that separates s and t, we infer that 𝑜𝑢𝑡G(S)k. Now, a repeated application of Lemma 58 in [20] implies that 𝑜𝑢𝑡Gk(S)=𝑜𝑢𝑡G(S)k. Due to the definition of S, we have 𝑜𝑢𝑡Gk(S)=0. This implies that 𝑜𝑢𝑡G(S)=k. Therefore, due to the maximality of S, we conclude that S=S.

Lemma 18.

Let s and t be two distinct vertices, and let S be an (s,t)-mincut (not necessarily the latest). Then, every boundary point of S in G is reachable by s through a path in G[S].

Proof.

Let R be the set of vertices that are reachable by s in G[S]. Thus, we have sR and RS. Therefore, R is an (s,t)-cut, and therefore 𝑜𝑢𝑡G(R)λ(s,t). Furthermore, by the definition of R we have that every outgoing edge of R in G is an outgoing edge of S in G. Thus, 𝑜𝑢𝑡G(R)𝑜𝑢𝑡G(S). Then, since 𝑜𝑢𝑡G(S)=λ(s,t), we infer that 𝑜𝑢𝑡G(R)=λ(s,t). This shows that the set of the outgoing edges of R in G coincides with the set of the outgoing edges of S in G. We conclude that R includes the tails of the outgoing edges of S in G (i.e., the boundary points of S).

For convenience, we use the following notation. Let v be a vertex of a graph H. Then 𝑟𝑒𝑎𝑐ℎH(v) denotes the set of vertices that are reachable from v. In other words, 𝑟𝑒𝑎𝑐ℎH(v) consists of every vertex x of H for which there exists a path that starts from v and ends in x.

Lemma 19.

Let s and t be two distinct vertices, let S be the latest (s,t)-mincut, let R=𝑟𝑒𝑎𝑐ℎG[S](s), and let x be an exit point of S with xt. Then λ(R{x},t)>𝑜𝑢𝑡(S).

Proof.

Notice that R{x} is an (s,t)-cut, and therefore λ(R{x},t)𝑜𝑢𝑡(S). Now let us suppose, for the sake of contradiction, that λ(R{x},t)=𝑜𝑢𝑡(S). This implies that there is an (R{x},t)-cut R with 𝑜𝑢𝑡(R)=𝑜𝑢𝑡(S). Our goal is to show that SR is an (s,t)-cut with 𝑜𝑢𝑡(SR)=𝑜𝑢𝑡(S), which contradicts the fact that S is the latest (s,t)-mincut (because SR is strictly larger than S, since it contains x). Throughout this proof, whenever we speak of an outgoing edge of a set of vertices, we mean an outgoing edge in G.

Let U be the set of vertices from S that are unreachable by s in G[S]. (I.e., U=SR.) Then, we have S=RU. Notice that every outgoing edge of U has its head in R. (Otherwise, there exists an edge (z,w) with zU and wS. Thus, (z,w) is an outgoing edge of S. But then, since S is an (s,t)-mincut, by Lemma 18 we have that s can reach z in G[S], in contradiction to the definition of U.)

Now, since S=RU and RR, we have SR=UR. Let (z,w) be an outgoing edge of SR. Then, either zU or zR. If zU, then (z,w) is an outgoing edge of U, and so wR. But RR, and so (z,w) cannot be an outgoing edge of SR. Thus, we have zR. Then, (z,w) is an outgoing edge of R. This shows that the set of the outgoing edges of SR is a subset of the set of the outgoing edges of R. Thus, we have 𝑜𝑢𝑡(SR)𝑜𝑢𝑡(R). But since 𝑜𝑢𝑡(R)=𝑜𝑢𝑡(S), this implies the desired contradiction.

4 Finding good partitions induced by the large 𝑴-sets

In this section we assume that G is a strongly connected graph, where some of its vertices are designated as “ordinary” and they are (k+1)-edge-connected. Let s be a fixed ordinary vertex. For every ordinary vertex u with λ(u,s)=k+1, we let M(u) denote the inclusion-wise minimum (k+1)-out set that separates u and s.

Our goal is to establish Proposition 9, 10, and 11. The proofs of Propositions 9 and 10 are provided in Sections 4.1 and 4.2, where they appear as Proposition 22 and Proposition 23, respectively, because the corresponding properties of the computed partitions are explained formally in their statements. The proof of Proposition 11 is discussed in Section 4.2, because this is established by using the same techniques as in Proposition 23.

4.1 Proof of Proposition 9 (using the Picard-Queyranne graph)

Let a and b be two distinct vertices of G. If G is a multigraph, then we consider it as a simple capacitated graph, with capacity function c:E(G), where c(e) for every edge e equals the multiplicity of e in the original graph. Let us define an (a,b)-flow f as a function f:E(G) with the following two properties:

  1. 1.

    0f(e)c(e), for every edge e of G. (I.e., the flow passing through every edge cannot exceed its capacity.)

  2. 2.

    e=(u,v)f(e)=e=(v,u)f(e), for any vertex vV(G){a,b}. (I.e., the amount of flow entering any vertex v{a,b} equals the amount of flow exiting v.)

Without loss of generality, we may assume that no flow enters the source vertex a and no flow leaves the sink vertex b, i.e., f(e)=0 for any edge e=(v,a) and any edge e=(b,v).

We call e=(a,u)f(e) the value of f. (I.e., the value of f is the amount of flow exiting a.) It is well known that an (a,b)-flow with value λ(a,b) exists, and this is in fact the maximum value of any (a,b)-flow. We call such a flow an (a,b)-maxflow.

Definition 20 (Picard-Queyranne graph).

Let f be an (a,b)-maxflow of G. Then we define a graph 𝑃𝑄 with V(𝑃𝑄)=V(G) as follows. For every edge e=(x,y) of G, there is an edge (x,y) in 𝑃𝑄 if f(e)<c(e), and an edge (y,x) if f(e)>0. 𝑃𝑄 is called the Picard-Queyranne graph that corresponds to f.

We note that, since G is strongly connected, it is not difficult to see that a is reachable by all vertices in 𝑃𝑄, and b reaches all vertices in 𝑃𝑄. (Thus, if we contract every strongly connected component of 𝑃𝑄 into a single vertex, then the node containing b is the only source, and the node containing a is the only sink in the resulting DAG.)

Picard and Queyranne [38] have provided the following characterization of the (a,b)-mincuts of G:

Proposition 21 (Theorem 1 in [38]).

A set of vertices X of G is an (a,b)-mincut if and only if: it contains a, it does not contain b, and it is closed w.r.t. the reachability relation in 𝑃𝑄 (i.e., for every xX, we have 𝑟𝑒𝑎𝑐ℎPQ(x)X).

We will prove the following.

Proposition 22.

Let v be a vertex with λ(v,s)=k+1. There is an algorithm that runs in O(km) time and returns a partition 𝒫 of V(G) with the following properties:

  • 𝒫 maintains the (k+2)-edge-connected components of G.

  • For every two ordinary vertices u and w with vM(u) and wM(u), we have that u and w are separated by 𝒫.

Proof.

First we perform k+1 iterations of Ford-Fulkerson’s augmenting paths algorithm (e.g. using BFS), in order to find a maximum (v,s)-flow. Then we construct the corresponding graph 𝑃𝑄 as described in Definition 20, and we let 𝒫 be the collection of the strongly connected components (viewed as vertex-sets) of 𝑃𝑄. Thus, the computation of 𝒫 takes O(km) time.

Now let u and w be two vertices of G that are separated by 𝒫. Then, at least one of those vertices is unreachable by the other in 𝑃𝑄. Thus, we may assume w.l.o.g. that u cannot reach w in 𝑃𝑄. This implies that u cannot reach the strongly connected component of s in 𝑃𝑄 (because s reaches all vertices of 𝑃𝑄), and therefore X=𝑟𝑒𝑎𝑐ℎPQ(u) is a (v,s)-mincut of G. Since λ(v,s)=k+1, we have that X is a (k+1)-out set of G. Furthermore, X separates u and w. Thus, u and w are not (k+2)-edge-connected in G. This establishes the property that 𝒫 maintains the (k+2)-edge-connected components of G.

Now let u and w be two ordinary vertices of G with vM(u) and wM(u). This implies that M(u) is a (k+1)-out set that separates u and s. Therefore, since vM(u), we have that M(u) is a (v,s)-mincut. According to Proposition 21, this implies that 𝑟𝑒𝑎𝑐ℎPQ(u)M(u). Thus, since wM(u), we have that u cannot reach w in 𝑃𝑄, and therefore u and w are separated by 𝒫.

4.2 Proof of Proposition 10

We will prove the following.

Proposition 23.

Let v be a vertex with λ(v,s)=k. There is an algorithm that runs in O(k2m) time and returns a partition 𝒫 of V(G) with the following properties:

  • 𝒫 maintains the (k+2)-edge-connected components of G.

  • For every two ordinary vertices u and w with vM(u) and wM(u), we have that u and w are separated by 𝒫.

Proof.

We apply the procedure shown in Algorithm 2. Thus, first we compute the latest (v,s)-mincut S. By Lemma 17, this takes O(km) time. Notice that S does not contain any ordinary vertex of G (because the ordinary vertices are (k+1)-edge-connected, and S is a k-out set).

Then, we contract S into a single vertex z, and let G~ be the resulting graph. It is easy to establish the following two facts: (i) for every two vertices x and y of G with x,yS, we have λG~(x,y)λG(x,y), and (ii) the out-degree of z in G~ is k. Let {e1,,ek} be the set of the outgoing edges of z in G~.

Now, as shown in Line 4, we first remove all outgoing edges of z from G~, and we compute the partition 𝒬0 of the 2-edge-connected components of the resulting graph, that we denote by G~. By [18], this takes linear time. Let 𝒫0 be the partition of V(G) that corresponds to 𝒬0. (I.e., every set of 𝒬0 is a set of 𝒫0, except for the set U𝒬0 that contains z, which is replaced by (U{z})S.) Let x and y be two vertices of G with x,yS and λG(x,y)k+2. Then, by (i) we infer that λG~(x,y)2. Thus, 𝒫0 maintains the (k+2)-edge-connected components of G.

Then, for every i{1,,k} such that the head xi of ei is not s, we contract z with xi into a single vertex zi, and let G~i be the resulting graph (derived from G~). Notice that G~i is essentially the same graph as if we had contracted the vertex set S{xi} of G into zi. Thus, it is not difficult to see that Lemma 19 implies that λG~i(zi,s)>λG(v,s)=k. (To be precise, Lemma 19 implies that λG(R{xi},s)>k, where R=𝑟𝑒𝑎𝑐ℎG[S](v). But then, since R{xi}S{xi}, we have λG(R{xi},s)λG(S{xi},s). Thus, we get λG(S{xi},s)>k, which implies that λG~i(zi,s)>k.) Now, if λG~i(zi,s)=k+1, then we can apply Proposition 22 on G~i (with v=zi), in order to get a partition 𝒬i. By Proposition 22, we have that 𝒬i maintains the (k+2)-edge-connected components of G~i. Then, since G~i is essentially derived from G by contracting S{xi} into a single vertex, we have that the partition 𝒫i of V(G) that corresponds to 𝒬i maintains the (k+2)-edge-connected components of G.

The output of Algorithm 2 is the partition 𝒫 which is the common refinement of 𝒫0 and all 𝒫i, for i{1,,k} such that the head xi of ei is not s and λG(S{xi},s)=k+1. Therefore, so far we have established that 𝒫 maintains the (k+2)-edge-connected components of G.

Now let u and w be two ordinary vertices of G such that vM(u) and wM(u). Consider the set of vertices U=M(u)S. As w is an ordinary vertex, we have wU. We will show that 𝑜𝑢𝑡G(U)=k+1. By the submodularity of the cut function we have

𝑜𝑢𝑡G(M(u)S)+𝑜𝑢𝑡G(M(u)S)𝑜𝑢𝑡G(M(u))+𝑜𝑢𝑡G(S).

We have 𝑜𝑢𝑡G(M(u))=k+1 and 𝑜𝑢𝑡G(S)=k. On the other hand, we have 𝑜𝑢𝑡G(M(u)S)k (because M(u)S is a (v,s)-cut), and 𝑜𝑢𝑡G(M(u)S)k+1 (because M(u)S is a (u,s)-cut). Thus, we infer that 𝑜𝑢𝑡G(M(u)S)=k+1.

Now consider the projection U~ of U from G into G~. Then, since SU, we have 𝑜𝑢𝑡G~(U~)=𝑜𝑢𝑡G(U), and therefore U~ is a (k+1)-out set of G~. Notice that u,zU~ and wU~. Now, if the outgoing edges of z in G~ are outgoing edges of U~, then their removal from G~ drops the connectivity from u to w to 1. Thus, u and w are separated by 𝒬0, and therefore by 𝒫0, and therefore by 𝒫. Otherwise, we have that at least one outgoing edge ei of z in G~ lies entirely within U~. Then, since we contract z with the head of ei into a vertex zi in order to get G~i, it is easy to see that the projection of U~ into G~i is a (k+1)-out set of G~i that contains zi, and does not contain w or s. Then, by Proposition 22 we infer that u is separated from w by 𝒫i, and therefore by 𝒫.

Notice that we get the O(k2m) time bound because we apply at most k times the algorithm that establishes Proposition 22 on graphs that have at most as many edges as G.

In order to establish Proposition 11, we can use Algorithm 2 with the following modifications (and the proof of correctness is similar to that of Proposition 23). First, if λ(v,s)=2, then we just apply this algorithm with k=2. However, if λ(v,s)=1, then the vertex z, that appears in Line 2 (and is the contraction of the latest (v,s)-mincut S), has a unique outgoing edge e1. Thus, in Line 4 we perform a computation of the 3-edge-connected components of G~{e1}. This can be performed in linear time, by [17]. Then, we have λ=λG(S{x1},s)>1, where x1 is the head of e1. And now, if λ3, we work similarly as in Lines 8 to 10. The only difference is that, if λ=2, then we apply again Proposition 11, instead of Proposition 22.

Algorithm 2 The procedure that establishes Proposition 23.

References

  • [1] Amir Abboud, Robert Krauthgamer, and Ohad Trabelsi. APMF < APSP? Gomory-Hu tree for unweighted graphs in almost-quadratic time, 2021. arXiv:2106.02981.
  • [2] Amir Abboud, Robert Krauthgamer, and Ohad Trabelsi. Subcubic algorithms for gomory–hu tree in unweighted graphs. In Proceedings of the 53rd Annual ACM SIGACT Symposium on Theory of Computing, STOC 2021, pages 1725–1737, New York, NY, USA, 2021. Association for Computing Machinery. doi:10.1145/3406325.3451073.
  • [3] Amir Abboud, Jason Li, Debmalya Panigrahi, and Thatchaphol Saranurak. All-pairs max-flow is no harder than single-pair max-flow: Gomory–Hu trees in almost-linear time. In 2023 IEEE 64th Annual Symposium on Foundations of Computer Science (FOCS), pages 2204–2212, 2023. doi:10.1109/FOCS57990.2023.00137.
  • [4] Shyan Akmal. An enumerative perspective on connectivity. In 2024 Symposium on Simplicity in Algorithms (SOSA), pages 179–198, 2024. doi:10.1137/1.9781611977936.18.
  • [5] Shyan Akmal and Ce Jin. An Efficient Algorithm for All-Pairs Bounded Edge Connectivity. In Kousha Etessami, Uriel Feige, and Gabriele Puppis, editors, 50th International Colloquium on Automata, Languages, and Programming (ICALP 2023), volume 261 of Leibniz International Proceedings in Informatics (LIPIcs), pages 11:1–11:20, Dagstuhl, Germany, 2023. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.ICALP.2023.11.
  • [6] Josh Alman, Ran Duan, Virginia Vassilevska Williams, Yinzhan Xu, Zixuan Xu, and Renfei Zhou. More asymmetry yields faster matrix multiplication. In Proceedings of the 2025 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 2005–2039, 2025. doi:10.1137/1.9781611978322.63.
  • [7] András A. Benczúr. Counterexamples for directed and node capacitated cut-trees. SIAM Journal on Computing, 24(3):505–510, 1995. doi:10.1137/S0097539792236730.
  • [8] Shiri Chechik, Thomas Dueholm Hansen, Giuseppe F Italiano, Veronika Loitzenbauer, and Nikos Parotsidis. Faster algorithms for computing maximal 2-connected subgraphs in sparse directed graphs. In Proceedings of the Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1900–1918. SIAM, 2017. doi:10.1137/1.9781611974782.124.
  • [9] Li Chen, Rasmus Kyng, Yang P. Liu, Richard Peng, Maximilian Probst Gutenberg, and Sushant Sachdeva. Maximum flow and minimum-cost flow in almost-linear time. In Proceedings of the 63rd IEEE Symposium on Foundations of Computer Science, FOCS ’22, 2022. doi:10.48550/arXiv.2203.00671.
  • [10] Ho Yee Cheung, Lap Chi Lau, and Kai Man Leung. Graph connectivities, network coding, and expander graphs. SIAM J. Comput., 42(3):733–751, January 2013. doi:10.1137/110844970.
  • [11] D. R. Ford and D. R. Fulkerson. Flows in Networks. Princeton University Press, USA, 2010.
  • [12] Sebastian Forster, Danupon Nanongkai, Liu Yang, Thatchaphol Saranurak, and Sorrachai Yingchareonthawornchai. Computing and testing small connectivity in near-linear time and queries via fast local cut algorithms. In Proceedings of the Fourteenth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 2046–2065. SIAM, 2020. doi:10.1137/1.9781611975994.126.
  • [13] H. N. Gabow. Path-based depth-first search for strong and biconnected components. Information Processing Letters, 74:107–114, 2000. doi:10.1016/S0020-0190(00)00051-X.
  • [14] Harold N. Gabow. The minset-poset approach to representations of graph connectivity. ACM Transactions on Algorithms, 12(2):24:1–24:73, February 2016. doi:10.1145/2764909.
  • [15] Z. Galil and G. F. Italiano. Reducing edge connectivity to vertex connectivity. SIGACT News, 22(1):57–61, March 1991. doi:10.1145/122413.122416.
  • [16] Loukas Georgiadis, Giuseppe F. Italiano, and Evangelos Kosinas. Computing the 4-edge-connected components of a graph in linear time. In Proc. 29th European Symposium on Algorithms, pages 47:1–47:17, 2021. doi:10.4230/LIPIcs.ESA.2021.47.
  • [17] Loukas Georgiadis, Giuseppe F. Italiano, and Evangelos Kosinas. Computing the 3-edge-connected components of directed graphs in linear time. In 65th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2024, Chicago, IL, USA, October 27-30, 2024, pages 62–85. IEEE, 2024. doi:10.1109/FOCS61266.2024.00015.
  • [18] Loukas Georgiadis, Giuseppe F. Italiano, Luigi Laura, and Nikos Parotsidis. 2-edge connectivity in directed graphs. ACM Trans. Algorithms, 13(1), October 2016. doi:10.1145/2968448.
  • [19] Loukas Georgiadis, Giuseppe F. Italiano, and Nikos Parotsidis. Strong connectivity in directed graphs under failures, with applications. SIAM J. Comput., 49(5):865–926, 2020. doi:10.1137/19M1258530.
  • [20] Loukas Georgiadis, Evangelos Kipouridis, Evangelos Kosinas, Charis Papadopoulos, and Nikos Parotsidis. Computing the (k+2)-edge-connected components in k-edge-connected digraphs in subquadratic time, 2026. arXiv:2604.27474.
  • [21] Loukas Georgiadis, Evangelos Kipouridis, Charis Papadopoulos, and Nikos Parotsidis. Faster computation of 3-edge-connected components in digraphs. In Proc. 2023 ACM-SIAM Symposium on Discrete Algorithms, SODA, pages 2489–2531. SIAM, 2023. doi:10.1137/1.9781611977554.CH96.
  • [22] Loukas Georgiadis and Robert E. Tarjan. Dominator tree certification and divergent spanning trees. ACM Transactions on Algorithms, 12(1):11:1–11:42, November 2015. doi:10.1145/2764913.
  • [23] Ramesh Hariharan, Telikepalli Kavitha, and Debmalya Panigrahi. Efficient algorithms for computing all low s-t edge connectivities and related problems. In Proceedings of the Eighteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA ’07, pages 127–136, USA, 2007. Society for Industrial and Applied Mathematics. URL: http://dl.acm.org/citation.cfm?id=1283383.1283398.
  • [24] M. Henzinger, S. Rao, and D. Wang. Local flow partitioning for faster edge connectivity. SIAM Journal on Computing, 49(1):1–36, 2020. doi:10.1137/18M1180335.
  • [25] J. E. Hopcroft and R. E. Tarjan. Dividing a graph into triconnected components. SIAM Journal on Computing, 2(3):135–158, 1973. doi:10.1137/0202012.
  • [26] Gary Hoppenworth, Thatchaphol Saranurak, and Benyu Wang. Near-optimal fault-tolerant strong connectivity preservers. In Proceedings of the 66th Annual Symposium on Foundations of Computer Science (FOCS 2025), 2025.
  • [27] Andreas Huck. Disproof of a conjecture about independent branchings in k-connected directed graphs. Journal of Graph Theory, 20(2):235–239, 1995. doi:10.1002/jgt.3190200212.
  • [28] K.-I. Kawarabayashi and M. Thorup. Deterministic edge connectivity in near-linear time. Journal of the ACM, 66(1), December 2018. doi:10.1145/3274663.
  • [29] Tuukka Korhonen. Linear-time algorithms for k-edge-connected components, k-lean tree decompositions, and more. In 57th ACM Symposium on Theory of Computing (STOC 2025), 2025.
  • [30] Evangelos Kosinas. Computing the 5-edge-connected components in linear time. In Proceedings of the Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1887–2119, 2024. doi:10.1137/1.9781611977912.76.
  • [31] Jason Li, Debmalya Panigrahi, and Thatchaphol Saranurak. A nearly optimal all-pairs min-cuts algorithm in simple graphs. In 2021 IEEE 62nd Annual Symposium on Foundations of Computer Science (FOCS), pages 1124–1134, 2022. doi:10.1109/FOCS52979.2021.00111.
  • [32] K. Menger. Zur allgemeinen kurventheorie. Fund. Math., 10:96–115, 1927.
  • [33] W. Nadara, M. Radecki, M. Smulewicz, and M. Sokolowski. Determining 4-edge-connected components in linear time. In Proc. 29th European Symposium on Algorithms, 2021.
  • [34] H. Nagamochi and T. Ibaraki. A linear time algorithm for computing 3-edge-connected components in a multigraph. Japan J. Indust. Appl. Math, 9(163), 1992. doi:10.1007/BF03167564.
  • [35] H. Nagamochi and T. Ibaraki. Algorithmic Aspects of Graph Connectivity. Cambridge University Press, 2008. 1st edition.
  • [36] H. Nagamochi and Toshimasa Watanabe. Computing k-edge-connected components of a multigraph (special section on discrete mathematics and its applications). IEICE Transactions on Fundamentals of Electronics, Communications and Computer Sciences, 76:513–517, 1993.
  • [37] Danupon Nanongkai, Thatchaphol Saranurak, and Sorrachai Yingchareonthawornchai. Breaking quadratic time for small vertex connectivity and an approximation scheme. In Proceedings of the 51st Annual ACM SIGACT Symposium on Theory of Computing, pages 241–252, 2019. doi:10.1145/3313276.3316394.
  • [38] Jean-Claude Picard and Maurice Queyranne. On the structure of all minimum cuts in a network and applications. Math. Program., 13(1):8–16, 1980.
  • [39] Claus-Peter Schnorr. Bottlenecks and edge connectivity in unsymmetrical networks. SIAM Journal on Computing, 8(2):265–274, 1979. doi:10.1137/0208019.
  • [40] R. E. Tarjan. Depth-first search and linear graph algorithms. SIAM Journal on Computing, 1(2):146–160, 1972. doi:10.1137/0201010.
  • [41] Y. H. Tsin. Yet another optimal algorithm for 3-edge-connectivity. Journal of Discrete Algorithms, 7(1):130–146, 2009. Selected papers from the 1st International Workshop on Similarity Search and Applications (SISAP). doi:10.1016/j.jda.2008.04.003.