Practical Minimum Cut Algorithms

The minimum cut problem for an undirected edge-weighted graph asks us to divide its set of nodes into two blocks while minimizing the weight sum of the cut edges. Here, we introduce a linear-time algorithm to compute near-minimum cuts. Our algorithm is based on cluster contraction using label propagation and Padberg and Rinaldi's contraction heuristics [SIAM Review, 1991]. We give both sequential and shared-memory parallel implementations of our algorithm. Extensive experiments on both real-world and generated instances show that our algorithm finds the optimal cut on nearly all instances significantly faster than other state-of-the-art algorithms while our error rate is lower than that of other heuristic algorithms. In addition, our parallel algorithm shows good scalability

Optimal Bounds for the kk-cut Problem

In the $k$-cut problem, we want to find the smallest set of edges whose deletion breaks a given (multi)graph into $k$ connected components. Algorithms of Karger & Stein and Thorup showed how to find such a minimum $k$-cut in time approximately $O(n^{2k})$. The best lower bounds come from conjectures about the solvability of the $k$-clique problem, and show that solving $k$-cut is likely to require time $\Omega(n^k)$. Recent results of Gupta, Lee & Li have given special-purpose algorithms that solve the problem in time $n^{1.98k + O(1)}$, and ones that have better performance for special classes of graphs (e.g., for small integer weights). In this work, we resolve the problem for general graphs, by showing that the Contraction Algorithm of Karger outputs any fixed $k$-cut of weight $\alpha \lambda_k$ with probability $\Omega_k(n^{-\alpha k})$, where $\lambda_k$ denotes the minimum $k$-cut size. This also gives an extremal bound of $O_k(n^k)$ on the number of minimum $k$-cuts and an algorithm to compute a minimum $k$-cut in similar runtime. Both are tight up to lower-order factors, with the algorithmic lower bound assuming hardness of max-weight $k$-clique. The first main ingredient in our result is a fine-grained analysis of how the graph shrinks -- and how the average degree evolves -- in the Karger process. The second ingredient is an extremal bound on the number of cuts of size less than $2 \lambda_k/k$, using the Sunflower lemma.Comment: Final version of arXiv:1911.09165 with new and more general proof

A computational study of a geometric embedding of minimum multiway cut

Thesis (M. Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2006.Includes bibliographical references (p. 77-78).In the minimum multiway cut problem, the goal is to find a minimum cost set of edges whose removal disconnects a certain set of k distinguished vertices in a graph. The problem is MAX-SNP hard for k >/= 3. Clinescu, Karloff, and Rabani gave a geometric relaxation of the problem and a rounding scheme, to produce an approximation algorithm that has a performance guarantee of 3/2 - 1/k. In a subsequent study, Karger, Klein, Stein, Thorup, and Young discovered improved rounding schemes via computation experiments for various values of k, yielding approximation algorithms with improved performance guarantees. Their rounding scheme for k = 3 is provably optimal (i.e., its performance guarantee is equal to the integrality gap of the relaxation), but their rounding schemes for k > 3 seemed unlikely to be optimal. In the present work, we improve these rounding schemes for small values of k > 3, yielding improved approximation algorithms. These improvements were discovered by applying an improved analysis to the same set of computational experiments used by Karger et al.(cont.) We also present computer-aided proofs of improved lower bounds on the integrality gap for various values of k > 3. For the k = 4 case, for instance, our work demonstrates a lower and upper bound of 1.1052 and 1.1494, respectively, improving upon the previously best known bounds of 1.0909 and 1.1539. Finally, we present additional computational experiments that may shed some light on the nature of the optimal rounding scheme for the k = 4 case.by David Shin.M.Eng

Fast and Deterministic Approximations for k-Cut

In an undirected graph, a k-cut is a set of edges whose removal breaks the graph into at least k connected components. The minimum weight k-cut can be computed in n^O(k) time, but when k is treated as part of the input, computing the minimum weight k-cut is NP-Hard [Goldschmidt and Hochbaum, 1994]. For poly(m,n,k)-time algorithms, the best possible approximation factor is essentially 2 under the small set expansion hypothesis [Manurangsi, 2017]. Saran and Vazirani [1995] showed that a (2 - 2/k)-approximately minimum weight k-cut can be computed via O(k) minimum cuts, which implies a O~(km) randomized running time via the nearly linear time randomized min-cut algorithm of Karger [2000]. Nagamochi and Kamidoi [2007] showed that a (2 - 2/k)-approximately minimum weight k-cut can be computed deterministically in O(mn + n^2 log n) time. These results prompt two basic questions. The first concerns the role of randomization. Is there a deterministic algorithm for 2-approximate k-cuts matching the randomized running time of O~(km)? The second question qualitatively compares minimum cut to 2-approximate minimum k-cut. Can 2-approximate k-cuts be computed as fast as the minimum cut - in O~(m) randomized time? We give a deterministic approximation algorithm that computes (2 + eps)-minimum k-cuts in O(m log^3 n / eps^2) time, via a (1 + eps)-approximation for an LP relaxation of k-cut

Distributed Minimum Cut Approximation

We study the problem of computing approximate minimum edge cuts by distributed algorithms. We use a standard synchronous message passing model where in each round, $O(\log n)$ bits can be transmitted over each edge (a.k.a. the CONGEST model). We present a distributed algorithm that, for any weighted graph and any $\epsilon \in (0, 1)$, with high probability finds a cut of size at most $O(\epsilon^{-1}\lambda)$ in $O(D) + \tilde{O}(n^{1/2 + \epsilon})$ rounds, where $\lambda$ is the size of the minimum cut. This algorithm is based on a simple approach for analyzing random edge sampling, which we call the random layering technique. In addition, we also present another distributed algorithm, which is based on a centralized algorithm due to Matula [SODA '93], that with high probability computes a cut of size at most $(2+\epsilon)\lambda$ in $\tilde{O}((D+\sqrt{n})/\epsilon^5)$ rounds for any $\epsilon>0$. The time complexities of both of these algorithms almost match the $\tilde{\Omega}(D + \sqrt{n})$ lower bound of Das Sarma et al. [STOC '11], thus leading to an answer to an open question raised by Elkin [SIGACT-News '04] and Das Sarma et al. [STOC '11]. Furthermore, we also strengthen the lower bound of Das Sarma et al. by extending it to unweighted graphs. We show that the same lower bound also holds for unweighted multigraphs (or equivalently for weighted graphs in which $O(w\log n)$ bits can be transmitted in each round over an edge of weight $w$), even if the diameter is $D=O(\log n)$. For unweighted simple graphs, we show that even for networks of diameter $\tilde{O}(\frac{1}{\lambda}\cdot \sqrt{\frac{n}{\alpha\lambda}})$, finding an $\alpha$-approximate minimum cut in networks of edge connectivity $\lambda$ or computing an $\alpha$-approximation of the edge connectivity requires $\tilde{\Omega}(D + \sqrt{\frac{n}{\alpha\lambda}})$ rounds

Minimum Cuts in Near-Linear Time

We significantly improve known time bounds for solving the minimum cut problem on undirected graphs. We use a ``semi-duality'' between minimum cuts and maximum spanning tree packings combined with our previously developed random sampling techniques. We give a randomized algorithm that finds a minimum cut in an m-edge, n-vertex graph with high probability in O(m log^3 n) time. We also give a simpler randomized algorithm that finds all minimum cuts with high probability in O(n^2 log n) time. This variant has an optimal RNC parallelization. Both variants improve on the previous best time bound of O(n^2 log^3 n). Other applications of the tree-packing approach are new, nearly tight bounds on the number of near minimum cuts a graph may have and a new data structure for representing them in a space-efficient manner