Fully Dynamic Maximal Matching in $O(\log n)$ Update Time

We consider the problem of maintaining an approximately maximum (fractional) matching and an approximately minimum vertex cover in a dynamic graph. Starting with the seminal paper by Onak and Rubinfeld [STOC 2010], this problem has received significant attention in recent years. There remains, however, a polynomial gap between the best known worst case update time and the best known amortised update time for this problem, even after allowing for randomisation. Specifically, Bernstein and Stein [ICALP 2015, SODA 2016] have the best known worst case update time. They present a deterministic data structure with approximation ratio $(3/2+\epsilon)$ and worst case update time $O(m^{1/4}/\epsilon^2)$, where $m$ is the number of edges in the graph. In recent past, Gupta and Peng [FOCS 2013] gave a deterministic data structure with approximation ratio $(1+\epsilon)$ and worst case update time $O(\sqrt{m}/\epsilon^2)$. No known randomised data structure beats the worst case update times of these two results. In contrast, the paper by Onak and Rubinfeld [STOC 2010] gave a randomised data structure with approximation ratio $O(1)$ and amortised update time $O(\log^2 n)$, where $n$ is the number of nodes in the graph. This was later improved by Baswana, Gupta and Sen [FOCS 2011] and Solomon [FOCS 2016], leading to a randomised date structure with approximation ratio $2$ and amortised update time $O(1)$. We bridge the polynomial gap between the worst case and amortised update times for this problem, without using any randomisation. We present a deterministic data structure with approximation ratio $(2+\epsilon)$ and worst case update time $O(\log^3 n)$, for all sufficiently small constants $\epsilon$.

For a graph G=(V,E), finding a set of disjoint edges that do not share any vertices is called a matching problem, and finding the maximum matching is a fundamental problem in the theory of distributed graph algorithms. Although local algorithms for the approximate maximum matching problem have been widely studied, exact algorithms has not been much studied. In fact, no exact maximum matching algorithm that is faster than the trivial upper bound of O(n^2) rounds is known for the general instance. In this paper, we propose a randomized O(s_{max}^{3/2}+log n)-round algorithm in the CONGEST model, where s_{\max} is the size of maximum matching. This is the first exact maximum matching algorithm in o(n^2) rounds for general instances in the CONGEST model. The key technical ingredient of our result is a distributed algorithms of finding an augmenting path in O(s_{\max}) rounds, which is based on a novel technique of constructing a sparse certificate of augmenting paths, which is a subgraph of the input graph preserving at least one augmenting path. To establish a highly parallel construction of sparse certificates, we also propose a new characterization of sparse certificates, which might also be of independent interest.

In 1999, Brodal and Fagerberg (BF) gave an algorithm for maintaining a low outdegree orientation of a dynamic uniformly sparse graph. Specifically, for a dynamic graph on n -vertices, with arboricity bounded by ɑ at all times, the BF algorithm supports edge updates in O (log n ) amortized update time, while keeping the maximum outdegree in the graph bounded by O ( ɑ ). Such an orientation provides a basic data structure for uniformly sparse graphs, which found applications to several dynamic graph algorithms, including adjacency queries and labeling schemes, maximal and approximate matching, approximate vertex cover, forest decomposition, and distance oracles. A significant weakness of the BF algorithm is the possible temporary blowup of the maximum outdegree, following edge insertions. Although BF eventually reduces all outdegrees to O ( ɑ ), some vertices may reach an outdegree of Ω( n ) during the process, and hence local memory usage at the vertices, which is an important quality measure in distributed systems, cannot be bounded. We show how to modify the BF algorithm to guarantee that the outdegrees of all vertices are bounded by O ( ɑ ) at all times, without hurting any of its other properties and present an efficient distributed implementation of the modified algorithm. This provides the first representation of distributed networks in which the local memory usage at all vertices is bounded by the arboricity (which is essentially the average degree of the densest subgraph) rather than the maximum degree. For settings where there is no strict limitation on the local memory, one may take the temporary outdegree blowup to the extreme and allow a permanent outdegree blowup. This allows us to address the second significant weakness of the BF algorithm—its inherently global nature: An insertion of an edge ( u,v ) may trigger changes in the orientations of edges that are arbitrarily far away from u and v . Such a non-local scheme may be prohibitively expensive in various practical applications. We suggest an alternative local scheme, which does not guarantee any outdegree bound on the vertices, yet is just as efficient as the BF scheme for some of the aforementioned applications. For example, we obtain a local dynamic algorithm for maintaining a maximal matching with sub-logarithmic update time in uniformly sparse networks, providing an exponential improvement over the state of the art in this context. We also present a distributed implementation of this scheme and some of its applications.

This paper studies the dynamic single-source shortest paths SSSP in Erdos-Renyi random graphs generated by Gn,i¾?p model. In 2014, Ding and Lin AAIM 2014, LNCS 8546, 197---207 first considered the dynamic SSSP in general digraphs with arbitrary positive weights, and devised a nontrivial local search algorithm named DSPI which takes at most $$On\cdot \max \{1, n\log n / m\}$$Oni¾?max{1,nlogn/m} expected update time to handle a single weight increase, where n is the number of nodes and m is the number of edges in the digraph. DSPI also works on undirected graphs. This paper analyzes the expected update time of DSPI dealing with edge weight increases or edge deletions in Erdos-Renyi a.k.a., Gn,i¾?p random graphs. For weighted Gn,i¾?p random graphs with arbitrary positive edge weights, DSPI takes at most $$OhT_s$$OhTs expected update time to deal with a single edge weight increase as well as $$Opn^2 hT_s$$Opn2hTs total update time, where $$hT_s$$hTs is the height of input SSSP tree $$T_s$$Ts. For Gn,i¾?p random graphs, DSPI takes $$O\ln n$$Olnn expected update time to handle a single edge deletion as well as $$Opn^2 \ln n$$Opn2lnn total update time when $$20\ln n / n \le p \sqrt{2\ln n / n}$$p>2lnn/n. Specifically, DSPI takes the least total update time of $$On\ln n hT_s$$OnlnnhTs for weighted Gn,i¾?p random graphs with $$p = c\ln n / n, c > 1$$p=clnn/n,c>1 as well as $$On^{3/2}\ln n^{1/2}$$On3/2lnn1/2 for Gn,i¾?p random graphs with $$p = c\sqrt{\ln n / n}, c > \sqrt{2}$$p=clnn/n,c>2.

We study \emph{dynamic} algorithms for maintaining spectral vertex sparsifiers of graphs with respect to a set of terminals $T$ of our choice. Such objects preserve pairwise resistances, solutions to systems of linear equations, and energy of electrical flows between the terminals in $T$. We give a data structure that supports insertions and deletions of edges, and terminal additions, all in sublinear time. Our result is then applied to the following problems. (1) A data structure for maintaining solutions to Laplacian systems $\mathbf{L} \mathbf{x} = \mathbf{b}$, where $\mathbf{L}$ is the Laplacian matrix and $\mathbf{b}$ is a demand vector. For a bounded degree, unweighted graph, we support modifications to both $\mathbf{L}$ and $\mathbf{b}$ while providing access to $\epsilon$-approximations to the energy of routing an electrical flow with demand $\mathbf{b}$, as well as query access to entries of a vector $\tilde{\mathbf{x}}$ such that $\left\lVert \tilde{\mathbf{x}}-\mathbf{L}^{\dagger} \mathbf{b} \right\rVert_{\mathbf{L}} \leq \epsilon \left\lVert \mathbf{L}^{\dagger} \mathbf{b} \right\rVert_{\mathbf{L}}$ in $\tilde{O}(n^{11/12}\epsilon^{-5})$ expected amortized update and query time. (2) A data structure for maintaining All-Pairs Effective Resistance. For an intermixed sequence of edge insertions, deletions, and resistance queries, our data structure returns $(1 \pm \epsilon)$-approximation to all the resistance queries against an oblivious adversary with high probability. Its expected amortized update and query times are $\tilde{O}(\min(m^{3/4},n^{5/6} \epsilon^{-2}) \epsilon^{-4})$ on an unweighted graph, and $\tilde{O}(n^{5/6}\epsilon^{-6})$ on weighted graphs. These results represent the first data structures for maintaining key primitives from the Laplacian paradigm for graph algorithms in sublinear time without assumptions on the underlying graph topologies.

We introduce a new framework for computing approximate maximum weight matchings. Our primary focus is on the fully dynamic setting, where there is a large gap between the guarantees of the best known algorithms for computing weighted and unweighted matchings. Indeed, almost all current weighted matching algorithms that reduce to the unweighted problem lose a factor of two in the approximation ratio. In contrast, in other sublinear models such as the distributed and streaming models, recent work has largely closed this weighted/unweighted gap. For bipartite graphs, we almost completely settle the gap with a general reduction that converts any algorithm for α-approximate unweighted matching to an algorithm for (1−)α-approximate weighted matching, while only increasing the update time by an O(logn) factor for constant . We also show that our framework leads to significant improvements for non-bipartite graphs, though not in the form of a universal reduction. In particular, we give two algorithms for weighted non-bipartite matching: 1. A randomized (Las Vegas) fully dynamic algorithm that maintains a (1/2−)-approximate maximum weight matching in worst-case update time O(polylog n) with high probability against an adaptive adversary. Our bounds are essentially the same as those of the unweighted algorithm of Wajc [STOC 2020]. 2. A deterministic fully dynamic algorithm that maintains a (2/3−)-approximate maximum weight matching in amortized update time O(m1/4). Our bounds are essentially the same as those of the unweighted algorithm of Bernstein and Stein [SODA 2016]. A key feature of our framework is that it uses existing algorithms for unweighted matching as black-boxes. As a result, our framework is simple and versatile. Moreover, our framework easily translates to other models, and we use it to derive new results for the weighted matching problem in streaming and communication complexity models.

Matching and packing problems have formed an important class of NP-hard problems. There have been a number of recently developed techniques for parameterized algorithms for these problems, including greedy localization, color-coding plus dynamic programming, and randomized divide-and-conquer. In this paper, we provide further theoretical study on the structures of these problems, and develop improved algorithmic methods that combine existing and new techniques to obtain improved algorithms for matching and packing problems. For the 3-set packing problem, we present a deterministic algorithm of time O *(4.613k), which significantly improves the previous best deterministic algorithm of time O *(12.83k). For the 3-d matching problem, we develop a new randomized algorithm of running time O *(2.323k) and a new deterministic algorithm of running time O *(2.773k). Our randomized algorithm improves the previous best randomized algorithm of running time O *(2.523k), and our deterministic algorithm significantly improves the previous best deterministic algorithm of running time O *(12.83k). Our results also imply improved algorithms for various triangle packing problems in graphs.KeywordsTime ComplexityDynamic ProgrammingMatch ProblemPacking ProblemDynamic Programming AlgorithmThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

We present O(loglog n) -round algorithms in the Massively Parallel Computation (MPC) model, with O (n) memory per machine, that compute a maximal independent set, a 1+e approximation of maximum matching, and a 2+eapproximation of minimum vertex cover, for any n-vertex graph and any constant \eps>0. These improve the state of the art as follows: Our MIS algorithm leads to a simple O(loglog Δ)-round MIS algorithm in the CONGESTED-CLIQUE model of distributed computing, which improves on the O (√log Δ )-round algorithm of Ghaffari [PODC'17]. Our O(loglog n)-round (1+e)-approximate maximum matching algorithm simplifies or improves on the following prior work: O(log^2log n)-round (1+\eps)-approximation algorithm of Czumaj et al. [STOC'18] and $O(loglog n)-round (1+e)-approximation algorithm of Assadi et al. [arXiv'17]. Our O(loglog n)-round (2+e)-approximate minimum vertex cover algorithm improves on an O(loglog n)-round O(1)-approximation of Assadi et al. [arXiv'17].

We consider the problem of maintaining a maximum matching in a convex bipartite graph G = (V,E) under a set of update operations which includes insertions and deletions of vertices and edges. It is not hard to show that it is impossible to maintain an explicit representation of a maximum matching in sub-linear time per operation, even in the amortized sense. Despite this difficulty, we develop a data structure which maintains the set of vertices that participate in a maximum matching in O(log2 |V|) amortized time per update and reports the status of a vertex (matched or unmatched) in constant worst-case time. Our structure can report the mate of a matched vertex in the maximum matching in worst-case O(min{k log2 |V |+log |V|, |V| log |V|}) time, where k is the number of update operations since the last query for the same pair of vertices was made. In addition, we give an O(√|V| log2 |V|)-time amortized bound for this pair query.

ABSTRACTI introduce a new graph‐theoretic property called abundant neighborhoods. This property is motivated by studying the thickness of economic markets. A vertex is, roughly, guaranteed to match if and only if it has an abundant neighborhood. This fact holds across numerous variants of two‐sided markets that are studied across the economics, operations research, and computer science literature. I introduce a new formalism to study these variants under a unifying framework, which I call matching rules, allowing us to study hitherto different types of markets (equivalently, graph matching problems) together. In particular, stable matchings, max‐weight matchings, and rank‐maximal matchings can be studied together as they are all surjective maximal matching rules. Lastly, the abundant neighborhood property can be used to study properties of maximal matchings: a vertex is matched in all maximal matchings if and only if it has an abundant neighborhood. With this observation, I develop a novel decomposition for studying maximal matchings. I use it to introduce a new integer programming formulation of the minimum maximal matching problem, which represents the worst‐case performance of a market. I show with experiments that using this formulation solves the problem for dense graphs with up to 500 vertices with 30%–50% less time than previous approaches from the literature and yields much tighter solutions for timed‐out instances.

Unit interval editing is fixed-parameter tractable

Given two vertices of interest (POIs) s and t on a spatial network, a distance (path) query returns the shortest network distance (shortest path) from s to t. This query has a variety of applications in practice and is a fundamental operation for many database and data mining algorithms. In this paper, we propose an efficient distance and path oracle on dynamic road networks using the randomization technique. Our oracle has a good performance in practice and remarkably, and at the same time, it has a favorable theoretical bound. Specifically, it has O(n log2 n) (resp. O(n log2n)) preprocessing time (resp. space) and O(log4n log log n) (resp. O(log4n log log n+l)) distance query time (resp. shortest path query time) as well as O(log3n) update time with high probability (w.h.p.), where n is the number of vertices in the spatial network and l is the number of edges on the shortest path. Our experiments show that the existing oracles suffer from a huge updating time that renders them impractical and our oracle enjoys a negligible updating time and meanwhile has comparable query time and indexing cost with the best existing oracle. © 2020 Association for Computing Machinery.

We consider the fine-grained complexity of sparse graph problems that currently have O(mn) time algorithms, where m is the number of edges and n is the number of vertices in the input graph. This class includes several important path problems on both directed and undirected graphs, including APSP, MWC (Minimum Weight Cycle), Radius, Eccentricities, BC (Betweenness Centrality), etc. We introduce the notion of a sparse reduction which preserves the sparsity of graphs, and we present near linear-time sparse reductions between various pairs of graph problems in the O(mn) class. There are many sub-cubic reductions between graph problems in the O(mn) class, but surprisingly few of these preserve sparsity. In the directed case, our results give a partial order on a large collection of problems in the O(mn) class (along with some equivalences), and many of our reductions are very nontrivial. In the undirected case we give two nontrivial sparse reductions: from MWC to APSP, and from unweighted ANSC (all nodes shortest cycles) to unweighted APSP. We develop a new ‘bit-sampling’ method for these sparse reductions on undirected graphs, which also gives rise to improved or simpler algorithms for cycle finding problems in undirected graphs. We formulate the the notion of MWC hardness, which is based on the assumption that a minimum weight cycle in a directed graph cannot be computed in time polynomially smaller than mn. Our sparse reductions for directed path problems in the O(mn) class establish that several problems in this class, including 2-SiSP (second simple shortest path), s-t Replacement Paths, Radius, Eccentricities and BC are MWC hard. Our sparse reductions give MWC hardness a status for the O(mn) class similar to 3SUM hardness for the quadratic class, since they show sub-mn hardness for a large collection of fundamental and well-studied graph problems that have maintained an O(mn) time bound for over half a century. We also identify Eccentricities and BC as key problems in the O(mn) class which are simultaneously MWC-hard, SETH-hard and k-DSH-hard, where SETH is the Strong Exponential Time Hypothesis, and k-DSH is the hypothesis that a dominating set of size k cannot be computed in time polynomially smaller than nk. Our framework using sparse reductions is very relevant to real-world graphs, which tend to be sparse and for which the O(mn) time algorithms are the ones typically used in practice, and not the O(n3) time algorithms.

A fundamental question is whether one can maintain a maximum independent set in polylogarithmic update time for a dynamic collection of geometric objects in Euclidean space. Already, for a set of intervals, it is known that no dynamic algorithm can maintain an exact maximum independent set in sublinear update time. Therefore, the typical objective is to explore the trade-off between update time and solution size. Substantial efforts have been made in recent years to understand this question for various families of geometric objects, such as intervals, hypercubes, hyperrectangles, and fat objects. We present the first fully dynamic approximation algorithm for disks of arbitrary radii in the plane that maintains a constant-factor approximate maximum independent set in polylogarithmic expected amortized update time. Moreover, for a fully dynamic set of n disks of unit radius in the plane, we show that a 12-approximate maximum independent set can be maintained with worst-case update time $$O(\log n)$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>O</mml:mi> <mml:mo>(</mml:mo> <mml:mo>log</mml:mo> <mml:mi>n</mml:mi> <mml:mo>)</mml:mo> </mml:mrow> </mml:math> , and optimal output-sensitive reporting. This result generalizes to fat objects of comparable sizes in any fixed dimension d , where the approximation ratio depends on the dimension and the fatness parameter. Further, we note that, even for a dynamic set of disks of unit radius in the plane, it is impossible to maintain $$O(1+\varepsilon )$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>O</mml:mi> <mml:mo>(</mml:mo> <mml:mn>1</mml:mn> <mml:mo>+</mml:mo> <mml:mi>ε</mml:mi> <mml:mo>)</mml:mo> </mml:mrow> </mml:math> -approximate maximum independent set in truly sublinear update time, under standard complexity assumptions. Our results build on two recent technical tools: (i) The MIX algorithm by Cardinal et al. (2021) that can smoothly transition from one independent set to another; hence it suffices to maintain a family of independent sets where the largest one is a constant-factor approximation of a maximum independent set. (ii) A dynamic nearest/farthest neighbor data structure for disks by Kaplan et al. (2020) and Liu (2022), which generalizes the dynamic convex hull data structure by Chan (2010), and allows us to quickly find a “replacement” disk (if any) when a disk in one of our independent sets is deleted.

In the fully dynamic maximal independent set (MIS) problem our goal is to maintain an MIS in a given graph G while edges are inserted and deleted from the graph. The first non-trivial algorithm for this problem was presented by Assadi, Onak, Schieber, and Solomon [STOC 2018] who obtained a deterministic fully dynamic MIS with O(m^3/4) update time. Later, this was independently improved by Du and Zhang and by Gupta and Khan [arXiv 2018] to O(m^2/3) update time^1 Du and Zhang [arXiv 2018] also presented a randomized algorithm against an oblivious adversary with O(√m) update time. The current state of art is by Assadi, Onak, Schieber, and Solomon [SODA 2019] who obtained randomized algorithms against oblivious adversary with O(√n) and O(m^1/3) update times. In this paper, we propose a dynamic randomized algorithm against oblivious adversary with expected worst-case update time of O(log^4n). As a direct corollary, one can apply the black-box reduction from a recent work by Bernstein, Forster, and Henzinger [SODA 2019] to achieve O(log^6n) worst-case update time with high probability. This is the first dynamic MIS algorithm with very fast update time of poly-log.