arXiv subjects

Danupon Nanongkai

Publications and source records attributed to Danupon Nanongkai.

At least 37 records · Page 2Linked to original sources

arXiv2021

Vertex Connectivity in Poly-logarithmic Max-flows

The vertex connectivity of an $m$-edge $n$-vertex undirected graph is the smallest number of vertices whose removal disconnects the graph, or leaves only a singleton vertex. In this paper, we give a reduction from the vertex connectivity problem to a set of maxflow instances. Using this reduction, we can solve vertex connectivity in $\tilde O(m^α)$ time for any $α\ge 1$, if there is a $m^α$-time maxflow algorithm. Using the current best maxflow algorithm that runs in $m^{4/3+o(1)}$ time (Kathuria, Liu and Sidford, FOCS 2020), this yields a $m^{4/3+o(1)}$-time vertex connectivity algorithm. This is the first improvement in the running time of the vertex connectivity problem in over 20 years, the previous best being an $\tilde O(mn)$-time algorithm due to Henzinger, Rao, and Gabow (FOCS 1996). Indeed, no algorithm with an $o(mn)$ running time was known before our work, even if we assume an $\tilde O(m)$-time maxflow algorithm. Our new technique is robust enough to also improve the best $\tilde O(mn)$-time bound for directed vertex connectivity to $mn^{1-1/12+o(1)}$ time

cs.DS↗

arXiv2021

A Note on Isolating Cut Lemma for Submodular Function Minimization

It has been observed independently by many researchers that the isolating cut lemma of Li and Panigrahi [FOCS 2020] can be easily extended to obtain new algorithms for finding the non-trivial minimizer of a symmetric submodular function and solving the hypergraph minimum cut problem. This note contains these observations.

cs.DS↗

arXiv2021

Work-Optimal Parallel Minimum Cuts for Non-Sparse Graphs

We present the first work-optimal polylogarithmic-depth parallel algorithm for the minimum cut problem on non-sparse graphs. For $m\geq n^{1+ε}$ for any constant $ε>0$, our algorithm requires $O(m \log n)$ work and $O(\log^3 n)$ depth and succeeds with high probability. Its work matches the best $O(m \log n)$ runtime for sequential algorithms [MN STOC 2020, GMW SOSA 2021]. This improves the previous best work by Geissmann and Gianinazzi [SPAA 2018] by $O(\log^3 n)$ factor, while matching the depth of their algorithm. To do this, we design a work-efficient approximation algorithm and parallelize the recent sequential algorithms [MN STOC 2020; GMW SOSA 2021] that exploit a connection between 2-respecting minimum cuts and 2-dimensional orthogonal range searching.

cs.DS↗

arXiv2021

Weighted Min-Cut: Sequential, Cut-Query and Streaming Algorithms

Consider the following 2-respecting min-cut problem. Given a weighted graph $G$ and its spanning tree $T$, find the minimum cut among the cuts that contain at most two edges in $T$. This problem is an important subroutine in Karger's celebrated randomized near-linear-time min-cut algorithm [STOC'96]. We present a new approach for this problem which can be easily implemented in many settings, leading to the following randomized min-cut algorithms for weighted graphs. * An $O(m\frac{\log^2 n}{\log\log n} + n\log^6 n)$-time sequential algorithm: This improves Karger's $O(m \log^3 n)$ and $O(m\frac{(\log^2 n)\log (n^2/m)}{\log\log n} + n\log^6 n)$ bounds when the input graph is not extremely sparse or dense. Improvements over Karger's bounds were previously known only under a rather strong assumption that the input graph is simple [Henzinger et al. SODA'17; Ghaffari et al. SODA'20]. For unweighted graphs with parallel edges, our bound can be improved to $O(m\frac{\log^{1.5} n}{\log\log n} + n\log^6 n)$. * An algorithm requiring $\tilde O(n)$ cut queries to compute the min-cut of a weighted graph: This answers an open problem by Rubinstein et al. ITCS'18, who obtained a similar bound for simple graphs. * A streaming algorithm that requires $\tilde O(n)$ space and $O(\log n)$ passes to compute the min-cut: The only previous non-trivial exact min-cut algorithm in this setting is the 2-pass $\tilde O(n)$-space algorithm on simple graphs [Rubinstein et al., ITCS'18] (observed by Assadi et al. STOC'19). In contrast to Karger's 2-respecting min-cut algorithm which deploys sophisticated dynamic programming techniques, our approach exploits some cute structural properties so that it only needs to compute the values of $\tilde O(n)$ cuts corresponding to removing $\tilde O(n)$ pairs of tree edges, an operation that can be done quickly in many settings.

cs.DS↗

arXiv2021

Breaking Quadratic Time for Small Vertex Connectivity and an Approximation Scheme

Vertex connectivity a classic extensively-studied problem. Given an integer $k$, its goal is to decide if an $n$-node $m$-edge graph can be disconnected by removing $k$ vertices. Although a linear-time algorithm was postulated since 1974 [Aho, Hopcroft and Ullman], and despite its sibling problem of edge connectivity being resolved over two decades ago [Karger STOC'96], so far no vertex connectivity algorithms are faster than $O(n^2)$ time even for $k=4$ and $m=O(n)$. In the simplest case where $m=O(n)$ and $k=O(1)$, the $O(n^2)$ bound dates five decades back to [Kleitman IEEE Trans. Circuit Theory'69]. For general $k$ and $m$, the best bound is $\tilde{O}(\min(kn^2, n^ω+nk^ω))$. In this paper, we present a randomized Monte Carlo algorithm with $\tilde{O}(m+k^{7/3}n^{4/3})$ time for any $k=O(\sqrt{n})$. This gives the {\em first subquadratic time} bound for any $4\leq k \leq o(n^{2/7})$ and improves all above classic bounds for all $k\le n^{0.44}$. We also present a new randomized Monte Carlo $(1+ε)$-approximation algorithm that is strictly faster than the previous Henzinger's 2-approximation algorithm [J. Algorithms'97] and all previous exact algorithms. The key to our results is to avoid computing single-source connectivity, which was needed by all previous exact algorithms and is not known to admit $o(n^2)$ time. Instead, we design the first local algorithm for computing vertex connectivity; without reading the whole graph, our algorithm can find a separator of size at most $k$ or certify that there is no separator of size at most $k$ `near' a given seed node.

cs.DS↗

arXiv2021

Breaking the Quadratic Barrier for Matroid Intersection

The matroid intersection problem is a fundamental problem that has been extensively studied for half a century. In the classic version of this problem, we are given two matroids $\mathcal{M}_1 = (V, \mathcal{I}_1)$ and $\mathcal{M}_2 = (V, \mathcal{I}_2)$ on a comment ground set $V$ of $n$ elements, and then we have to find the largest common independent set $S \in \mathcal{I}_1 \cap \mathcal{I}_2$ by making independence oracle queries of the form "Is $S \in \mathcal{I}_1$?" or "Is $S \in \mathcal{I}_2$?" for $S \subseteq V$. The goal is to minimize the number of queries. Beating the existing $\tilde O(n^2)$ bound, known as the quadratic barrier, is an open problem that captures the limits of techniques from two lines of work. The first one is the classic Cunningham's algorithm [SICOMP 1986], whose $\tilde O(n^2)$-query implementations were shown by CLS+ [FOCS 2019] and Nguyen [2019]. The other one is the general cutting plane method of Lee, Sidford, and Wong [FOCS 2015]. The only progress towards breaking the quadratic barrier requires either approximation algorithms or a more powerful rank oracle query [CLS+ FOCS 2019]. No exact algorithm with $o(n^2)$ independence queries was known. In this work, we break the quadratic barrier with a randomized algorithm guaranteeing $\tilde O(n^{9/5})$ independence queries with high probability, and a deterministic algorithm guaranteeing $\tilde O(n^{11/6})$ independence queries. Our key insight is simple and fast algorithms to solve a graph reachability problem that arose in the standard augmenting path framework [Edmonds 1968]. Combining this with previous exact and approximation algorithms leads to our results.

cs.DS↗

arXiv2020

Distributed Weighted Min-Cut in Nearly-Optimal Time

Minimum-weight cut (min-cut) is a basic measure of a network's connectivity strength. While the min-cut can be computed efficiently in the sequential setting [Karger STOC'96], there was no efficient way for a distributed network to compute its own min-cut without limiting the input structure or dropping the output quality: In the standard CONGEST model, existing algorithms with nearly-optimal time (e.g. [Ghaffari, Kuhn, DISC'13; Nanongkai, Su, DISC'14]) can guarantee a solution that is $(1+ε)$-approximation at best while the exact $\tilde O(n^{0.8}D^{0.2} + n^{0.9})$-time algorithm [Ghaffari, Nowicki, Thorup, SODA'20] works only on *simple* networks (no weights and no parallel edges). Here $n$ and $D$ denote the network's number of vertices and hop-diameter, respectively. For the weighted case, the best bound was $\tilde O(n)$ [Daga, Henzinger, Nanongkai, Saranurak, STOC'19]. In this paper, we provide an *exact* $\tilde O(\sqrt n + D)$-time algorithm for computing min-cut on *weighted* networks. Our result improves even the previous algorithm that works only on simple networks. Its time complexity matches the known lower bound up to polylogarithmic factors. At the heart of our algorithm are a clever routing trick and two structural lemmas regarding the structure of a minimum cut of a graph. These two structural lemmas considerably strengthen and generalize the framework of Mukhopadhyay-Nanongkai [STOC'20] and can be of independent interest.

cs.DS↗

arXiv2020

Fully-Dynamic Graph Sparsifiers Against an Adaptive Adversary

Designing dynamic graph algorithms against an adaptive adversary is a major goal in the field of dynamic graph algorithms. While a few such algorithms are known for spanning trees, matchings, and single-source shortest paths, very little was known for an important primitive like graph sparsifiers. The challenge is how to approximately preserve so much information about the graph (e.g., all-pairs distances and all cuts) without revealing the algorithms' underlying randomness to the adaptive adversary. In this paper we present the first non-trivial efficient adaptive algorithms for maintaining spanners and cut sparisifers. These algorithms in turn imply improvements over existing algorithms for other problems. Our first algorithm maintains a polylog$(n)$-spanner of size $\tilde O(n)$ in polylog$(n)$ amortized update time. The second algorithm maintains an $O(k)$-approximate cut sparsifier of size $\tilde O(n)$ in $\tilde O(n^{1/k})$ amortized update time, for any $k\ge1$, which is polylog$(n)$ time when $k=\log(n)$. The third algorithm maintains a polylog$(n)$-approximate spectral sparsifier in polylog$(n)$ amortized update time. The amortized update time of both algorithms can be made worst-case by paying some sub-polynomial factors. Prior to our result, there were near-optimal algorithms against oblivious adversaries (e.g. Baswana et al. [TALG'12] and Abraham et al. [FOCS'16]), but the only non-trivial adaptive dynamic algorithm requires $O(n)$ amortized update time to maintain $3$- and $5$-spanner of size $O(n^{1+1/2})$ and $O(n^{1+1/3})$, respectively [Ausiello et al. ESA'05]. Our results are based on two novel techniques. The first technique, is a generic black-box reduction that allows us to assume that the graph undergoes only edge deletions and, more importantly, remains an expander with almost-uniform degree. The second technique we call proactive resampling. [...]

cs.DS↗

arXiv2020

A Deterministic Algorithm for Balanced Cut with Applications to Dynamic Connectivity, Flows, and Beyond

We consider the classical Minimum Balanced Cut problem: given a graph $G$, compute a partition of its vertices into two subsets of roughly equal volume, while minimizing the number of edges connecting the subsets. We present the first {\em deterministic, almost-linear time} approximation algorithm for this problem. Specifically, our algorithm, given an $n$-vertex $m$-edge graph $G$ and any parameter $1\leq r\leq O(\log n)$, computes a $(\log m)^{r^2}$-approximation for Minimum Balanced Cut on $G$, in time $O\left ( m^{1+O(1/r)+o(1)}\cdot (\log m)^{O(r^2)}\right )$. In particular, we obtain a $(\log m)^{1/ε}$-approximation in time $m^{1+O(1/\sqrtε)}$ for any constant $ε$, and a $(\log m)^{f(m)}$-approximation in time $m^{1+o(1)}$, for any slowly growing function $m$. We obtain deterministic algorithms with similar guarantees for the Sparsest Cut and the Lowest-Conductance Cut problems. Our algorithm for the Minimum Balanced Cut problem in fact provides a stronger guarantee: it either returns a balanced cut whose value is close to a given target value, or it certifies that such a cut does not exist by exhibiting a large subgraph of $G$ that has high conductance. We use this algorithm to obtain deterministic algorithms for dynamic connectivity and minimum spanning forest, whose worst-case update time on an $n$-vertex graph is $n^{o(1)}$, thus resolving a major open problem in the area of dynamic graph algorithms. Our work also implies deterministic algorithms for a host of additional problems, whose time complexities match, up to subpolynomial in $n$ factors, those of known randomized algorithms. The implications include almost-linear time deterministic algorithms for solving Laplacian systems and for approximating maximum flows in undirected graphs.

cs.DS↗

arXiv2020

Dynamic Set Cover: Improved Amortized and Worst-Case Update Time

In the dynamic minimum set cover problem, a challenge is to minimize the update time while guaranteeing close to the optimal $\min(O(\log n), f)$ approximation factor. (Throughout, $m$, $n$, $f$, and $C$ are parameters denoting the maximum number of sets, number of elements, frequency, and the cost range.) In the high-frequency range, when $f=Ω(\log n)$, this was achieved by a deterministic $O(\log n)$-approximation algorithm with $O(f \log n)$ amortized update time [Gupta et al. STOC'17]. In the low-frequency range, the line of work by Gupta et al. [STOC'17], Abboud et al. [STOC'19], and Bhattacharya et al. [ICALP'15, IPCO'17, FOCS'19] led to a deterministic $(1+ε)f$-approximation algorithm with $O(f \log (Cn)/ε^2)$ amortized update time. In this paper we improve the latter update time and provide the first bounds that subsume (and sometimes improve) the state-of-the-art dynamic vertex cover algorithms. We obtain: 1. $(1+ε)f$-approximation ratio in $O(f\log^2 (Cn)/ε^3)$ worst-case update time: No non-trivial worst-case update time was previously known for dynamic set cover. Our bound subsumes and improves by a logarithmic factor the $O(\log^3 n/\text{poly}(ε))$ worst-case update time for unweighted dynamic vertex cover (i.e., when $f=2$ and $C=1$) by Bhattacharya et al. [SODA'17]. 2. $(1+ε)f$-approximation ratio in $O\left((f^2/ε^3)+(f/ε^2) \log C\right)$ amortized update time: This result improves the previous $O(f \log (Cn)/ε^2)$ update time bound for most values of $f$ in the low-frequency range, i.e. whenever $f=o(\log n)$. It is the first that is independent of $m$ and $n$. It subsumes the constant amortized update time of Bhattacharya and Kulkarni [SODA'19] for unweighted dynamic vertex cover (i.e., when $f = 2$ and $C = 1$).

cs.DS↗

arXiv2020

Equivalence Classes and Conditional Hardness in Massively Parallel Computations

The Massively Parallel Computation (MPC) model serves as a common abstraction of many modern large-scale data processing frameworks, and has been receiving increasingly more attention over the past few years, especially in the context of classical graph problems. So far, the only way to argue lower bounds for this model is to condition on conjectures about the hardness of some specific problems, such as graph connectivity on promise graphs that are either one cycle or two cycles, usually called the one cycle vs. two cycles problem. This is unlike the traditional arguments based on conjectures about complexity classes (e.g., $\textsf{P} \neq \textsf{NP}$), which are often more robust in the sense that refuting them would lead to groundbreaking algorithms for a whole bunch of problems. In this paper we present connections between problems and classes of problems that allow the latter type of arguments. These connections concern the class of problems solvable in a sublogarithmic amount of rounds in the MPC model, denoted by $\textsf{MPC}(o(\log N))$, and some standard classes concerning space complexity, namely $\textsf{L}$ and $\textsf{NL}$, and suggest conjectures that are robust in the sense that refuting them would lead to many surprisingly fast new algorithms in the MPC model. We also obtain new conditional lower bounds, and prove new reductions and equivalences between problems in the MPC model.

cs.DC↗

arXiv2019

Computing and Testing Small Connectivity in Near-Linear Time and Queries via Fast Local Cut Algorithms

Consider the following "local" cut-detection problem in a directed graph: We are given a seed vertex $x$ and need to remove at most $k$ edges so that at most $ν$ edges can be reached from $x$ (a "local" cut) or output $\bot$ to indicate that no such cut exists. If we are given query access to the input graph, then this problem can in principle be solved without reading the whole graph and with query complexity depending on $k$ and $ν$. In this paper we consider a slack variant of this problem where, when such a cut exists, we can output a cut with up to $O(kν)$ edges reachable from $x$. We present a simple randomized algorithm spending $O(k^2ν)$ time and $O(kν)$ queries for the above variant, improving in particular a previous time bound of $O(k^{O(k)}ν)$ by Chechik et al. [SODA '17]. We also extend our algorithm to handle an approximate variant. We demonstrate that these local algorithms are versatile primitives for designing substantially improved algorithms for classic graph problems by providing the following three applications. (Throughout, $\tilde O(T)$ hides $\operatorname{polylog}(T)$.) (1) A randomized algorithm for the classic $k$-vertex connectivity problem that takes near-linear time when $k=O(\operatorname{polylog}(n))$, namely $\tilde O(m+nk^3)$ time in undirected graphs. For directed graphs our $\tilde O(mk^2)$-time algorithm is near-linear when $k=O(\operatorname{polylog}(n))$. Our techniques also yield an improved approximation scheme. (2) Property testing algorithms for $k$-edge and -vertex connectivity with query complexities that are near-linear in $k$, exponentially improving the state-of-the-art. This resolves two open problems, one by Goldreich and Ron [STOC '97] and one by Orenstein and Ron [Theor. Comput Sci. '11]. (3) A faster algorithm for computing the maximal $k$-edge connected subgraphs, improving prior work of Chechik et al. [SODA '17].

cs.DS↗

arXiv2019

Deterministic Graph Cuts in Subquadratic Time: Sparse, Balanced, and k-Vertex

We study deterministic algorithms for computing graph cuts, with focus on two fundamental problems: balanced sparse cut and $k$-vertex connectivity for small $k$ ($k=O(\polylog n)$). Both problems can be solved in near-linear time with randomized algorithms, but their previous deterministic counterparts take at least quadratic time. In this paper, we break this bound for both problems. Interestingly, achieving this for one problem crucially relies on doing so for the other. In particular, via a divide-and-conquer argument, a variant of the cut-matching game by [Khandekar et al.`07], and the local vertex connectivity algorithm of [Nanongkai et al. STOC'19], we give a subquadratic time algorithm for $k$-vertex connectivity using a subquadratic time algorithm for computing balanced sparse cuts on sparse graphs. To achieve the latter, we improve the previously best $mn$ bound for approximating balanced sparse cut for the whole range of $m$. This starts from (1) breaking the $n^3$ barrier on dense graphs to $n^{ω+ o(1)}$ (where $ω< 2.372$) using the the PageRank matrix, but without explicitly sweeping to find sparse cuts; to (2) getting the $\tilde O(m^{1.58})$ bound by combining the $J$-trees by [Madry FOCS `10] with the $n^{ω+ o(1)}$ bound above, and finally; to (3) getting the $m^{1.5 + o(1)}$ bound by recursively invoking the second bound in conjunction with expander-based graph sparsification. Interestingly, our final $m^{1.5 + o(1)}$ bound lands at a natural stopping point in the sense that polynomially breaking it would lead to a breakthrough for the dynamic connectivity problem.

cs.DS↗

arXiv2019

Dynamic Approximate Shortest Paths and Beyond: Subquadratic and Worst-Case Update Time

Consider the following distance query for an $n$-node graph $G$ undergoing edge insertions and deletions: given two sets of nodes $I$ and $J$, return the distances between every pair of nodes in $I\times J$. This query is rather general and captures several versions of the dynamic shortest paths problem. In this paper, we develop an efficient $(1+ε)$-approximation algorithm for this query using fast matrix multiplication. Our algorithm leads to answers for some open problems for Single-Source and All-Pairs Shortest Paths (SSSP and APSP), as well as for Diameter, Radius, and Eccentricities. Below are some highlights. Note that all our algorithms guarantee worst-case update time and are randomized (Monte Carlo), but do not need the oblivious adversary assumption. Subquadratic update time for SSSP, Diameter, Centralities, ect.: When we want to maintain distances from a single node explicitly (without queries), a fundamental question is to beat trivially calling Dijkstra's static algorithm after each update, taking $Θ(n^2)$ update time on dense graphs. It was known to be improbable for exact algorithms and for combinatorial any-approximation algorithms to polynomially beat the $Ω(n^2)$ bound (under some conjectures) [Roditty, Zwick, ESA'04; Abboud, V. Williams, FOCS'14]. Our algorithm with $I=\{s\}$ and $J=V(G)$ implies a $(1+ε)$-approximation algorithm for this, guaranteeing $\tilde O(n^{1.823}/ε^2)$ worst-case update time for directed graphs with positive real weights in $[1, W]$. With ideas from [Roditty, V. Williams, STOC'13], we also obtain the first subquadratic worst-case update time for $(5/3+ε)$-approximating the eccentricities and $(1.5+ε)$-approximating the diameter and radius for unweighted graphs (with small additive errors). [...]

cs.DS↗

arXiv2019

A New Deterministic Algorithm for Dynamic Set Cover

We present a deterministic dynamic algorithm for maintaining a $(1+ε)f$-approximate minimum cost set cover with $O(f\log(Cn)/ε^2)$ amortized update time, when the input set system is undergoing element insertions and deletions. Here, $n$ denotes the number of elements, each element appears in at most $f$ sets, and the cost of each set lies in the range $[1/C, 1]$. Our result, together with that of Gupta et al. [STOC`17], implies that there is a deterministic algorithm for this problem with $O(f\log(Cn))$ amortized update time and $O(\min(\log n, f))$-approximation ratio, which nearly matches the polynomial-time hardness of approximation for minimum set cover in the static setting. Our update time is only $O(\log (Cn))$ away from a trivial lower bound. Prior to our work, the previous best approximation ratio guaranteed by deterministic algorithms was $O(f^2)$, which was due to Bhattacharya et al. [ICALP`15]. In contrast, the only result that guaranteed $O(f)$-approximation was obtained very recently by Abboud et al. [STOC`19], who designed a dynamic algorithm with $(1+ε)f$-approximation ratio and $O(f^2 \log n/ε)$ amortized update time. Besides the extra $O(f)$ factor in the update time compared to our and Gupta et al.'s results, the Abboud et al. algorithm is randomized, and works only when the adversary is oblivious and the sets are unweighted (each set has the same cost). We achieve our result via the primal-dual approach, by maintaining a fractional packing solution as a dual certificate. Unlike previous primal-dual algorithms that try to satisfy some local constraints for individual sets at all time, our algorithm basically waits until the dual solution changes significantly globally, and fixes the solution only where the fix is needed.

cs.DS↗

arXiv2019

A Faster Distributed Single-Source Shortest Paths Algorithm

We devise new algorithms for the single-source shortest paths (SSSP) problem with non-negative edge weights in the CONGEST model of distributed computing. While close-to-optimal solutions, in terms of the number of rounds spent by the algorithm, have recently been developed for computing SSSP approximately, the fastest known exact algorithms are still far away from matching the lower bound of $ \tilde Ω(\sqrt{n} + D) $ rounds by Peleg and Rubinovich [SIAM Journal on Computing 2000], where $ n $ is the number of nodes in the network and $ D $ is its diameter. The state of the art is Elkin's randomized algorithm [STOC 2017] that performs $ \tilde O(n^{2/3} D^{1/3} + n^{5/6}) $ rounds. We significantly improve upon this upper bound with our two new randomized algorithms for polynomially bounded integer edge weights, the first performing $ \tilde O (\sqrt{n D}) $ rounds and the second performing $ \tilde O (\sqrt{n} D^{1/4} + n^{3/5} + D) $ rounds. Our bounds also compare favorably to the independent result by Ghaffari and Li [STOC 2018]. As side results, we obtain a $ (1 + ε) $-approximation $ \tilde O ((\sqrt{n} D^{1/4} + D) / ε) $-round algorithm for directed SSSP and a new work/depth trade-off for exact SSSP on directed graphs in the PRAM model.

cs.DC↗

arXiv2019

Computing and Testing Small Vertex Connectivity in Near-Linear Time and Queries

We present a new, simple, algorithm for the local vertex connectivity problem (LocalVC) introduced by Nanongkai~et~al. [STOC'19]. Roughly, given an undirected unweighted graph $G$, a seed vertex $x$, a target volume $ν$, and a target separator size $k$, the goal of LocalVC is to remove $k$ vertices `near' $x$ (in terms of $ν$) to disconnect the graph in `local time', which depends only on parameters $ν$ and $k$. In this paper, we present a simple randomized algorithm with running time $O(νk^2)$ and correctness probability $2/3$. Plugging our new localVC algorithm in the generic framework of Nanongkai~et~al. immediately lead to a randomized $\tilde O(m+nk^3)$-time algorithm for the classic $k$-vertex connectivity problem on undirected graphs. ($\tilde O(T)$ hides $\text{polylog}(T)$.) This is the first near-linear time algorithm for any $4\leq k \leq \text{polylog} n$. Previous fastest algorithm for small $k$ takes $\tilde O(m+n^{4/3}k^{7/3})$ time [Nanongkai~et~al., STOC'19]. This work is inspired by the algorithm of Chechik~et~al. [SODA'17] for computing the maximal $k$-edge connected subgraphs. Forster and Yang [arXiv'19] has independently developed local algorithms similar to ours, and showed that they lead to an $\tilde O(k^3/ε)$ bound for testing $k$-edge and -vertex connectivity, resolving two long-standing open problems in property testing since the work of Goldreich and Ron [STOC'97] and Orenstein and Ron [Theor. Comput. Sci.'11]. Inspired by this, we use local approximation algorithms to obtain bounds that are near-linear in $k$, namely $\tilde O(k/ε)$ and $\tilde O(k/ε^2)$ for the bounded and unbounded degree cases, respectively. For testing $k$-edge connectivity for simple graphs, the bound can be improved to $\tilde O(\min(k/ε, 1/ε^2))$.

cs.DS↗

arXiv2019

Dynamic Matrix Inverse: Improved Algorithms and Matching Conditional Lower Bounds

The dynamic matrix inverse problem is to maintain the inverse of a matrix undergoing element and column updates. It is the main subroutine behind the best algorithms for many dynamic problems whose complexity is not yet well-understood, such as maintaining the largest eigenvalue, rank and determinant of a matrix and maintaining reachability, distances, maximum matching size, and $k$-paths/cycles in a graph. Understanding the complexity of dynamic matrix inverse is a key to understand these problems. In this paper, we present (i) improved algorithms for dynamic matrix inverse and their extensions to some incremental/look-ahead variants, and (ii) variants of the Online Matrix-Vector conjecture [Henzinger et al. STOC'15] that, if true, imply that these algorithms are tight. Our algorithms automatically lead to faster dynamic algorithms for the aforementioned problems, some of which are also tight under our conjectures, e.g. reachability and maximum matching size (closing the gaps for these two problems was in fact asked by Abboud and V. Williams [FOCS'14]). Prior best bounds for most of these problems date back to more than a decade ago [Sankowski FOCS'04, COCOON'05, SODA'07; Kavitha FSTTCS'08; Mucha and Sankowski Algorithmica'10; Bosek et al. FOCS'14]. Our improvements stem mostly from the ability to use fast matrix multiplication ``one more time'', to maintain a certain transformation matrix which could be maintained only combinatorially previously (i.e. without fast matrix multiplication). Oddly, unlike other dynamic problems where this approach, once successful, could be repeated several times (``bootstrapping''), our conjectures imply that this is not the case for dynamic matrix inverse and some related problems. However, when a small additional ``look-ahead'' information is provided we can perform such repetition to drive the bounds down further.

cs.DS↗