12,625 research outputs found

    A Randomized Algorithm for Single-Source Shortest Path on Undirected Real-Weighted Graphs

    Full text link
    In undirected graphs with real non-negative weights, we give a new randomized algorithm for the single-source shortest path (SSSP) problem with running time O(mlognloglogn)O(m\sqrt{\log n \cdot \log\log n}) in the comparison-addition model. This is the first algorithm to break the O(m+nlogn)O(m+n\log n) time bound for real-weighted sparse graphs by Dijkstra's algorithm with Fibonacci heaps. Previous undirected non-negative SSSP algorithms give time bound of O(mα(m,n)+min{nlogn,nloglogr})O(m\alpha(m,n)+\min\{n\log n, n\log\log r\}) in comparison-addition model, where α\alpha is the inverse-Ackermann function and rr is the ratio of the maximum-to-minimum edge weight [Pettie & Ramachandran 2005], and linear time for integer edge weights in RAM model [Thorup 1999]. Note that there is a proposed complexity lower bound of Ω(m+min{nlogn,nloglogr})\Omega(m+\min\{n\log n, n\log\log r\}) for hierarchy-based algorithms for undirected real-weighted SSSP [Pettie & Ramachandran 2005], but our algorithm does not obey the properties required for that lower bound. As a non-hierarchy-based approach, our algorithm shows great advantage with much simpler structure, and is much easier to implement.Comment: 17 page

    Faster Parallel Algorithm for Approximate Shortest Path

    Full text link
    We present the first mpolylog(n)m\,\text{polylog}(n) work, polylog(n)\text{polylog}(n) time algorithm in the PRAM model that computes (1+ϵ)(1+\epsilon)-approximate single-source shortest paths on weighted, undirected graphs. This improves upon the breakthrough result of Cohen~[JACM'00] that achieves O(m1+ϵ0)O(m^{1+\epsilon_0}) work and polylog(n)\text{polylog}(n) time. While most previous approaches, including Cohen's, leveraged the power of hopsets, our algorithm builds upon the recent developments in \emph{continuous optimization}, studying the shortest path problem from the lens of the closely-related \emph{minimum transshipment} problem. To obtain our algorithm, we demonstrate a series of near-linear work, polylogarithmic-time reductions between the problems of approximate shortest path, approximate transshipment, and 1\ell_1-embeddings, and establish a recursive algorithm that cycles through the three problems and reduces the graph size on each cycle. As a consequence, we also obtain faster parallel algorithms for approximate transshipment and 1\ell_1-embeddings with polylogarithmic distortion. The minimum transshipment algorithm in particular improves upon the previous best m1+o(1)m^{1+o(1)} work sequential algorithm of Sherman~[SODA'17]. To improve readability, the paper is almost entirely self-contained, save for several staple theorems in algorithms and combinatorics.Comment: 53 pages, STOC 202

    Efficient Construction of Probabilistic Tree Embeddings

    Get PDF
    In this paper we describe an algorithm that embeds a graph metric (V,dG)(V,d_G) on an undirected weighted graph G=(V,E)G=(V,E) into a distribution of tree metrics (T,DT)(T,D_T) such that for every pair u,vVu,v\in V, dG(u,v)dT(u,v)d_G(u,v)\leq d_T(u,v) and ET[dT(u,v)]O(logn)dG(u,v){\bf{E}}_{T}[d_T(u,v)]\leq O(\log n)\cdot d_G(u,v). 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 nn vertices and mm edges, our algorithm runs in O(mlogn)O(m\log n) time with high probability, which improves the previous upper bound of O(mlog3n)O(m\log^3 n) 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 kk-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 O(mlogn)O(m \log n) time, and further propose a simple yet efficient algorithm to converted this sequence to a tree embedding in O(nlogn)O(n\log n) 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

    Bellman-Ford is optimal for shortest hop-bounded paths

    Get PDF
    This paper is about the problem of finding a shortest ss-tt path using at most hh edges in edge-weighted graphs. The Bellman--Ford algorithm solves this problem in O(hm)O(hm) time, where mm is the number of edges. We show that this running time is optimal, up to subpolynomial factors, under popular fine-grained complexity assumptions. More specifically, we show that under the APSP Hypothesis the problem cannot be solved faster already in undirected graphs with non-negative edge weights. This lower bound holds even restricted to graphs of arbitrary density and for arbitrary hO(m)h \in O(\sqrt{m}). Moreover, under a stronger assumption, namely the Min-Plus Convolution Hypothesis, we can eliminate the restriction hO(m)h \in O(\sqrt{m}). In other words, the O(hm)O(hm) bound is tight for the entire space of parameters hh, mm, and nn, where nn is the number of nodes. Our lower bounds can be contrasted with the recent near-linear time algorithm for the negative-weight Single-Source Shortest Paths problem, which is the textbook application of the Bellman--Ford algorithm

    Replacement Paths via Row Minima of Concise Matrices

    Full text link
    Matrix MM is {\em kk-concise} if the finite entries of each column of MM consist of kk or less intervals of identical numbers. We give an O(n+m)O(n+m)-time algorithm to compute the row minima of any O(1)O(1)-concise n×mn\times m matrix. Our algorithm yields the first O(n+m)O(n+m)-time reductions from the replacement-paths problem on an nn-node mm-edge undirected graph (respectively, directed acyclic graph) to the single-source shortest-paths problem on an O(n)O(n)-node O(m)O(m)-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 O(n+m)O(n+m)-time algorithms for the replacement-paths problem on the following classes of nn-node mm-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 simpler and more efficient algorithm for the next-to-shortest path problem

    Full text link
    Given an undirected graph G=(V,E)G=(V,E) with positive edge lengths and two vertices ss and tt, the next-to-shortest path problem is to find an stst-path which length is minimum amongst all stst-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 ss and tt to all other vertices are given. Particularly our new algorithm runs in O(VlogV+E)O(|V|\log |V|+|E|) time for general graphs, which improves the previous result of O(V2)O(|V|^2) 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

    Near-Optimal Approximate Shortest Paths and Transshipment in Distributed and Streaming Models

    Full text link
    We present a method for solving the transshipment problem - also known as uncapacitated minimum cost flow - up to a multiplicative error of 1+ε1 + \varepsilon in undirected graphs with non-negative edge weights using a tailored gradient descent algorithm. Using O~()\tilde{O}(\cdot) to hide polylogarithmic factors in nn (the number of nodes in the graph), our gradient descent algorithm takes O~(ε2)\tilde O(\varepsilon^{-2}) iterations, and in each iteration it solves an instance of the transshipment problem up to a multiplicative error of polylogn\operatorname{polylog} n. 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: (1+ε)(1 + \varepsilon)-approximate SSSP using O~((n+D)ε3)\tilde{O}((\sqrt{n} + D)\varepsilon^{-3}) rounds, where D D is the (hop) diameter of the network. (2) Broadcast congested clique model: (1+ε)(1 + \varepsilon)-approximate transshipment and SSSP using O~(ε2)\tilde{O}(\varepsilon^{-2}) rounds. (3) Multipass streaming model: (1+ε)(1 + \varepsilon)-approximate transshipment and SSSP using O~(n)\tilde{O}(n) space and O~(ε2)\tilde{O}(\varepsilon^{-2}) 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 nn; 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
    corecore