4,455 research outputs found
Massively Parallel Approximate Distance Sketches
Data structures that allow efficient distance estimation (distance oracles, distance sketches, etc.) have been extensively studied, and are particularly well studied in centralized models and classical distributed models such as CONGEST. We initiate their study in newer (and arguably more realistic) models of distributed computation: the Congested Clique model and the Massively Parallel Computation (MPC) model. We provide efficient constructions in both of these models, but our core results are for MPC. In MPC we give two main results: an algorithm that constructs stretch/space optimal distance sketches but takes a (small) polynomial number of rounds, and an algorithm that constructs distance sketches with worse stretch but that only takes polylogarithmic rounds.
Along the way, we show that other useful combinatorial structures can also be computed in MPC. In particular, one key component we use to construct distance sketches are an MPC construction of the hopsets of [Elkin and Neiman, 2016]. This result has additional applications such as the first polylogarithmic time algorithm for constant approximate single-source shortest paths for weighted graphs in the low memory MPC setting
Linear-Space Approximate Distance Oracles for Planar, Bounded-Genus, and Minor-Free Graphs
A (1 + eps)-approximate distance oracle for a graph is a data structure that
supports approximate point-to-point shortest-path-distance queries. The most
relevant measures for a distance-oracle construction are: space, query time,
and preprocessing time. There are strong distance-oracle constructions known
for planar graphs (Thorup, JACM'04) and, subsequently, minor-excluded graphs
(Abraham and Gavoille, PODC'06). However, these require Omega(eps^{-1} n lg n)
space for n-node graphs. We argue that a very low space requirement is
essential. Since modern computer architectures involve hierarchical memory
(caches, primary memory, secondary memory), a high memory requirement in effect
may greatly increase the actual running time. Moreover, we would like data
structures that can be deployed on small mobile devices, such as handhelds,
which have relatively small primary memory. In this paper, for planar graphs,
bounded-genus graphs, and minor-excluded graphs we give distance-oracle
constructions that require only O(n) space. The big O hides only a fixed
constant, independent of \epsilon and independent of genus or size of an
excluded minor. The preprocessing times for our distance oracle are also faster
than those for the previously known constructions. For planar graphs, the
preprocessing time is O(n lg^2 n). However, our constructions have slower query
times. For planar graphs, the query time is O(eps^{-2} lg^2 n). For our
linear-space results, we can in fact ensure, for any delta > 0, that the space
required is only 1 + delta times the space required just to represent the graph
itself
Efficient Construction of Probabilistic Tree Embeddings
In this paper we describe an algorithm that embeds a graph metric
on an undirected weighted graph into a distribution of tree metrics
such that for every pair , and
. Such embeddings have
proved highly useful in designing fast approximation algorithms, as many hard
problems on graphs are easy to solve on tree instances. For a graph with
vertices and edges, our algorithm runs in time with high
probability, which improves the previous upper bound of shown by
Mendel et al.\,in 2009.
The key component of our algorithm is a new approximate single-source
shortest-path algorithm, which implements the priority queue with a new data
structure, the "bucket-tree structure". The algorithm has three properties: it
only requires linear time in the number of edges in the input graph; the
computed distances have a distance preserving property; and when computing the
shortest-paths to the -nearest vertices from the source, it only requires to
visit these vertices and their edge lists. These properties are essential to
guarantee the correctness and the stated time bound.
Using this shortest-path algorithm, we show how to generate an intermediate
structure, the approximate dominance sequences of the input graph, in time, and further propose a simple yet efficient algorithm to converted
this sequence to a tree embedding in time, both with high
probability. Combining the three subroutines gives the stated time bound of the
algorithm.
Then we show that this efficient construction can facilitate some
applications. We proved that FRT trees (the generated tree embedding) are
Ramsey partitions with asymptotically tight bound, so the construction of a
series of distance oracles can be accelerated
Brief Announcement: Massively Parallel Approximate Distance Sketches
Data structures that allow efficient distance estimation have been extensively studied both in centralized models and classical distributed models. We initiate their study in newer (and arguably more realistic) models of distributed computation: the Congested Clique model and the Massively Parallel Computation (MPC) model. In MPC we give two main results: an algorithm that constructs stretch/space optimal distance sketches but takes a (small) polynomial number of rounds, and an algorithm that constructs distance sketches with worse stretch but that only takes polylogarithmic rounds. Along the way, we show that other useful combinatorial structures can also be computed in MPC. In particular, one key component we use is an MPC construction of the hopsets of Elkin and Neiman (2016). This result has additional applications such as the first polylogarithmic time algorithm for constant approximate single-source shortest paths for weighted graphs in the low memory MPC setting
Constructing Light Spanners Deterministically in Near-Linear Time
Graph spanners are well-studied and widely used both in theory and practice. In a recent breakthrough, Chechik and Wulff-Nilsen [Shiri Chechik and Christian Wulff-Nilsen, 2018] improved the state-of-the-art for light spanners by constructing a (2k-1)(1+epsilon)-spanner with O(n^(1+1/k)) edges and O_epsilon(n^(1/k)) lightness. Soon after, Filtser and Solomon [Arnold Filtser and Shay Solomon, 2016] showed that the classic greedy spanner construction achieves the same bounds. The major drawback of the greedy spanner is its running time of O(mn^(1+1/k)) (which is faster than [Shiri Chechik and Christian Wulff-Nilsen, 2018]). This makes the construction impractical even for graphs of moderate size. Much faster spanner constructions do exist but they only achieve lightness Omega_epsilon(kn^(1/k)), even when randomization is used.
The contribution of this paper is deterministic spanner constructions that are fast, and achieve similar bounds as the state-of-the-art slower constructions. Our first result is an O_epsilon(n^(2+1/k+epsilon\u27)) time spanner construction which achieves the state-of-the-art bounds. Our second result is an O_epsilon(m + n log n) time construction of a spanner with (2k-1)(1+epsilon) stretch, O(log k * n^(1+1/k) edges and O_epsilon(log k * n^(1/k)) lightness. This is an exponential improvement in the dependence on k compared to the previous result with such running time. Finally, for the important special case where k=log n, for every constant epsilon>0, we provide an O(m+n^(1+epsilon)) time construction that produces an O(log n)-spanner with O(n) edges and O(1) lightness which is asymptotically optimal. This is the first known sub-quadratic construction of such a spanner for any k = omega(1).
To achieve our constructions, we show a novel deterministic incremental approximate distance oracle. Our new oracle is crucial in our construction, as known randomized dynamic oracles require the assumption of a non-adaptive adversary. This is a strong assumption, which has seen recent attention in prolific venues. Our new oracle allows the order of the edge insertions to not be fixed in advance, which is critical as our spanner algorithm chooses which edges to insert based on the answers to distance queries. We believe our new oracle is of independent interest
Prioritized Metric Structures and Embedding
Metric data structures (distance oracles, distance labeling schemes, routing
schemes) and low-distortion embeddings provide a powerful algorithmic
methodology, which has been successfully applied for approximation algorithms
\cite{llr}, online algorithms \cite{BBMN11}, distributed algorithms
\cite{KKMPT12} and for computing sparsifiers \cite{ST04}. However, this
methodology appears to have a limitation: the worst-case performance inherently
depends on the cardinality of the metric, and one could not specify in advance
which vertices/points should enjoy a better service (i.e., stretch/distortion,
label size/dimension) than that given by the worst-case guarantee.
In this paper we alleviate this limitation by devising a suit of {\em
prioritized} metric data structures and embeddings. We show that given a
priority ranking of the graph vertices (respectively,
metric points) one can devise a metric data structure (respectively, embedding)
in which the stretch (resp., distortion) incurred by any pair containing a
vertex will depend on the rank of the vertex. We also show that other
important parameters, such as the label size and (in some sense) the dimension,
may depend only on . In some of our metric data structures (resp.,
embeddings) we achieve both prioritized stretch (resp., distortion) and label
size (resp., dimension) {\em simultaneously}. The worst-case performance of our
metric data structures and embeddings is typically asymptotically no worse than
of their non-prioritized counterparts.Comment: To appear at STOC 201
A Linear-Size Logarithmic Stretch Path-Reporting Distance Oracle for General Graphs
In 2001 Thorup and Zwick devised a distance oracle, which given an -vertex
undirected graph and a parameter , has size . Upon a query
their oracle constructs a -approximate path between
and . The query time of the Thorup-Zwick's oracle is , and it was
subsequently improved to by Chechik. A major drawback of the oracle of
Thorup and Zwick is that its space is . Mendel and Naor
devised an oracle with space and stretch , but their
oracle can only report distance estimates and not actual paths. In this paper
we devise a path-reporting distance oracle with size , stretch
and query time , for an arbitrarily small .
In particular, our oracle can provide logarithmic stretch using linear size.
Another variant of our oracle has size , polylogarithmic
stretch, and query time .
For unweighted graphs we devise a distance oracle with multiplicative stretch
, additive stretch , for a function , space
, and query time , for an arbitrarily
small constant . The tradeoff between multiplicative stretch and
size in these oracles is far below girth conjecture threshold (which is stretch
and size ). Breaking the girth conjecture tradeoff is
achieved by exhibiting a tradeoff of different nature between additive stretch
and size . A similar type of tradeoff was exhibited by
a construction of -spanners due to Elkin and Peleg.
However, so far -spanners had no counterpart in the
distance oracles' world.
An important novel tool that we develop on the way to these results is a
{distance-preserving path-reporting oracle}
- …