Linear-Size hopsets with small hopbound, and constant-hopbound hopsets in RNC

For a positive parameter β, the β-bounded distance between a pair of vertices u,v in a weighted undirected graph G = (V,E,ømega) is the length of the shortest u-v path in G with at most β edges, aka hops. For β as above and ε > 0, a (β,ε)-hopset of G = (V,E,ømega) is a graph GH =(V,H,ømegaH) on the same vertex set, such that all distances in G are (1+ε)-approximated by β-bounded distances in G ∪ GH. Hopsets are a fundamental graph-theoretic and graph-algorithmic construct, and they are widely used for distance-related problems in a variety of computational settings. Currently existing constructions of hopsets produce hopsets either with Ømega(n łog n) edges, or with a hopbound nØmega(1). In this paper we devise a construction of linear-size hopsets with hopbound (ignoring the dependence on ε) (łog łog n)łog łog n + O(1). This improves the previous hopbound for linear-size hopsets almost exponentially. We also devise efficient implementations of our construction in PRAM and distributed settings. The only existing PRAM algorithm [11] for computing hopsets with a constant (i.e., independent of n) hopbound requires nØmega(1) time. We devise a PRAM algorithm with polylogarithmic running time for computing hopsets with a constant hopbound, i.e., our running time is exponentially better than the previous one. Moreover, these hopsets are also significantly sparser than their counterparts from [11]. We apply these hopsets to achieve the following online variant of shortest paths in the PRAM model: preprocess a given weighted graph within polylogarithmic time, and then given any query vertex v, report all approximate shortest paths from v in constant time. All previous constructions of hopsets require either polylogarithmic time per query or polynomial preprocessing time.

[1]  Aleksander Madry,et al.  Computing Maximum Flow with Augmenting Electrical Flows , 2016, 2016 IEEE 57th Annual Symposium on Foundations of Computer Science (FOCS).

[2]  Christoph Lenzen,et al.  Near-Optimal Approximate Shortest Paths and Transshipment in Distributed and Streaming Models , 2016, DISC.

[3]  Pranay Chaudhuri Parallel algorithms - designs and analysis , 1992, Advances in computer science series.

[4]  Danupon Nanongkai,et al.  Distributed approximation algorithms for weighted shortest paths , 2014, STOC.

[5]  David Peleg,et al.  (1+epsilon, beta)-Spanner Constructions for General Graphs , 2004, SIAM J. Comput..

[6]  Edith Cohen,et al.  Polylog-time and near-linear work approximation scheme for undirected shortest paths , 1994, STOC '94.

[7]  Boaz Patt-Shamir,et al.  Distributed distance computation and routing with small messages , 2018, Distributed Computing.

[8]  Michael Elkin,et al.  Near-Optimal Distributed Routing with Low Memory , 2018, PODC.

[9]  Boaz Patt-Shamir,et al.  Fast Partial Distance Estimation and Applications , 2014, PODC.

[10]  Mihalis Yannakakis,et al.  High-probability parallel transitive closure algorithms , 1990, SPAA '90.

[11]  Ludek Kucera,et al.  Parallel Computation and Conflicts in Memory Access , 1982, Information Processing Letters.

[12]  Michael Elkin,et al.  Efficient algorithms for constructing (1+∊,β)-spanners in the distributed and streaming models , 2006, Distributed Computing.

[13]  Mihalis Yannakakis,et al.  High-Probability Parallel Transitive-Closure Algorithms , 1991, SIAM J. Comput..

[14]  Lenore Cowen,et al.  Near-linear cost sequential and distributed constructions of sparse neighborhood covers , 1993, Proceedings of 1993 IEEE 34th Annual Foundations of Computer Science.

[15]  Michael Elkin,et al.  Computing almost shortest paths , 2001, TALG.

[16]  Yijie Han,et al.  Deterministic sorting in O(nloglogn) time and linear space , 2004, J. Algorithms.

[17]  Philip N. Klein,et al.  A Randomized Parallel Algorithm for Single-Source Shortest Paths , 1997, J. Algorithms.

[18]  Thomas H. Spencer,et al.  Time-Work Tradeoffs of the Single-Source Shortest Paths Problem , 1999, J. Algorithms.

[19]  Monika Henzinger,et al.  Decremental Single-Source Shortest Paths on Undirected Graphs in Near-Linear Total Update Time , 2018, J. ACM.

[20]  Edith Cohen Using Selective Path-Doubling for Parallel Shortest-Path Computations , 1997, J. Algorithms.

[21]  Gary L. Miller,et al.  Improved Parallel Algorithms for Spanners and Hopsets , 2015, SPAA.

[22]  Michael Elkin,et al.  Distributed exact shortest paths in sublinear time , 2017, STOC.

[23]  Aaron Bernstein,et al.  Fully Dynamic (2 + epsilon) Approximate All-Pairs Shortest Paths with Fast Query and Close to Linear Update Time , 2009, 2009 50th Annual IEEE Symposium on Foundations of Computer Science.

[24]  Seth Pettie,et al.  Thorup-Zwick Emulators are Universally Optimal Hopsets , 2017, Inf. Process. Lett..

[25]  Jian Zhang,et al.  Efficient algorithms for constructing (1+, varepsilon;, beta)-spanners in the distributed and streaming models. , 2004, PODC 2004.

[26]  Seth Pettie,et al.  A Hierarchy of Lower Bounds for Sublinear Additive Spanners , 2016, SODA.

[27]  Christoph Lenzen,et al.  Parallel Metric Tree Embedding based on an Algebraic View on Moore-Bellman-Ford , 2015, SPAA.

[28]  James B. Orlin,et al.  Max flows in O(nm) time, or better , 2013, STOC '13.

[29]  Mikkel Thorup,et al.  Spanners and emulators with sublinear distance errors , 2006, SODA '06.

[30]  Michael Elkin,et al.  Linear-Size Hopsets with Small Hopbound, and Distributed Routing with Low Memory , 2017, ArXiv.

[31]  Monika Henzinger,et al.  Decremental Single-Source Shortest Paths on Undirected Graphs in Near-Linear Total Update Time , 2014, 2014 IEEE 55th Annual Symposium on Foundations of Computer Science.

[32]  Piotr Sankowski,et al.  Negative-Weight Shortest Paths and Unit Capacity Minimum Cost Flow in Õ (m10/7 log W) Time (Extended Abstract) , 2016, SODA.

[33]  Edith Cohen Fast algorithms for constructing t-spanners and paths with stretch t , 1993, FOCS.

[34]  Monika Henzinger,et al.  A deterministic almost-tight distributed algorithm for approximating single-source shortest paths , 2015, STOC.

[35]  Mikkel Thorup,et al.  Approximate distance oracles , 2001, JACM.

[36]  Uzi Vishkin,et al.  Finding the Maximum, Merging, and Sorting in a Parallel Computation Model , 1981, J. Algorithms.