170 research outputs found

### Faster Clustering via Preprocessing

We examine the efficiency of clustering a set of points, when the
encompassing metric space may be preprocessed in advance. In computational
problems of this genre, there is a first stage of preprocessing, whose input is
a collection of points $M$; the next stage receives as input a query set
$Q\subset M$, and should report a clustering of $Q$ according to some
objective, such as 1-median, in which case the answer is a point $a\in M$
minimizing $\sum_{q\in Q} d_M(a,q)$.
We design fast algorithms that approximately solve such problems under
standard clustering objectives like $p$-center and $p$-median, when the metric
$M$ has low doubling dimension. By leveraging the preprocessing stage, our
algorithms achieve query time that is near-linear in the query size $n=|Q|$,
and is (almost) independent of the total number of points $m=|M|$.Comment: 24 page

### Sketching Cuts in Graphs and Hypergraphs

Sketching and streaming algorithms are in the forefront of current research
directions for cut problems in graphs. In the streaming model, we show that
$(1-\epsilon)$-approximation for Max-Cut must use $n^{1-O(\epsilon)}$ space;
moreover, beating $4/5$-approximation requires polynomial space. For the
sketching model, we show that $r$-uniform hypergraphs admit a
$(1+\epsilon)$-cut-sparsifier (i.e., a weighted subhypergraph that
approximately preserves all the cuts) with $O(\epsilon^{-2} n (r+\log n))$
edges. We also make first steps towards sketching general CSPs (Constraint
Satisfaction Problems)

### Fault-Tolerant Spanners: Better and Simpler

A natural requirement of many distributed structures is fault-tolerance:
after some failures, whatever remains from the structure should still be
effective for whatever remains from the network. In this paper we examine
spanners of general graphs that are tolerant to vertex failures, and
significantly improve their dependence on the number of faults $r$, for all
stretch bounds.
For stretch $k \geq 3$ we design a simple transformation that converts every
$k$-spanner construction with at most $f(n)$ edges into an $r$-fault-tolerant
$k$-spanner construction with at most $O(r^3 \log n) \cdot f(2n/r)$ edges.
Applying this to standard greedy spanner constructions gives $r$-fault tolerant
$k$-spanners with $\tilde O(r^{2} n^{1+\frac{2}{k+1}})$ edges. The previous
construction by Chechik, Langberg, Peleg, and Roddity [STOC 2009] depends
similarly on $n$ but exponentially on $r$ (approximately like $k^r$).
For the case $k=2$ and unit-length edges, an $O(r \log n)$-approximation
algorithm is known from recent work of Dinitz and Krauthgamer [arXiv 2010],
where several spanner results are obtained using a common approach of rounding
a natural flow-based linear programming relaxation. Here we use a different
(stronger) LP relaxation and improve the approximation ratio to $O(\log n)$,
which is, notably, independent of the number of faults $r$. We further
strengthen this bound in terms of the maximum degree by using the \Lovasz Local
Lemma.
Finally, we show that most of our constructions are inherently local by
designing equivalent distributed algorithms in the LOCAL model of distributed
computation.Comment: 17 page

### Almost-Smooth Histograms and Sliding-Window Graph Algorithms

We study algorithms for the sliding-window model, an important variant of the
data-stream model, in which the goal is to compute some function of a
fixed-length suffix of the stream. We extend the smooth-histogram framework of
Braverman and Ostrovsky (FOCS 2007) to almost-smooth functions, which includes
all subadditive functions. Specifically, we show that if a subadditive function
can be $(1+\epsilon)$-approximated in the insertion-only streaming model, then
it can be $(2+\epsilon)$-approximated also in the sliding-window model with
space complexity larger by factor $O(\epsilon^{-1}\log w)$, where $w$ is the
window size.
We demonstrate how our framework yields new approximation algorithms with
relatively little effort for a variety of problems that do not admit the
smooth-histogram technique. For example, in the frequency-vector model, a
symmetric norm is subadditive and thus we obtain a sliding-window
$(2+\epsilon)$-approximation algorithm for it. Another example is for streaming
matrices, where we derive a new sliding-window
$(\sqrt{2}+\epsilon)$-approximation algorithm for Schatten $4$-norm. We then
consider graph streams and show that many graph problems are subadditive,
including maximum submodular matching, minimum vertex-cover, and maximum
$k$-cover, thereby deriving sliding-window $O(1)$-approximation algorithms for
them almost for free (using known insertion-only algorithms). Finally, we
design for every $d\in (1,2]$ an artificial function, based on the
maximum-matching size, whose almost-smoothness parameter is exactly $d$

### Tight Bounds for Gomory-Hu-like Cut Counting

By a classical result of Gomory and Hu (1961), in every edge-weighted graph
$G=(V,E,w)$, the minimum $st$-cut values, when ranging over all $s,t\in V$,
take at most $|V|-1$ distinct values. That is, these $\binom{|V|}{2}$ instances
exhibit redundancy factor $\Omega(|V|)$. They further showed how to construct
from $G$ a tree $(V,E',w')$ that stores all minimum $st$-cut values. Motivated
by this result, we obtain tight bounds for the redundancy factor of several
generalizations of the minimum $st$-cut problem.
1. Group-Cut: Consider the minimum $(A,B)$-cut, ranging over all subsets
$A,B\subseteq V$ of given sizes $|A|=\alpha$ and $|B|=\beta$. The redundancy
factor is $\Omega_{\alpha,\beta}(|V|)$.
2. Multiway-Cut: Consider the minimum cut separating every two vertices of
$S\subseteq V$, ranging over all subsets of a given size $|S|=k$. The
redundancy factor is $\Omega_{k}(|V|)$.
3. Multicut: Consider the minimum cut separating every demand-pair in
$D\subseteq V\times V$, ranging over collections of $|D|=k$ demand pairs. The
redundancy factor is $\Omega_{k}(|V|^k)$. This result is a bit surprising, as
the redundancy factor is much larger than in the first two problems.
A natural application of these bounds is to construct small data structures
that stores all relevant cut values, like the Gomory-Hu tree. We initiate this
direction by giving some upper and lower bounds.Comment: This version contains additional references to previous work (which
have some overlap with our results), see Bibliographic Update 1.

- β¦