3,989 research outputs found
Near-Optimal Approximate Shortest Paths and Transshipment in Distributed and Streaming Models
We present a method for solving the transshipment problem - also known as
uncapacitated minimum cost flow - up to a multiplicative error of in undirected graphs with non-negative edge weights using a
tailored gradient descent algorithm. Using to hide
polylogarithmic factors in (the number of nodes in the graph), our gradient
descent algorithm takes iterations, and in each
iteration it solves an instance of the transshipment problem up to a
multiplicative error of . In particular, this allows
us to perform a single iteration by computing a solution on a sparse spanner of
logarithmic stretch. Using a randomized rounding scheme, we can further extend
the method to finding approximate solutions for the single-source shortest
paths (SSSP) problem. As a consequence, we improve upon prior work by obtaining
the following results: (1) Broadcast CONGEST model: -approximate SSSP using rounds, where is the (hop) diameter of the network.
(2) Broadcast congested clique model: -approximate
transshipment and SSSP using rounds. (3)
Multipass streaming model: -approximate transshipment and
SSSP using space and passes. The
previously fastest SSSP algorithms for these models leverage sparse hop sets.
We bypass the hop set construction; computing a spanner is sufficient with our
method. The above bounds assume non-negative edge weights that are polynomially
bounded in ; for general non-negative weights, running times scale with the
logarithm of the maximum ratio between non-zero weights.Comment: Accepted to SIAM Journal on Computing. Preliminary version in DISC
2017. Abstract shortened to fit arXiv's limitation to 1920 character
Replacement Paths via Row Minima of Concise Matrices
Matrix is {\em -concise} if the finite entries of each column of
consist of or less intervals of identical numbers. We give an -time
algorithm to compute the row minima of any -concise matrix.
Our algorithm yields the first -time reductions from the
replacement-paths problem on an -node -edge undirected graph
(respectively, directed acyclic graph) to the single-source shortest-paths
problem on an -node -edge undirected graph (respectively, directed
acyclic graph). That is, we prove that the replacement-paths problem is no
harder than the single-source shortest-paths problem on undirected graphs and
directed acyclic graphs. Moreover, our linear-time reductions lead to the first
-time algorithms for the replacement-paths problem on the following
classes of -node -edge graphs (1) undirected graphs in the word-RAM model
of computation, (2) undirected planar graphs, (3) undirected minor-closed
graphs, and (4) directed acyclic graphs.Comment: 23 pages, 1 table, 9 figures, accepted to SIAM Journal on Discrete
Mathematic
A Faster Distributed Single-Source Shortest Paths Algorithm
We devise new algorithms for the single-source shortest paths (SSSP) problem
with non-negative edge weights in the CONGEST model of distributed computing.
While close-to-optimal solutions, in terms of the number of rounds spent by the
algorithm, have recently been developed for computing SSSP approximately, the
fastest known exact algorithms are still far away from matching the lower bound
of rounds by Peleg and Rubinovich [SIAM
Journal on Computing 2000], where is the number of nodes in the network
and is its diameter. The state of the art is Elkin's randomized algorithm
[STOC 2017] that performs rounds. We
significantly improve upon this upper bound with our two new randomized
algorithms for polynomially bounded integer edge weights, the first performing
rounds and the second performing rounds. Our bounds also compare favorably to the
independent result by Ghaffari and Li [STOC 2018]. As side results, we obtain a
-approximation -round algorithm for directed SSSP and a new work/depth trade-off for exact
SSSP on directed graphs in the PRAM model.Comment: Presented at the the 59th Annual IEEE Symposium on Foundations of
Computer Science (FOCS 2018
A simpler and more efficient algorithm for the next-to-shortest path problem
Given an undirected graph with positive edge lengths and two
vertices and , the next-to-shortest path problem is to find an -path
which length is minimum amongst all -paths strictly longer than the
shortest path length. In this paper we show that the problem can be solved in
linear time if the distances from and to all other vertices are given.
Particularly our new algorithm runs in time for general
graphs, which improves the previous result of time for sparse
graphs, and takes only linear time for unweighted graphs, planar graphs, and
graphs with positive integer edge lengths.Comment: Partial result appeared in COCOA201
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
Decremental Single-Source Shortest Paths on Undirected Graphs in Near-Linear Total Update Time
In the decremental single-source shortest paths (SSSP) problem we want to
maintain the distances between a given source node and every other node in
an -node -edge graph undergoing edge deletions. While its static
counterpart can be solved in near-linear time, this decremental problem is much
more challenging even in the undirected unweighted case. In this case, the
classic total update time of Even and Shiloach [JACM 1981] has been the
fastest known algorithm for three decades. At the cost of a
-approximation factor, the running time was recently improved to
by Bernstein and Roditty [SODA 2011]. In this paper, we bring the
running time down to near-linear: We give a -approximation
algorithm with expected total update time, thus obtaining
near-linear time. Moreover, we obtain time for the weighted
case, where the edge weights are integers from to . The only prior work
on weighted graphs in time is the -time algorithm by
Henzinger et al. [STOC 2014, ICALP 2015] which works for directed graphs with
quasi-polynomial edge weights. The expected running time bound of our algorithm
holds against an oblivious adversary.
In contrast to the previous results which rely on maintaining a sparse
emulator, our algorithm relies on maintaining a so-called sparse -hop set introduced by Cohen [JACM 2000] in the PRAM literature. An
-hop set of a graph is a set of weighted edges
such that the distance between any pair of nodes in can be
-approximated by their -hop distance (given by a path
containing at most edges) on . Our algorithm can maintain
an -hop set of near-linear size in near-linear time under
edge deletions.Comment: Accepted to Journal of the ACM. A preliminary version of this paper
was presented at the 55th IEEE Symposium on Foundations of Computer Science
(FOCS 2014). Abstract shortened to respect the arXiv limit of 1920 character
Shortest Distances as Enumeration Problem
We investigate the single source shortest distance (SSSD) and all pairs
shortest distance (APSD) problems as enumeration problems (on unweighted and
integer weighted graphs), meaning that the elements -- where
and are vertices with shortest distance -- are produced and
listed one by one without repetition. The performance is measured in the RAM
model of computation with respect to preprocessing time and delay, i.e., the
maximum time that elapses between two consecutive outputs. This point of view
reveals that specific types of output (e.g., excluding the non-reachable pairs
, or excluding the self-distances ) and the order of
enumeration (e.g., sorted by distance, sorted row-wise with respect to the
distance matrix) have a huge impact on the complexity of APSD while they appear
to have no effect on SSSD.
In particular, we show for APSD that enumeration without output restrictions
is possible with delay in the order of the average degree. Excluding
non-reachable pairs, or requesting the output to be sorted by distance,
increases this delay to the order of the maximum degree. Further, for weighted
graphs, a delay in the order of the average degree is also not possible without
preprocessing or considering self-distances as output. In contrast, for SSSD we
find that a delay in the order of the maximum degree without preprocessing is
attainable and unavoidable for any of these requirements.Comment: Updated version adds the study of space complexit
- …