57 research outputs found

    Simple parallel and distributed algorithms for spectral graph sparsification

    Full text link
    We describe a simple algorithm for spectral graph sparsification, based on iterative computations of weighted spanners and uniform sampling. Leveraging the algorithms of Baswana and Sen for computing spanners, we obtain the first distributed spectral sparsification algorithm. We also obtain a parallel algorithm with improved work and time guarantees. Combining this algorithm with the parallel framework of Peng and Spielman for solving symmetric diagonally dominant linear systems, we get a parallel solver which is much closer to being practical and significantly more efficient in terms of the total work.Comment: replaces "A simple parallel and distributed algorithm for spectral sparsification". Minor change

    CS 610-103: Data Structures and Algorithms

    Get PDF

    Directed Hamiltonicity and Out-Branchings via Generalized Laplacians

    Get PDF
    We are motivated by a tantalizing open question in exact algorithms: can we detect whether an nn-vertex directed graph GG has a Hamiltonian cycle in time significantly less than 2n2^n? We present new randomized algorithms that improve upon several previous works: 1. We show that for any constant 0<λ<10<\lambda<1 and prime pp we can count the Hamiltonian cycles modulo p(1λ)n3pp^{\lfloor (1-\lambda)\frac{n}{3p}\rfloor} in expected time less than cnc^n for a constant c<2c<2 that depends only on pp and λ\lambda. Such an algorithm was previously known only for the case of counting modulo two [Bj\"orklund and Husfeldt, FOCS 2013]. 2. We show that we can detect a Hamiltonian cycle in O(3nα(G))O^*(3^{n-\alpha(G)}) time and polynomial space, where α(G)\alpha(G) is the size of the maximum independent set in GG. In particular, this yields an O(3n/2)O^*(3^{n/2}) time algorithm for bipartite directed graphs, which is faster than the exponential-space algorithm in [Cygan et al., STOC 2013]. Our algorithms are based on the algebraic combinatorics of "incidence assignments" that we can capture through evaluation of determinants of Laplacian-like matrices, inspired by the Matrix--Tree Theorem for directed graphs. In addition to the novel algorithms for directed Hamiltonicity, we use the Matrix--Tree Theorem to derive simple algebraic algorithms for detecting out-branchings. Specifically, we give an O(2k)O^*(2^k)-time randomized algorithm for detecting out-branchings with at least kk internal vertices, improving upon the algorithms of [Zehavi, ESA 2015] and [Bj\"orklund et al., ICALP 2015]. We also present an algebraic algorithm for the directed kk-Leaf problem, based on a non-standard monomial detection problem

    A nearly-mlogn time solver for SDD linear systems

    Full text link
    We present an improved algorithm for solving symmetrically diagonally dominant linear systems. On input of an n×nn\times n symmetric diagonally dominant matrix AA with mm non-zero entries and a vector bb such that Axˉ=bA\bar{x} = b for some (unknown) vector xˉ\bar{x}, our algorithm computes a vector xx such that xxˉA<ϵxˉA||{x}-\bar{x}||_A < \epsilon ||\bar{x}||_A {A||\cdot||_A denotes the A-norm} in time O~(mlognlog(1/ϵ)).{\tilde O}(m\log n \log (1/\epsilon)). The solver utilizes in a standard way a `preconditioning' chain of progressively sparser graphs. To claim the faster running time we make a two-fold improvement in the algorithm for constructing the chain. The new chain exploits previously unknown properties of the graph sparsification algorithm given in [Koutis,Miller,Peng, FOCS 2010], allowing for stronger preconditioning properties. We also present an algorithm of independent interest that constructs nearly-tight low-stretch spanning trees in time O~(mlogn)\tilde{O}(m\log{n}), a factor of O(logn)O(\log{n}) faster than the algorithm in [Abraham,Bartal,Neiman, FOCS 2008]. This speedup directly reflects on the construction time of the preconditioning chain.Comment: to appear in FOCS1
    corecore