1,572 research outputs found

    Sublinear Distance Labeling

    Get PDF
    A distance labeling scheme labels the nn nodes of a graph with binary strings such that, given the labels of any two nodes, one can determine the distance in the graph between the two nodes by looking only at the labels. A DD-preserving distance labeling scheme only returns precise distances between pairs of nodes that are at distance at least DD from each other. In this paper we consider distance labeling schemes for the classical case of unweighted graphs with both directed and undirected edges. We present a O(nDlog2D)O(\frac{n}{D}\log^2 D) bit DD-preserving distance labeling scheme, improving the previous bound by Bollob\'as et. al. [SIAM J. Discrete Math. 2005]. We also give an almost matching lower bound of Ω(nD)\Omega(\frac{n}{D}). With our DD-preserving distance labeling scheme as a building block, we additionally achieve the following results: 1. We present the first distance labeling scheme of size o(n)o(n) for sparse graphs (and hence bounded degree graphs). This addresses an open problem by Gavoille et. al. [J. Algo. 2004], hereby separating the complexity from distance labeling in general graphs which require Ω(n)\Omega(n) bits, Moon [Proc. of Glasgow Math. Association 1965]. 2. For approximate rr-additive labeling schemes, that return distances within an additive error of rr we show a scheme of size O(nrpolylog(rlogn)logn)O\left ( \frac{n}{r} \cdot\frac{\operatorname{polylog} (r\log n)}{\log n} \right ) for r2r \ge 2. This improves on the current best bound of O(nr)O\left(\frac{n}{r}\right) by Alstrup et. al. [SODA 2016] for sub-polynomial rr, and is a generalization of a result by Gawrychowski et al. [arXiv preprint 2015] who showed this for r=2r=2.Comment: A preliminary version of this paper appeared at ESA'1

    Sparse Fault-Tolerant BFS Trees

    Full text link
    This paper addresses the problem of designing a sparse {\em fault-tolerant} BFS tree, or {\em FT-BFS tree} for short, namely, a sparse subgraph TT of the given network GG such that subsequent to the failure of a single edge or vertex, the surviving part TT' of TT still contains a BFS spanning tree for (the surviving part of) GG. Our main results are as follows. We present an algorithm that for every nn-vertex graph GG and source node ss constructs a (single edge failure) FT-BFS tree rooted at ss with O(n \cdot \min\{\Depth(s), \sqrt{n}\}) edges, where \Depth(s) is the depth of the BFS tree rooted at ss. This result is complemented by a matching lower bound, showing that there exist nn-vertex graphs with a source node ss for which any edge (or vertex) FT-BFS tree rooted at ss has Ω(n3/2)\Omega(n^{3/2}) edges. We then consider {\em fault-tolerant multi-source BFS trees}, or {\em FT-MBFS trees} for short, aiming to provide (following a failure) a BFS tree rooted at each source sSs\in S for some subset of sources SVS\subseteq V. Again, tight bounds are provided, showing that there exists a poly-time algorithm that for every nn-vertex graph and source set SVS \subseteq V of size σ\sigma constructs a (single failure) FT-MBFS tree T(S)T^*(S) from each source siSs_i \in S, with O(σn3/2)O(\sqrt{\sigma} \cdot n^{3/2}) edges, and on the other hand there exist nn-vertex graphs with source sets SVS \subseteq V of cardinality σ\sigma, on which any FT-MBFS tree from SS has Ω(σn3/2)\Omega(\sqrt{\sigma}\cdot n^{3/2}) edges. Finally, we propose an O(logn)O(\log n) approximation algorithm for constructing FT-BFS and FT-MBFS structures. The latter is complemented by a hardness result stating that there exists no Ω(logn)\Omega(\log n) approximation algorithm for these problems under standard complexity assumptions

    A Linear-Size Logarithmic Stretch Path-Reporting Distance Oracle for General Graphs

    Full text link
    In 2001 Thorup and Zwick devised a distance oracle, which given an nn-vertex undirected graph and a parameter kk, has size O(kn1+1/k)O(k n^{1+1/k}). Upon a query (u,v)(u,v) their oracle constructs a (2k1)(2k-1)-approximate path Π\Pi between uu and vv. The query time of the Thorup-Zwick's oracle is O(k)O(k), and it was subsequently improved to O(1)O(1) by Chechik. A major drawback of the oracle of Thorup and Zwick is that its space is Ω(nlogn)\Omega(n \cdot \log n). Mendel and Naor devised an oracle with space O(n1+1/k)O(n^{1+1/k}) and stretch O(k)O(k), but their oracle can only report distance estimates and not actual paths. In this paper we devise a path-reporting distance oracle with size O(n1+1/k)O(n^{1+1/k}), stretch O(k)O(k) and query time O(nϵ)O(n^\epsilon), for an arbitrarily small ϵ>0\epsilon > 0. In particular, our oracle can provide logarithmic stretch using linear size. Another variant of our oracle has size O(nloglogn)O(n \log\log n), polylogarithmic stretch, and query time O(loglogn)O(\log\log n). For unweighted graphs we devise a distance oracle with multiplicative stretch O(1)O(1), additive stretch O(β(k))O(\beta(k)), for a function β()\beta(\cdot), space O(n1+1/kβ)O(n^{1+1/k} \cdot \beta), and query time O(nϵ)O(n^\epsilon), for an arbitrarily small constant ϵ>0\epsilon >0. The tradeoff between multiplicative stretch and size in these oracles is far below girth conjecture threshold (which is stretch 2k12k-1 and size O(n1+1/k)O(n^{1+1/k})). Breaking the girth conjecture tradeoff is achieved by exhibiting a tradeoff of different nature between additive stretch β(k)\beta(k) and size O(n1+1/k)O(n^{1+1/k}). A similar type of tradeoff was exhibited by a construction of (1+ϵ,β)(1+\epsilon,\beta)-spanners due to Elkin and Peleg. However, so far (1+ϵ,β)(1+\epsilon,\beta)-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}

    Constructing Light Spanners Deterministically in Near-Linear Time

    Get PDF
    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

    Simpler, faster and shorter labels for distances in graphs

    Full text link
    We consider how to assign labels to any undirected graph with n nodes such that, given the labels of two nodes and no other information regarding the graph, it is possible to determine the distance between the two nodes. The challenge in such a distance labeling scheme is primarily to minimize the maximum label lenght and secondarily to minimize the time needed to answer distance queries (decoding). Previous schemes have offered different trade-offs between label lengths and query time. This paper presents a simple algorithm with shorter labels and shorter query time than any previous solution, thereby improving the state-of-the-art with respect to both label length and query time in one single algorithm. Our solution addresses several open problems concerning label length and decoding time and is the first improvement of label length for more than three decades. More specifically, we present a distance labeling scheme with label size (log 3)/2 + o(n) (logarithms are in base 2) and O(1) decoding time. This outperforms all existing results with respect to both size and decoding time, including Winkler's (Combinatorica 1983) decade-old result, which uses labels of size (log 3)n and O(n/log n) decoding time, and Gavoille et al. (SODA'01), which uses labels of size 11n + o(n) and O(loglog n) decoding time. In addition, our algorithm is simpler than the previous ones. In the case of integral edge weights of size at most W, we present almost matching upper and lower bounds for label sizes. For r-additive approximation schemes, where distances can be off by an additive constant r, we give both upper and lower bounds. In particular, we present an upper bound for 1-additive approximation schemes which, in the unweighted case, has the same size (ignoring second order terms) as an adjacency scheme: n/2. We also give results for bipartite graphs and for exact and 1-additive distance oracles

    Route Planning in Transportation Networks

    Full text link
    We survey recent advances in algorithms for route planning in transportation networks. For road networks, we show that one can compute driving directions in milliseconds or less even at continental scale. A variety of techniques provide different trade-offs between preprocessing effort, space requirements, and query time. Some algorithms can answer queries in a fraction of a microsecond, while others can deal efficiently with real-time traffic. Journey planning on public transportation systems, although conceptually similar, is a significantly harder problem due to its inherent time-dependent and multicriteria nature. Although exact algorithms are fast enough for interactive queries on metropolitan transit systems, dealing with continent-sized instances requires simplifications or heavy preprocessing. The multimodal route planning problem, which seeks journeys combining schedule-based transportation (buses, trains) with unrestricted modes (walking, driving), is even harder, relying on approximate solutions even for metropolitan inputs.Comment: This is an updated version of the technical report MSR-TR-2014-4, previously published by Microsoft Research. This work was mostly done while the authors Daniel Delling, Andrew Goldberg, and Renato F. Werneck were at Microsoft Research Silicon Valle

    Exact Distance Oracles for Planar Graphs

    Full text link
    We present new and improved data structures that answer exact node-to-node distance queries in planar graphs. Such data structures are also known as distance oracles. For any directed planar graph on n nodes with non-negative lengths we obtain the following: * Given a desired space allocation S[nlglgn,n2]S\in[n\lg\lg n,n^2], we show how to construct in O~(S)\tilde O(S) time a data structure of size O(S)O(S) that answers distance queries in O~(n/S)\tilde O(n/\sqrt S) time per query. As a consequence, we obtain an improvement over the fastest algorithm for k-many distances in planar graphs whenever k[n,n)k\in[\sqrt n,n). * We provide a linear-space exact distance oracle for planar graphs with query time O(n1/2+eps)O(n^{1/2+eps}) for any constant eps>0. This is the first such data structure with provable sublinear query time. * For edge lengths at least one, we provide an exact distance oracle of space O~(n)\tilde O(n) such that for any pair of nodes at distance D the query time is O~(minD,n)\tilde O(min {D,\sqrt n}). Comparable query performance had been observed experimentally but has never been explained theoretically. Our data structures are based on the following new tool: given a non-self-crossing cycle C with c=O(n)c = O(\sqrt n) nodes, we can preprocess G in O~(n)\tilde O(n) time to produce a data structure of size O(nlglgc)O(n \lg\lg c) that can answer the following queries in O~(c)\tilde O(c) time: for a query node u, output the distance from u to all the nodes of C. This data structure builds on and extends a related data structure of Klein (SODA'05), which reports distances to the boundary of a face, rather than a cycle. The best distance oracles for planar graphs until the current work are due to Cabello (SODA'06), Djidjev (WG'96), and Fakcharoenphol and Rao (FOCS'01). For σ(1,4/3)\sigma\in(1,4/3) and space S=nσS=n^\sigma, we essentially improve the query time from n2/Sn^2/S to n2/S\sqrt{n^2/S}.Comment: To appear in the proceedings of the 23rd ACM-SIAM Symposium on Discrete Algorithms, SODA 201
    corecore