13,697 research outputs found
A Constant Approximation for Colorful k-Center
In this paper, we consider the colorful k-center problem, which is a generalization of the well-known k-center problem. Here, we are given red and blue points in a metric space, and a coverage requirement for each color. The goal is to find the smallest radius rho, such that with k balls of radius rho, the desired number of points of each color can be covered. We obtain a constant approximation for this problem in the Euclidean plane. We obtain this result by combining a "pseudo-approximation" algorithm that works in any metric space, and an approximation algorithm that works for a special class of instances in the plane. The latter algorithm uses a novel connection to a certain matching problem in graphs
On the Complexity of Local Distributed Graph Problems
This paper is centered on the complexity of graph problems in the
well-studied LOCAL model of distributed computing, introduced by Linial [FOCS
'87]. It is widely known that for many of the classic distributed graph
problems (including maximal independent set (MIS) and -vertex
coloring), the randomized complexity is at most polylogarithmic in the size
of the network, while the best deterministic complexity is typically
. Understanding and narrowing down this exponential gap
is considered to be one of the central long-standing open questions in the area
of distributed graph algorithms. We investigate the problem by introducing a
complexity-theoretic framework that allows us to shed some light on the role of
randomness in the LOCAL model. We define the SLOCAL model as a sequential
version of the LOCAL model. Our framework allows us to prove completeness
results with respect to the class of problems which can be solved efficiently
in the SLOCAL model, implying that if any of the complete problems can be
solved deterministically in rounds in the LOCAL model, we can
deterministically solve all efficient SLOCAL-problems (including MIS and
-coloring) in rounds in the LOCAL model. We show
that a rather rudimentary looking graph coloring problem is complete in the
above sense: Color the nodes of a graph with colors red and blue such that each
node of sufficiently large polylogarithmic degree has at least one neighbor of
each color. The problem admits a trivial zero-round randomized solution. The
result can be viewed as showing that the only obstacle to getting efficient
determinstic algorithms in the LOCAL model is an efficient algorithm to
approximately round fractional values into integer values
Bi-Criteria and Approximation Algorithms for Restricted Matchings
In this work we study approximation algorithms for the \textit{Bounded Color
Matching} problem (a.k.a. Restricted Matching problem) which is defined as
follows: given a graph in which each edge has a color and a profit
, we want to compute a maximum (cardinality or profit)
matching in which no more than edges of color are
present. This kind of problems, beside the theoretical interest on its own
right, emerges in multi-fiber optical networking systems, where we interpret
each unique wavelength that can travel through the fiber as a color class and
we would like to establish communication between pairs of systems. We study
approximation and bi-criteria algorithms for this problem which are based on
linear programming techniques and, in particular, on polyhedral
characterizations of the natural linear formulation of the problem. In our
setting, we allow violations of the bounds and we model our problem as a
bi-criteria problem: we have two objectives to optimize namely (a) to maximize
the profit (maximum matching) while (b) minimizing the violation of the color
bounds. We prove how we can "beat" the integrality gap of the natural linear
programming formulation of the problem by allowing only a slight violation of
the color bounds. In particular, our main result is \textit{constant}
approximation bounds for both criteria of the corresponding bi-criteria
optimization problem
On Derandomizing Local Distributed Algorithms
The gap between the known randomized and deterministic local distributed
algorithms underlies arguably the most fundamental and central open question in
distributed graph algorithms. In this paper, we develop a generic and clean
recipe for derandomizing LOCAL algorithms. We also exhibit how this simple
recipe leads to significant improvements on a number of problem. Two main
results are:
- An improved distributed hypergraph maximal matching algorithm, improving on
Fischer, Ghaffari, and Kuhn [FOCS'17], and giving improved algorithms for
edge-coloring, maximum matching approximation, and low out-degree edge
orientation. The first gives an improved algorithm for Open Problem 11.4 of the
book of Barenboim and Elkin, and the last gives the first positive resolution
of their Open Problem 11.10.
- An improved distributed algorithm for the Lov\'{a}sz Local Lemma, which
gets closer to a conjecture of Chang and Pettie [FOCS'17], and moreover leads
to improved distributed algorithms for problems such as defective coloring and
-SAT.Comment: 37 page
Round Compression for Parallel Matching Algorithms
For over a decade now we have been witnessing the success of {\em massive
parallel computation} (MPC) frameworks, such as MapReduce, Hadoop, Dryad, or
Spark. One of the reasons for their success is the fact that these frameworks
are able to accurately capture the nature of large-scale computation. In
particular, compared to the classic distributed algorithms or PRAM models,
these frameworks allow for much more local computation. The fundamental
question that arises in this context is though: can we leverage this additional
power to obtain even faster parallel algorithms?
A prominent example here is the {\em maximum matching} problem---one of the
most classic graph problems. It is well known that in the PRAM model one can
compute a 2-approximate maximum matching in rounds. However, the
exact complexity of this problem in the MPC framework is still far from
understood. Lattanzi et al. showed that if each machine has
memory, this problem can also be solved -approximately in a constant number
of rounds. These techniques, as well as the approaches developed in the follow
up work, seem though to get stuck in a fundamental way at roughly
rounds once we enter the near-linear memory regime. It is thus entirely
possible that in this regime, which captures in particular the case of sparse
graph computations, the best MPC round complexity matches what one can already
get in the PRAM model, without the need to take advantage of the extra local
computation power.
In this paper, we finally refute that perplexing possibility. That is, we
break the above round complexity bound even in the case of {\em
slightly sublinear} memory per machine. In fact, our improvement here is {\em
almost exponential}: we are able to deliver a -approximation to
maximum matching, for any fixed constant , in
rounds
Degree-3 Treewidth Sparsifiers
We study treewidth sparsifiers. Informally, given a graph of treewidth
, a treewidth sparsifier is a minor of , whose treewidth is close to
, is small, and the maximum vertex degree in is bounded.
Treewidth sparsifiers of degree are of particular interest, as routing on
node-disjoint paths, and computing minors seems easier in sub-cubic graphs than
in general graphs.
In this paper we describe an algorithm that, given a graph of treewidth
, computes a topological minor of such that (i) the treewidth of
is ; (ii) ; and (iii) the maximum
vertex degree in is . The running time of the algorithm is polynomial in
and . Our result is in contrast to the known fact that unless , treewidth does not admit polynomial-size kernels.
One of our key technical tools, which is of independent interest, is a
construction of a small minor that preserves node-disjoint routability between
two pairs of vertex subsets. This is closely related to the open question of
computing small good-quality vertex-cut sparsifiers that are also minors of the
original graph.Comment: Extended abstract to appear in Proceedings of ACM-SIAM SODA 201
A Breezing Proof of the KMW Bound
In their seminal paper from 2004, Kuhn, Moscibroda, and Wattenhofer (KMW)
proved a hardness result for several fundamental graph problems in the LOCAL
model: For any (randomized) algorithm, there are input graphs with nodes
and maximum degree on which (expected) communication rounds are
required to obtain polylogarithmic approximations to a minimum vertex cover,
minimum dominating set, or maximum matching. Via reduction, this hardness
extends to symmetry breaking tasks like finding maximal independent sets or
maximal matchings. Today, more than years later, there is still no proof
of this result that is easy on the reader. Setting out to change this, in this
work, we provide a fully self-contained and proof of the KMW
lower bound. The key argument is algorithmic, and it relies on an invariant
that can be readily verified from the generation rules of the lower bound
graphs.Comment: 21 pages, 6 figure
- …