135 research outputs found
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
All-Pairs Minimum Cuts in Near-Linear Time for Surface-Embedded Graphs
For an undirected -vertex graph with non-negative edge-weights, we
consider the following type of query: given two vertices and in ,
what is the weight of a minimum -cut in ? We solve this problem in
preprocessing time for graphs of bounded genus, giving the first
sub-quadratic time algorithm for this class of graphs. Our result also improves
by a logarithmic factor a previous algorithm by Borradaile, Sankowski and
Wulff-Nilsen (FOCS 2010) that applied only to planar graphs. Our algorithm
constructs a Gomory-Hu tree for the given graph, providing a data structure
with space that can answer minimum-cut queries in constant time. The
dependence on the genus of the input graph in our preprocessing time is
A Simple Algorithm for Minimum Cuts in Near-Linear Time
We consider the minimum cut problem in undirected, weighted graphs. We give a
simple algorithm to find a minimum cut that -respects (cuts two edges of) a
spanning tree of a graph . This procedure can be used in place of the
complicated subroutine given in Karger's near-linear time minimum cut algorithm
(J. ACM, 2000). We give a self-contained version of Karger's algorithm with the
new procedure, which is easy to state and relatively simple to implement. It
produces a minimum cut on an -edge, -vertex graph in time
with high probability, matching the complexity of Karger's approach.Comment: To appear in SWAT 202
Brief Announcement: Almost-Tight Approximation Distributed Algorithm for Minimum Cut
In this short paper, we present an improved algorithm for approximating the
minimum cut on distributed (CONGEST) networks. Let be the minimum
cut. Our algorithm can compute exactly in
\tilde{O}((\sqrt{n}+D)\poly(\lambda)) time, where is the number of nodes
(processors) in the network, is the network diameter, and hides
\poly\log n. By a standard reduction, we can convert this algorithm into a
-approximation \tilde{O}((\sqrt{n}+D)/\poly(\epsilon))-time
algorithm. The latter result improves over the previous
-approximation \tilde{O}((\sqrt{n}+D)/\poly(\epsilon))-time
algorithm of Ghaffari and Kuhn [DISC 2013]. Due to the lower bound of
by Das Sarma et al. [SICOMP 2013], this running
time is {\em tight} up to a \poly\log n factor. Our algorithm is an extremely
simple combination of Thorup's tree packing theorem [Combinatorica 2007],
Kutten and Peleg's tree partitioning algorithm [J. Algorithms 1998], and
Karger's dynamic programming [JACM 2000].Comment: To appear as a brief announcement at PODC 201
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, 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 , with high probability finds a cut of size
at most in
rounds, where 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
in rounds for any .
The time complexities of both of these algorithms almost match the
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
bits can be transmitted in each round over an edge of weight ),
even if the diameter is . For unweighted simple graphs, we show
that even for networks of diameter , finding an -approximate minimum cut
in networks of edge connectivity or computing an
-approximation of the edge connectivity requires rounds
Weighted Min-Cut: Sequential, Cut-Query and Streaming Algorithms
Consider the following 2-respecting min-cut problem. Given a weighted graph
and its spanning tree , find the minimum cut among the cuts that contain
at most two edges in . This problem is an important subroutine in Karger's
celebrated randomized near-linear-time min-cut algorithm [STOC'96]. We present
a new approach for this problem which can be easily implemented in many
settings, leading to the following randomized min-cut algorithms for weighted
graphs.
* An -time sequential algorithm:
This improves Karger's and bounds when the input graph is not extremely
sparse or dense. Improvements over Karger's bounds were previously known only
under a rather strong assumption that the input graph is simple [Henzinger et
al. SODA'17; Ghaffari et al. SODA'20]. For unweighted graphs with parallel
edges, our bound can be improved to .
* An algorithm requiring cut queries to compute the min-cut of
a weighted graph: This answers an open problem by Rubinstein et al. ITCS'18,
who obtained a similar bound for simple graphs.
* A streaming algorithm that requires space and
passes to compute the min-cut: The only previous non-trivial exact min-cut
algorithm in this setting is the 2-pass -space algorithm on simple
graphs [Rubinstein et al., ITCS'18] (observed by Assadi et al. STOC'19).
In contrast to Karger's 2-respecting min-cut algorithm which deploys
sophisticated dynamic programming techniques, our approach exploits some cute
structural properties so that it only needs to compute the values of cuts corresponding to removing pairs of tree edges, an
operation that can be done quickly in many settings.Comment: Updates on this version: (1) Minor corrections in Section 5.1, 5.2;
(2) Reference to newer results by GMW SOSA21 (arXiv:2008.02060v2), DEMN
STOC21 (arXiv:2004.09129v2) and LMN 21 (arXiv:2102.06565v1
On the Analysis of a Label Propagation Algorithm for Community Detection
This paper initiates formal analysis of a simple, distributed algorithm for
community detection on networks. We analyze an algorithm that we call
\textsc{Max-LPA}, both in terms of its convergence time and in terms of the
"quality" of the communities detected. \textsc{Max-LPA} is an instance of a
class of community detection algorithms called \textit{label propagation}
algorithms. As far as we know, most analysis of label propagation algorithms
thus far has been empirical in nature and in this paper we seek a theoretical
understanding of label propagation algorithms. In our main result, we define a
clustered version of \er random graphs with clusters where
the probability , of an edge connecting nodes within a cluster is
higher than , the probability of an edge connecting nodes in distinct
clusters. We show that even with fairly general restrictions on and
( for any , , where is the number of nodes), \textsc{Max-LPA} detects the
clusters in just two rounds. Based on this and on empirical
results, we conjecture that \textsc{Max-LPA} can correctly and quickly identify
communities on clustered \er graphs even when the clusters are much sparser,
i.e., with for some .Comment: 17 pages. Submitted to ICDCN 201
Almost-Tight Distributed Minimum Cut Algorithms
We study the problem of computing the minimum cut in a weighted distributed
message-passing networks (the CONGEST model). Let be the minimum cut,
be the number of nodes in the network, and be the network diameter. Our
algorithm can compute exactly in time. To the best of our knowledge, this is the first paper that
explicitly studies computing the exact minimum cut in the distributed setting.
Previously, non-trivial sublinear time algorithms for this problem are known
only for unweighted graphs when due to Pritchard and
Thurimella's -time and -time algorithms for
computing -edge-connected and -edge-connected components.
By using the edge sampling technique of Karger's, we can convert this
algorithm into a -approximation -time algorithm for any . This improves
over the previous -approximation -time algorithm and
-approximation -time algorithm of Ghaffari and Kuhn. Due to the lower
bound of by Das Sarma et al. which holds for any
approximation algorithm, this running time is tight up to a factor.
To get the stated running time, we developed an approximation algorithm which
combines the ideas of Thorup's algorithm and Matula's contraction algorithm. It
saves an factor as compared to applying Thorup's tree
packing theorem directly. Then, we combine Kutten and Peleg's tree partitioning
algorithm and Karger's dynamic programming to achieve an efficient distributed
algorithm that finds the minimum cut when we are given a spanning tree that
crosses the minimum cut exactly once
- …