Finding the KT partition of a weighted graph in near-linear time

In this work we give the first near-linear time randomized algorithm to find the $(1+\varepsilon)$-KT partition of a weighted graph, for $0\leq\varepsilon\leq 1/16$. An interesting aspect of our algorithm is that it uses Karger’s 2-respecting cut framework to find the $(1+\varepsilon)$-KT partition, thereby combining the aforementioned major lines of work on the minimum cut problem. This makes progress on a number of problems.

1. 1.

   The polygon representation is a compact representation of the set of near-minimum cuts of a weighted graph, originally described by Benczúr [Ben95, Ben97] and Benczúr-Goemans [BG08]. It extends the cactus representation [DKL76], which only works for the set of exact minimum cuts, and has played a key role in recent breakthroughs on the traveling salesperson problem [GSS11, KKG21]. For a general weighted graph the polygon representation has size $O(n^{2})$, and Benczúr has given a randomized algorithm to construct a polygon representation of the $(1+\varepsilon)$-near mincuts of a graph in time $\mathcal{O}(n^{2(1+\varepsilon)})$ [Ben97, Section 6.3] by building on the Karger-Stein algorithm. It is an open question whether we can construct a polygon representation in time $\widetilde{\mathcal{O}}(n^{2})$ for $\varepsilon>0$. In his thesis [Ben97, pg. 126], Benczúr says, “It already seems hard to directly identify the system of atoms within the $\widetilde{\mathcal{O}}(n^{2})$ time bound,” where the system of atoms is defined analogously to the $(1+\varepsilon)$-KT partition but for the set of all $(1+\varepsilon)$-near minimum cuts, not just the non-trivial ones. One can easily construct the set of atoms from a $(1+\varepsilon)$-KT partition, thus our KT partition algorithm gives a $\widetilde{\mathcal{O}}(m)$ time algorithm for this task as well, making progress on this open question.

2. 2.

   The $(1+\varepsilon)$-KT partition of a weighted graph is exactly what is needed to give an optimal quantum algorithm for minimum cut: Apers and Lee [AL21] showed that the quantum query and time complexity of minimum cut in the adjacency matrix model is $\widetilde{\Theta}(n^{3/2}\sqrt{\tau})$ for a weighted graph where the ratio of the largest to smallest edge weights is $\tau$, with the algorithm proceeding by finding a $(1+\varepsilon)$-KT partition.

   In the case where the graph is instead represented as an adjacency list, they gave an algorithm with query complexity $\widetilde{\mathcal{O}}(\sqrt{mn\tau})$ but whose running time is larger at $\widetilde{\mathcal{O}}(\sqrt{mn\tau}+n^{3/2})$. The bottleneck in the time complexity is the time taken to find a $(1+\varepsilon)$-KT partition of a weighted graph with $\widetilde{\mathcal{O}}(n)$ edges. Using the near-linear time randomized algorithm we give to find a $(1+\varepsilon)$-KT partition here improves the time complexity of this algorithm to $\widetilde{\mathcal{O}}(\sqrt{mn\tau})$, matching the query complexity. We detail the full algorithm in Section 6.1.

   Both quantum algorithms also used the following observation [AL21, Lemma 2]: if in a weighted graph $G$ the ratio of the largest edge weight to the smallest is $\tau$, then the total weight of inter-component edges in a $(1+\varepsilon)$-KT partition of $G$ for $\varepsilon<1$ is $\mathcal{O}(\tau n)$, which can be tight.

3. 3.

   The best randomized algorithm to compute the edge connectivity of a simple graph is the 2-out contraction approach of Ghaffari, Nowicki, and Thorup [GNT20], which has running time $\mathcal{O}(\min\{m+n\log^{2}n,m\log n\})$. Using our algorithm to find a $(1+\varepsilon)$-KT partition in a weighted graph we can follow Karger’s 2-respecting tree approach to compute the edge connectivity of a simple graph in time $\mathcal{O}(m+n\log^{6}n)$, thus also achieving the optimal bound on graphs that are not too sparse. We postpone details to Section 6.2.

Apart from these examples, we are hopeful that our near-optimal randomized algorithm for finding the KT partition of a weighted graph will find further applications.

In order to find a $(1+\varepsilon)$-KT partition in near-linear time, Apers and Lee [AL21] show that it suffices to solve the following problem in near-linear time. Let $G$ be a connected weighted graph and $T$ a spanning tree of $G$. Consider a graph $H$ whose nodes are the edges of $T$, and where two nodes $e,f$ of $H$ are connected by an edge iff the 2-respecting cut defined by $e,f$ is a non-trivial $(1+\varepsilon)$-near minimum cut of $G$. Then the problem is to find a spanning forest of $H$. Our main technical contribution is to give a $\mathcal{O}(m\log^{4}n)$ time deterministic algorithm to solve this problem, where $m$ is the number of edges of the original graph $G$.

It is interesting to compare the problem of finding a spanning forest of $H$ with the original problem solved by Karger of finding a minimum-weight 2-respecting cut of $T$. To find a spanning forest of $H$ we potentially have to find $\Omega(n)$ many $(1+\varepsilon)$-near minimum cuts, which we accomplish with only an additional logarithmic overhead in the running time. The first insight to how this might be possible is to note that Karger’s original algorithm to find the minimum weight 2-respecting cut actually does something stronger than needed. Let $\mathrm{cost}(e,f)$ be the weight of the 2-respecting cut of $T$ defined by $\{e,f\}$. For every edge $e$ of $T$ Karger’s algorithm attempts to find an $f^{*}\in\operatorname*{arg\,min}_{f}\mathrm{cost}(e,f)$. It does not always succeed in this task, but if the candidate $f^{\prime}$ returned for edge $e$ is not such a minimizer, then for $f^{*}\in\operatorname*{arg\,min}_{f}\mathrm{cost}(e,f)$ it must be the case that the candidate $g$ returned for $f^{*}$ satisfies $\mathrm{cost}(f^{*},g)\leq\mathrm{cost}(e,f^{*})$. In this way, the algorithm still succeeds to find a minimum weight 2-respecting cut in the end.

In contrast, we give an algorithm that for every edge $e$ of $T$ actually finds

We then show that this suffices to implement a round of Borůvka’s spanning forest algorithm [NMN01] on $H$ in near-linear time. Borůvka’s spanning forest algorithm consists of $\log n$ rounds and maintains the invariant of having a partition $\{S_{1},\ldots,S_{k}\}$ of the vertex set and a spanning tree for each set $S_{i}$. The algorithm terminates when there is no outgoing edge from any set of the partition, at which point the collection of spanning trees for the sets of the partition is a spanning forest of $H$. The sets of the partition are initialized to be individual nodes of $H$.

In each round of Borůvka’s algorithm the goal is to find an outgoing edge from each set $S_{i}$ of the partition which has one. Consider a node $e$ of $H$ with $e\in S_{i}$. We can find the best partner $f$ for $e$ and check if $\{e,f\}$ indeed gives rise to a non-trivial $(1+\varepsilon)$-near minimum cut and so is an edge of $H$. The problem is that $f$ could also be in $S_{i}$ in which case the edge $\{e,f\}$ is not an outgoing edge of $S_{i}$ as desired. To handle this, we maintain a data structure that allows us to find both the best partner $f$ for $e$, but also the best partner $f^{\prime}$ for $e$ that lies in a different set of the partition from $f$. We call this operation a categorical top two query. If there actually is an edge of $H$ with one endpoint $e$ and the other endpoint outside of $S_{i}$ then either $\{e,f\}$ or $\{e,f^{\prime}\}$ will be such an edge. Following the approach of [GMW20] to the minimum-weight 2-respecting cut problem, combined with an efficient data structure for handling categorical top two queries, we are able to do this for all nodes $e$ of $H$ in near-linear time, which allows us to implement a round of Borůvka’s algorithm in near-linear time.

We now give a more detailed description of our main result. Let $G=(V,E,w)$ be a weighted graph, where $E$ is the set of edges and $w:E\rightarrow\mathbb{R}_{+}$ assigns a positive weight to each edge. For a set $S\subseteq V$ let $\Delta_{G}(S)$ be the set of all edges of $G$ with exactly one endpoint in $S$. A cut of $G$ is a set of edges of the form $\Delta_{G}(S)$ for some $\emptyset\neq S\subsetneq V$. We call $S$ and $\bar{S}$ the shores of the cut. Let $w(\Delta_{G}(S))=\sum_{e\in\Delta(S)}w(e)$. We use $\lambda(G)=\min_{\emptyset\neq S\subsetneq V}w(\Delta(S))$ for the minimum weight of a cut in $G$.

We will be interested in partitions of $V$ and the partial order on partitions induced by refinement. For two partitions $\mathcal{X},\mathcal{Y}$ of $V$ we say that $\mathcal{X}\preceq\mathcal{Y}$ iff for every $X\in\mathcal{X}$ there is a $Y\in\mathcal{Y}$ with $X\subseteq Y$. In this case we say $\mathcal{X}$ is a refinement of $\mathcal{Y}$. The meet of two partitions $\mathcal{X}$ and $\mathcal{Y}$, denoted $\mathcal{X}\wedge\mathcal{Y}$, is the partition $\mathcal{Z}$ such that $\mathcal{Z}\preceq\mathcal{X},\mathcal{Z}\preceq\mathcal{Y}$ and for any other partition $\mathcal{W}$ satisfying these two conditions $\mathcal{W}\preceq\mathcal{Z}$. In other words, $\mathcal{X}\wedge\mathcal{Y}$ is the greatest lower bound on $\mathcal{X}$ and $\mathcal{Y}$ under $\preceq$. For a set of partitions $\mathcal{D}=\{\mathcal{D}_{1},\ldots,\mathcal{D}_{K}\}$ we write $\bigwedge\mathcal{D}=\mathcal{D}_{1}\wedge\cdots\wedge\mathcal{D}_{K}$.

For our applications we need to consider not only minimum cuts, but also near-minimum cuts. For $\varepsilon\geq 0$, let $\mathcal{B}_{\varepsilon}(G)=\{\{S,\bar{S}\}:w(\Delta_{G}(S))\leq(1+\varepsilon)\lambda(G)\}$ be the set of all bipartitions of $V$ corresponding to $(1+\varepsilon)$-near minimum cuts. Let $\mathcal{B}_{\varepsilon}^{nt}(G)\subseteq\mathcal{B}_{\varepsilon}(G)$ be the set of all the non-trivial cuts in $\mathcal{B}_{\varepsilon}(G)$. The $(1+\varepsilon)$-KT partition of $G$ is exactly $\bigwedge\mathcal{B}_{\varepsilon}^{nt}(G)$.

Both $\bigwedge\mathcal{B}_{\varepsilon}(G)$ and $\bigwedge\mathcal{B}_{\varepsilon}^{nt}(G)$ are important sets for understanding the structure of (near)-minimum cuts in a graph. Consider first $\bigwedge\mathcal{B}_{0}(G)$, the meet of the set of all bipartitions corresponding to minimum cuts. This set arises in the cactus decomposition of $G$ [DKL76], a compact representation of all minimum cuts of $G$. A cactus is a connected multigraph where every edge appears in exactly one cycle. The edge connectivity of a cactus is 2 and the minimum cuts are obtained by removing any two edges from the same cycle. A cactus decomposition of a graph $G$ is a cactus $H$ on $\mathcal{O}(n)$ vertices and a mapping $\phi:V(G)\rightarrow V(H)$ such that $\Delta_{G}(\phi^{-1}(S))$ is a mincut of $G$ iff $\Delta_{H}(S)$ is a mincut of $H$. The mapping $\phi$ does not have to be injective, so multiple vertices of $G$ can map to the same vertex of $H$. In this case, however, the cactus decomposition property means that all vertices in $\phi^{-1}(\{v\})$ must be on the same side of every minimum cut of $G$, for every $v\in V(H)$. Thus as $v$ ranges over $V(H)$ the sets $\phi^{-1}(\{v\})$ give the elements of $\bigwedge\mathcal{B}_{0}(G)$ (note that $\phi^{-1}(\{v\})$ can also be empty). A cactus decomposition of a weighted graph can be constructed by a randomized algorithm in near-linear time [KP09], thus this also gives a near-linear time randomized algorithm to compute $\bigwedge\mathcal{B}_{0}(G)$.

Lo, Schmidt, and Thorup [LST20] give a version of the cactus decomposition that only represents the non-trivial minimum cuts. In fact, they give a deterministic $\mathcal{O}(n)$ time algorithm that converts a standard cactus into one representing the non-trivial minimum cuts. Combining this with the near-linear time algorithm to compute a cactus decomposition, this gives a near-linear time randomized algorithm to compute $\bigwedge\mathcal{B}_{0}^{nt}(G)$ as well.

The situation changes once we go to near-minimum cuts, which can no longer be represented by a cactus, but require the deformable polygon representation from [Ben95, Ben97, BG08]. This construction is fairly intricate, and the best known randomized algorithm to construct a deformable polygon representation of the $(1+\varepsilon)$-near mincuts of a graph builds on the Karger-Stein algorithm and takes time $\mathcal{O}(n^{2(1+\varepsilon)})$ [Ben97, Section 6.3]. A prerequisite to constructing a deformable polygon representation is being able to compute $\bigwedge\mathcal{B}_{\varepsilon}(G)$ as, analogously to the case of a cactus, these sets will be the “atoms” that label regions of the polygons.

Our main result in this work is to give a randomized algorithm to compute $\bigwedge\mathcal{B}_{\varepsilon}(G)$ and $\bigwedge\mathcal{B}_{\varepsilon}^{nt}(G)$ in time $\mathcal{O}(m\log^{5}n)$.

In the rest of this introduction we focus on computing $\bigwedge\mathcal{B}_{\varepsilon}^{nt}$. It is easy to construct $\bigwedge\mathcal{B}_{\varepsilon}$ from $\bigwedge\mathcal{B}_{\varepsilon}^{nt}$ deterministically in $\mathcal{O}(n)$ time.

The first obstacle we face in designing a near-linear time algorithm to compute the meet of $\mathcal{B}_{\varepsilon}^{nt}$ is that the number of near-minimum cuts in $G$ can be $\Omega(n^{2})$, so we cannot afford to consider all of them. An idea to get around this is to try the following:

1. 1.

   Efficiently find a “small” subset $\mathcal{B}^{\prime}\subseteq\mathcal{B}_{\varepsilon}^{nt}$ such that $\bigwedge\mathcal{B}^{\prime}=\bigwedge\mathcal{B}_{\varepsilon}^{nt}$. We call such a subset a generating set.

A greedy argument shows that such a subset $\mathcal{B}^{\prime}$ exists of size at most $n-1$. We initialize $\mathcal{B}^{\prime}=\{\{S,\bar{S}\}\}$ for some element $\{S,\bar{S}\}$ in $\mathcal{B}_{\varepsilon}^{nt}$. We then iterate through the elements $\{T,\bar{T}\}$ of $\mathcal{B}_{\varepsilon}^{nt}$ and add it to $\mathcal{B}^{\prime}$ iff $\bigwedge\mathcal{B}^{\prime}\cup\{T,\bar{T}\}\neq\bigwedge\mathcal{B}^{\prime}$. Each bipartition added to $\mathcal{B}^{\prime}$ increases the number of elements in $\bigwedge\mathcal{B}^{\prime}$ by at least $1$. As this size can be at most $n$, and begins with size $2$ the total number of sets at termination is at most $n-1$. This shows that a small generating set exists, but there still remains the problem of finding such a generating set efficiently.

Assuming we get past the first obstacle, there remains a second obstacle. The most straightforward algorithm to compute the meet of $k$ partitions of a set of size $n$ takes time $\Theta(kn\log n)$, which is again too slow if $k=\Theta(n)$. Thus we will also need to

1. 2.

   Exploit the structure of $\mathcal{B}^{\prime}$ to compute $\bigwedge\mathcal{B}^{\prime}$ efficiently.

Apers and Lee [AL21] give an approach to accomplish (1) and (2) following Karger’s framework of tree respecting cuts. Karger shows that in near-linear time one can compute a set of $K\in\mathcal{O}(\log n)$ spanning trees $T_{1},\ldots,T_{K}$ of $G$ such that every $(1+\varepsilon)$-near minimum cut of $G$ 2-respects at least one of these trees. Let $\mathcal{B}_{i}\subseteq\mathcal{B}_{\varepsilon}^{nt}$ be the bipartitions corresponding to non-trivial near-minimum cuts that 2-respect $T_{i}$. To compute $\bigwedge\mathcal{B}_{\varepsilon}^{nt}$ it suffices to compute $\mathcal{C}_{i}=\bigwedge\mathcal{B}_{i}$ for each $i=1,\ldots,K$ and then compute $\bigwedge_{i=1}^{K}\mathcal{C}_{i}$. The latter can be done in time $\mathcal{O}(n\log^{2}n)$ by the aforementioned algorithm. This leaves the problem of computing $\bigwedge\mathcal{B}_{i}$.

A key observation from [AL21] gives a generating set $\mathcal{B}_{i}^{\prime}$ for $\mathcal{B}_{i}$ of size $\mathcal{O}(n)$. One intializes $\mathcal{B}_{i}^{\prime}$ to be empty and then adds bipartitions in $\mathcal{B}_{i}$ that 1-respect $T_{i}$ to $\mathcal{B}_{i}^{\prime}$. This is a set of size $\mathcal{O}(n)$, and Karger has shown that all near-minimum cuts that 1-respect a tree can be found in time $\mathcal{O}(m)$.

Now we focus on the cuts that strictly 2-respect $T_{i}$. To handle these one creates a graph $H$ whose nodes are the edges of $T_{i}$ and where there is an edge between nodes $e$ and $f$ iff the 2-respecting cut of $T_{i}$ defined by $\{e,f\}$ is a near-minimum cut in $\mathcal{B}_{i}$. One then adds to $\mathcal{B}_{i}^{\prime}$ the bipartitions corresponding to a set of 2-respecting cuts that form a spanning forest of $H$. The resulting set $\mathcal{B}_{i}^{\prime}$ has size $\mathcal{O}(n)$ and it can be shown to be a generating set for $\mathcal{B}_{i}$.

Apers and Lee give a quantum algorithm to find a spanning forest of $H$ with running time $\widetilde{\mathcal{O}}(n^{3/2})$. They then give a randomized algorithm to compute $\bigwedge\mathcal{B}_{i}^{\prime}$ in time $\widetilde{\mathcal{O}}(n)$. As our main technical contribution, we give a deterministic algorithm to find a spanning forest of $H$ in time $\mathcal{O}(m\log^{4}n)$. We also replace the randomization used in the algorithm to compute $\bigwedge\mathcal{B}_{i}^{\prime}$ with an appropriate data structure to give an $\widetilde{\mathcal{O}}(n)$ deterministic algorithm to compute the meet.

We follow the approach from [GMW20] originally designed to find a single pair $\{e,f\}$ of descendant edges that minimizes $\mathrm{cost}(e,f)$ over all $e,f\in E(T)$ in $\mathcal{O}(m\log n)$ time. Their approach actually does something stronger (as does Karger’s original algorithm): for every $e\in E(T)$ it finds the best match in the subtree $T_{e}$, i.e., it returns an edge $f^{*}\in\operatorname*{arg\,min}\{\mathrm{cost}(e,f)\mid f\in T_{e}\}$. In order to implement the descendant edge part of $\mathsf{RoundEdges}$ we have three additional complications to handle:

1. 1.

   The edge $f^{*}$ might have the same color as $e$.

2. 2.

   The resulting $\mathrm{cut}(e,f^{*})$ might be a trivial cut.

3. 3.

   Edge $e$ may have no partner in $T_{e}$ but still have a partner $f$ such that $e\in T_{f}$. This partnership may not be discovered when we are looking for partners of $f$ if there is another $g\in T_{f}$ with $\mathrm{cost}(f,g)\leq\mathrm{cost}(e,f)$.

Item 1 can be easily solved by, in addition to finding $f^{*}$, also finding $g^{*}\in\operatorname*{arg\,min}\{\mathrm{cost}(e,f)\mid f\in E(T_{e}),\,\mathrm{color}(f)\neq\mathrm{color}(f^{*})\}$. Phrasing things in this way, rather than simply looking for the edge $h$ with color different from $e$ which minimizes $\mathrm{cost}(e,h)$, helps to limit the dependence of the query on $e$ and thus reduce the query time. If there is an $f\in T_{e}$ with $\mathrm{color}(f)\neq\mathrm{color}(e)$ and $\mathrm{cost}(e,f)\leq\beta$ then at least one of $f^{*},g^{*}$ will satisfy this too.

For item 2, we use the result of Proposition 8 that descendant edges that give rise to trivial cuts have a very constrained structure. This allow us to avoid trivial cuts when looking for a partner of $e$.

Item 3 is relatively subtle and does not arise in the minimum weight 2-respecting cut problem. To explain the issue we have to first say something about the high level structure of our implementation of $\mathsf{RoundEdges}$. We will perform an Euler tour of $T$ and, when the tour visits edge $e$ for the first time, we will look for a partner $f$ for $e$ in $T_{e}$. The issue is the following, which we explain in the context of the very first round of Borůvka’s algorithm so we do not have to worry about nodes having different colors. Suppose that in the graph $H$ the only edge incident to node $e$ is a node $f$ with $e\in T_{f}$. Thus in the execution of $\mathsf{RoundEdges}$ we want to find $f$ as a partner of $e$. When the Euler tour is at $e$ we will not find any suitable partner for $e$, as there is none in $T_{e}$. We would like to identify $f$ as a partner for $e$ when the Euler tour visits $f$ for the first time. However, if there is a $g\in T_{f}$ with $\mathrm{cost}(f,g)<\mathrm{cost}(f,e)$ then the algorithm will return $g$ as a partner of $f$ rather than $e$. To handle this we will actually make two passes over $T$. In the first pass, when we visit edge $e$ for the first time we look for a partner $f$ in $T_{e}$. In the second pass, we handle the case where the partner of $e$ might be an ancestor of $e$. To do this we need to de-activate nodes. When the Euler tour visits $f$ for the first time, we first find the lowest cost partner for $f$ in $T_{f}$. We then de-activate this node, and again find the best active partner for $f$ in $T_{f}$. Repeating this process, we will eventually find $e$ if $\{e,f\}$ is indeed an edge of $H$ and $e,f$ have different colors.

Now we turn to more specific implementation details. A key idea in [GMW20] is that we can do an Euler tour of $T$ while maintaining a data structure such that when we first visit an edge $e$ we can easily look up $\mathrm{cost}(e,f)$ for any $f\in T_{e}$. The way this is maintained can be best understood by noting that for $f\in T_{e}$:

where for convenience we defined $\mathrm{score}_{e}(f)=\mathrm{cost}(f)-2w(f^{\downarrow},(e^{\downarrow})^{c})$, where the superscript $c$ denotes taking the complement.

We begin the algorithm by computing $\mathrm{cost}(e)$ for every $e\in E(T)$, which can be done in $\mathcal{O}(m)$ time by Lemma 3. We then do an Euler of $T$ while maintaining a data structure from Lemma 7 such that, when we are considering $e\in E(T)$, for every $f\in T_{e}$ the value of the data structure at location $f$ is $\mathrm{cost}(e,f)$. For $f\not\in T_{e}$ this will not in general be the case.

As can be seen from Section 4.1, the key to maintaining this data structure is how to update the values $w(f^{\downarrow},(e^{\downarrow})^{c})$ when we descend edge $e$. Consider the case where we are currently at edge $e^{\prime}=(z,x)$ and move to a descending edge $e=(x,y)$. For two vertices $u,v$ let $p(u,v)$ be the set of edges on the path from $u$ to $v$ in $T$, and let $\mathrm{lca}(u,v)$ be their least common ancestor in $T$. For $f\in T_{e}$ we see that

By its definition in (4.1) we can compute $\mathrm{score}_{e}(f)$ from $\mathrm{score}_{e^{\prime}}(f)$ by subtracting $2w(\{u,v\})$ from for every $\{u,v\}\in E$ such that $f\in p(u,v)$ and $\mathrm{lca}(u,v)=x$. The for-loop on line 2 of Algorithm 2 implements this step for all $f$ by looping over all $\{u,v\}\in E$ with $\mathrm{lca}(u,v)=x$. After this update we have that $\mathrm{cost}(e,f)=\mathrm{cost}(e)+\mathrm{score}(f)$ for every $f\in T_{e}$. This shows how to descend down $T$ while keeping the invariant. The full tree is then explored by taking an Euler tour through $T$, and whenever we go back up in the tree we revert the score updates (for-loop on line 10 of Algorithm 3). This allows us to find candidate $f\in T_{e}$ for every $e\in E(T)$. To bound the number of updates, note that each of the $m$ edges has a unique lca, and we only do an update corresponding to an edge when the lca is visited by the Euler tour. Since the Euler tour visits every vertex at most twice, the number of updates is at most $2m$. In addition, the number of categorical top two queries is $n-1$. The data structure from Lemma 7 then yields $\mathcal{O}(m\log^{2}n)$ time overall.