55,326 research outputs found
Finding Simple Shortest Paths and Cycles
The problem of finding multiple simple shortest paths in a weighted directed
graph has many applications, and is considerably more difficult than
the corresponding problem when cycles are allowed in the paths. Even for a
single source-sink pair, it is known that two simple shortest paths cannot be
found in time polynomially smaller than (where ) unless the
All-Pairs Shortest Paths problem can be solved in a similar time bound. The
latter is a well-known open problem in algorithm design. We consider the
all-pairs version of the problem, and we give a new algorithm to find
simple shortest paths for all pairs of vertices. For , our algorithm runs
in time (where ), which is almost the same bound as
for the single pair case, and for we improve earlier bounds. Our approach
is based on forming suitable path extensions to find simple shortest paths;
this method is different from the `detour finding' technique used in most of
the prior work on simple shortest paths, replacement paths, and distance
sensitivity oracles.
Enumerating simple cycles is a well-studied classical problem. We present new
algorithms for generating simple cycles and simple paths in in
non-decreasing order of their weights; the algorithm for generating simple
paths is much faster, and uses another variant of path extensions. We also give
hardness results for sparse graphs, relative to the complexity of computing a
minimum weight cycle in a graph, for several variants of problems related to
finding simple paths and cycles.Comment: The current version includes new results for undirected graphs. In
Section 4, the notion of an (m,n) reduction is generalized to an f(m,n)
reductio
A Simple Framework for Finding Balanced Sparse Cuts via APSP
We present a very simple and intuitive algorithm to find balanced sparse cuts
in a graph via shortest-paths. Our algorithm combines a new
multiplicative-weights framework for solving unit-weight multi-commodity flows
with standard ball growing arguments. Using Dijkstra's algorithm for computing
the shortest paths afresh every time gives a very simple algorithm that runs in
time and finds an -sparse
balanced cut, when the given graph has a -sparse balanced cut. Combining
our algorithm with known deterministic data-structures for answering
approximate All Pairs Shortest Paths (APSP) queries under increasing edge
weights (decremental setting), we obtain a simple deterministic algorithm that
finds -sparse balanced cuts in time. Our
deterministic almost-linear time algorithm matches the state-of-the-art in
randomized and deterministic settings up to subpolynomial factors, while being
significantly simpler to understand and analyze, especially compared to the
only almost-linear time deterministic algorithm, a recent breakthrough by
Chuzhoy-Gao-Li-Nanongkai-Peng-Saranurak (FOCS 2020)
Distributed Approximation Algorithms for Weighted Shortest Paths
A distributed network is modeled by a graph having nodes (processors) and
diameter . We study the time complexity of approximating {\em weighted}
(undirected) shortest paths on distributed networks with a {\em
bandwidth restriction} on edges (the standard synchronous \congest model). The
question whether approximation algorithms help speed up the shortest paths
(more precisely distance computation) was raised since at least 2004 by Elkin
(SIGACT News 2004). The unweighted case of this problem is well-understood
while its weighted counterpart is fundamental problem in the area of
distributed approximation algorithms and remains widely open. We present new
algorithms for computing both single-source shortest paths (\sssp) and
all-pairs shortest paths (\apsp) in the weighted case.
Our main result is an algorithm for \sssp. Previous results are the classic
-time Bellman-Ford algorithm and an -time
-approximation algorithm, for any integer
, which follows from the result of Lenzen and Patt-Shamir (STOC 2013).
(Note that Lenzen and Patt-Shamir in fact solve a harder problem, and we use
to hide the O(\poly\log n) term.) We present an -time -approximation algorithm for \sssp. This
algorithm is {\em sublinear-time} as long as is sublinear, thus yielding a
sublinear-time algorithm with almost optimal solution. When is small, our
running time matches the lower bound of by Das Sarma
et al. (SICOMP 2012), which holds even when , up to a
\poly\log n factor.Comment: Full version of STOC 201
Analytical results for the distribution of shortest path lengths in random networks
We present two complementary analytical approaches for calculating the
distribution of shortest path lengths in Erdos-R\'enyi networks, based on
recursion equations for the shells around a reference node and for the paths
originating from it. The results are in agreement with numerical simulations
for a broad range of network sizes and connectivities. The average and standard
deviation of the distribution are also obtained. In the case that the mean
degree scales as with the network size, the distribution becomes
extremely narrow in the asymptotic limit, namely almost all pairs of nodes are
equidistant, at distance from each other. The
distribution of shortest path lengths between nodes of degree and the rest
of the network is calculated. Its average is shown to be a monotonically
decreasing function of , providing an interesting relation between a local
property and a global property of the network. The methodology presented here
can be applied to more general classes of networks.Comment: 12 pages, 4 figures, accepted to EP
Distributed Exact Shortest Paths in Sublinear Time
The distributed single-source shortest paths problem is one of the most
fundamental and central problems in the message-passing distributed computing.
Classical Bellman-Ford algorithm solves it in time, where is the
number of vertices in the input graph . Peleg and Rubinovich (FOCS'99)
showed a lower bound of for this problem, where
is the hop-diameter of .
Whether or not this problem can be solved in time when is
relatively small is a major notorious open question. Despite intensive research
\cite{LP13,N14,HKN15,EN16,BKKL16} that yielded near-optimal algorithms for the
approximate variant of this problem, no progress was reported for the original
problem.
In this paper we answer this question in the affirmative. We devise an
algorithm that requires time, for , and time, for larger . This
running time is sublinear in in almost the entire range of parameters,
specifically, for . For the all-pairs shortest paths
problem, our algorithm requires time, regardless of
the value of .
We also devise the first algorithm with non-trivial complexity guarantees for
computing exact shortest paths in the multipass semi-streaming model of
computation.
From the technical viewpoint, our algorithm computes a hopset of a
skeleton graph of without first computing itself. We then conduct
a Bellman-Ford exploration in , while computing the required edges
of on the fly. As a result, our algorithm computes exactly those edges of
that it really needs, rather than computing approximately the entire
- …