863 research outputs found

    Effective Edge-Fault-Tolerant Single-Source Spanners via Best (or Good) Swap Edges

    Full text link
    Computing \emph{all best swap edges} (ABSE) of a spanning tree TT of a given nn-vertex and mm-edge undirected and weighted graph GG means to select, for each edge ee of TT, a corresponding non-tree edge ff, in such a way that the tree obtained by replacing ee with ff enjoys some optimality criterion (which is naturally defined according to some objective function originally addressed by TT). Solving efficiently an ABSE problem is by now a classic algorithmic issue, since it conveys a very successful way of coping with a (transient) \emph{edge failure} in tree-based communication networks: just replace the failing edge with its respective swap edge, so as that the connectivity is promptly reestablished by minimizing the rerouting and set-up costs. In this paper, we solve the ABSE problem for the case in which TT is a \emph{single-source shortest-path tree} of GG, and our two selected swap criteria aim to minimize either the \emph{maximum} or the \emph{average stretch} in the swap tree of all the paths emanating from the source. Having these criteria in mind, the obtained structures can then be reviewed as \emph{edge-fault-tolerant single-source spanners}. For them, we propose two efficient algorithms running in O(mn+n2logn)O(m n +n^2 \log n) and O(mnlogα(m,n))O(m n \log \alpha(m,n)) time, respectively, and we show that the guaranteed (either maximum or average, respectively) stretch factor is equal to 3, and this is tight. Moreover, for the maximum stretch, we also propose an almost linear O(mlogα(m,n))O(m \log \alpha(m,n)) time algorithm computing a set of \emph{good} swap edges, each of which will guarantee a relative approximation factor on the maximum stretch of 3/23/2 (tight) as opposed to that provided by the corresponding BSE. Surprisingly, no previous results were known for these two very natural swap problems.Comment: 15 pages, 4 figures, SIROCCO 201

    A Novel Algorithm for the All-Best-Swap-Edge Problem on Tree Spanners

    Get PDF
    Given a 2-edge connected, unweighted, and undirected graph GG with nn vertices and mm edges, a σ\sigma-tree spanner is a spanning tree TT of GG in which the ratio between the distance in TT of any pair of vertices and the corresponding distance in GG is upper bounded by σ\sigma. The minimum value of σ\sigma for which TT is a σ\sigma-tree spanner of GG is also called the {\em stretch factor} of TT. We address the fault-tolerant scenario in which each edge ee of a given tree spanner may temporarily fail and has to be replaced by a {\em best swap edge}, i.e. an edge that reconnects TeT-e at a minimum stretch factor. More precisely, we design an O(n2)O(n^2) time and space algorithm that computes a best swap edge of every tree edge. Previously, an O(n2log4n)O(n^2 \log^4 n) time and O(n2+mlog2n)O(n^2+m\log^2n) space algorithm was known for edge-weighted graphs [Bil\`o et al., ISAAC 2017]. Even if our improvements on both the time and space complexities are of a polylogarithmic factor, we stress the fact that the design of a o(n2)o(n^2) time and space algorithm would be considered a breakthrough.Comment: The paper has been accepted for publication at the 29th International Symposium on Algorithms and Computation (ISAAC 2018). 12 pages, 3 figure

    An Improved Algorithm for Computing All the Best Swap Edges of a Tree Spanner

    Get PDF
    A tree sigma-spanner of a positively real-weighted n-vertex and m-edge undirected graph G is a spanning tree T of G which approximately preserves (i.e., up to a multiplicative stretch factor sigma) distances in G. Tree spanners with provably good stretch factors find applications in communication networks, distributed systems, and network design. However, finding an optimal or even a good tree spanner is a very hard computational task. Thus, if one has to face a transient edge failure in T, the overall effort that has to be afforded to rebuild a new tree spanner (i.e., computational costs, set-up of new links, updating of the routing tables, etc.) can be rather prohibitive. To circumvent this drawback, an effective alternative is that of associating with each tree edge a best possible (in terms of resulting stretch) swap edge -- a well-established approach in the literature for several other tree topologies. Correspondingly, the problem of computing all the best swap edges of a tree spanner is a challenging algorithmic problem, since solving it efficiently means to exploit the structure of shortest paths not only in G, but also in all the scenarios in which an edge of T has failed. For this problem we provide a very efficient solution, running in O(n^2 log^4 n) time, which drastically improves (almost by a quadratic factor in n in dense graphs!) on the previous known best result

    Space-Efficient Fault-Tolerant Diameter Oracles

    Get PDF
    We design ff-edge fault-tolerant diameter oracles (ff-FDOs). We preprocess a given graph GG on nn vertices and mm edges, and a positive integer ff, to construct a data structure that, when queried with a set FF of Ff|F| \leq f edges, returns the diameter of GFG-F. For a single failure (f=1f=1) in an unweighted directed graph of diameter DD, there exists an approximate FDO by Henzinger et al. [ITCS 2017] with stretch (1+ε)(1+\varepsilon), constant query time, space O(m)O(m), and a combinatorial preprocessing time of O~(mn+n1.5Dm/ε)\widetilde{O}(mn + n^{1.5} \sqrt{Dm/\varepsilon}).We present an FDO for directed graphs with the same stretch, query time, and space. It has a preprocessing time of O~(mn+n2/ε)\widetilde{O}(mn + n^2/\varepsilon). The preprocessing time nearly matches a conditional lower bound for combinatorial algorithms, also by Henzinger et al. With fast matrix multiplication, we achieve a preprocessing time of O~(n2.5794+n2/ε)\widetilde{O}(n^{2.5794} + n^2/\varepsilon). We further prove an information-theoretic lower bound showing that any FDO with stretch better than 3/23/2 requires Ω(m)\Omega(m) bits of space. For multiple failures (f>1f>1) in undirected graphs with non-negative edge weights, we give an ff-FDO with stretch (f+2)(f+2), query time O(f2log2n)O(f^2\log^2{n}), O~(fn)\widetilde{O}(fn) space, and preprocessing time O~(fm)\widetilde{O}(fm). We complement this with a lower bound excluding any finite stretch in o(fn)o(fn) space. We show that for unweighted graphs with polylogarithmic diameter and up to f=o(logn/loglogn)f = o(\log n/ \log\log n) failures, one can swap approximation for query time and space. We present an exact combinatorial ff-FDO with preprocessing time mn1+o(1)mn^{1+o(1)}, query time no(1)n^{o(1)}, and space n2+o(1)n^{2+o(1)}. When using fast matrix multiplication instead, the preprocessing time can be improved to nω+o(1)n^{\omega+o(1)}, where ω<2.373\omega < 2.373 is the matrix multiplication exponent.Comment: Full version of a paper to appear at MFCS'21. Abstract shortened to meet ArXiv requirement

    Exploring the Design Space of Static and Incremental Graph Connectivity Algorithms on GPUs

    Full text link
    Connected components and spanning forest are fundamental graph algorithms due to their use in many important applications, such as graph clustering and image segmentation. GPUs are an ideal platform for graph algorithms due to their high peak performance and memory bandwidth. While there exist several GPU connectivity algorithms in the literature, many design choices have not yet been explored. In this paper, we explore various design choices in GPU connectivity algorithms, including sampling, linking, and tree compression, for both the static as well as the incremental setting. Our various design choices lead to over 300 new GPU implementations of connectivity, many of which outperform state-of-the-art. We present an experimental evaluation, and show that we achieve an average speedup of 2.47x speedup over existing static algorithms. In the incremental setting, we achieve a throughput of up to 48.23 billion edges per second. Compared to state-of-the-art CPU implementations on a 72-core machine, we achieve a speedup of 8.26--14.51x for static connectivity and 1.85--13.36x for incremental connectivity using a Tesla V100 GPU

    Parallel Batch-Dynamic Graph Connectivity

    Full text link
    In this paper, we study batch parallel algorithms for the dynamic connectivity problem, a fundamental problem that has received considerable attention in the sequential setting. The most well known sequential algorithm for dynamic connectivity is the elegant level-set algorithm of Holm, de Lichtenberg and Thorup (HDT), which achieves O(log2n)O(\log^2 n) amortized time per edge insertion or deletion, and O(logn/loglogn)O(\log n / \log\log n) time per query. We design a parallel batch-dynamic connectivity algorithm that is work-efficient with respect to the HDT algorithm for small batch sizes, and is asymptotically faster when the average batch size is sufficiently large. Given a sequence of batched updates, where Δ\Delta is the average batch size of all deletions, our algorithm achieves O(lognlog(1+n/Δ))O(\log n \log(1 + n / \Delta)) expected amortized work per edge insertion and deletion and O(log3n)O(\log^3 n) depth w.h.p. Our algorithm answers a batch of kk connectivity queries in O(klog(1+n/k))O(k \log(1 + n/k)) expected work and O(logn)O(\log n) depth w.h.p. To the best of our knowledge, our algorithm is the first parallel batch-dynamic algorithm for connectivity.Comment: This is the full version of the paper appearing in the ACM Symposium on Parallelism in Algorithms and Architectures (SPAA), 201
    corecore