Worst-case Update Time Research Articles

Dynamic Matching with Better-than-2 Approximation in Polylogarithmic Update Time

We present dynamic algorithms with polylogarithmic update time for estimating the size of the maximum matching of a graph undergoing edge insertions and deletions with approximation ratio strictly better than 2 . Specifically, we obtain a \(1+\tfrac{1}{\sqrt {2}}+\epsilon \approx 1.707+\epsilon\) approximation in bipartite graphs and a \(1.973+\epsilon\) approximation in general graphs. We thus answer in the affirmative the value version of the major open question repeatedly asked in the dynamic graph algorithms literature. Our randomized algorithms’ approximation and worst-case update time bounds both hold w.h.p. against adaptive adversaries. Our algorithms are based on simulating new two-pass streaming matching algorithms in the dynamic setting. Our key new idea is to invoke the recent sublinear-time matching algorithm of Behnezhad (FOCS’21) in a white-box manner to efficiently simulate the second pass of our streaming algorithms, while bypassing the well-known vertex-update barrier.

Deterministic Dynamic Matching in Worst-Case Update Time

We present deterministic algorithms for maintaining a (3/2 + epsilon ) and (2 + epsilon )-approximate maximum matching in a fully dynamic graph with worst-case update times {hat{O}}(sqrt{n}) and {tilde{O}}(1) respectively. The fastest known deterministic worst-case update time algorithms for achieving approximation ratio (2 - delta ) (for any delta > 0) and (2 + epsilon ) were both shown by Roghani et al. (Beating the folklore algorithm for dynamic matching, 2021) with update times O(n^{3/4}) and O_epsilon (sqrt{n}) respectively. We close the gap between worst-case and amortized algorithms for the two approximation ratios as the best deterministic amortized update times for the problem are O_epsilon (sqrt{n}) and {tilde{O}}(1) which were shown in Bernstein and Stein (in: Proceedings of the twenty-seventh annual ACM-SIAM symposium on discrete algorithms, 2016) and Bhattacharya and Kiss (in: 48th international colloquium on automata, languages, and programming, ICALP 2021, 12–16 July, Glasgow, 2021) respectively. The algorithm achieving (3/2 + epsilon ) approximation builds on the EDCS concept introduced by the influential paper of Bernstein and Stein (in: International colloquium on automata, languages, and programming, Springer, Berlin, 2015). Say that H is a (alpha , delta )-approximate matching sparsifier if at all times H satisfies that mu (H) cdot alpha + delta cdot n ge mu (G) (define (alpha , delta )-approximation similarly for matchings). We show how to maintain a locally damaged version of the EDCS which is a (3/2 + epsilon , delta )-approximate matching sparsifier. We further show how to reduce the maintenance of an alpha -approximate maximum matching to the maintenance of an (alpha , delta )-approximate maximum matching building based on an observation of Assadi et al. (in: Proceedings of the twenty-seventh annual (ACM-SIAM) symposium on discrete algorithms, (SODA) 2016, Arlington, VA, USA, January 10–12, 2016). Our reduction requires an update time blow-up of {hat{O}}(1) or {tilde{O}}(1) and is deterministic or randomized against an adaptive adversary respectively. To achieve (2 + epsilon )-approximation we improve on the update time guarantee of an algorithm of Bhattacharya and Kiss (in: 48th International colloquium on automata, languages, and programming, ICALP 2021, 12–16 July, Glasgow, 2021). In order to achieve both results we explicitly state a method implicitly used in Nanongkai and Saranurak (in: Proceedings of the twenty-seventh annual ACM symposium on theory of computing, 2017) and Bernstein et al. (Fully-dynamic graph sparsifiers against an adaptive adversary, 2020) which allows to transform dynamic algorithms capable of processing the input in batches to a dynamic algorithms with worst-case update time.

Streaming Quantiles Algorithms with Small Space and Update Time

Approximating quantiles and distributions over streaming data has been studied for roughly two decades now. Recently, Karnin, Lang, and Liberty proposed the first asymptotically optimal algorithm for doing so. This manuscript complements their theoretical result by providing a practical variants of their algorithm with improved constants. For a given sketch size, our techniques provably reduce the upper bound on the sketch error by a factor of two. These improvements are verified experimentally. Our modified quantile sketch improves the latency as well by reducing the worst-case update time from O(1ε) down to O(log1ε).

Dynamic Kernels for Hitting Sets and Set Packing

Computing small kernels for the hitting set problem is a well-studied computational problem where we are given a hypergraph with n vertices and m hyperedges, each of size d for some small constant d, and a parameter k. The task is to compute a new hypergraph, called a kernel, whose size is polynomial with respect to the parameter k and which has a size-k hitting set if, and only if, the original hypergraph has one. State-of-the-art algorithms compute kernels of size k^d (which is a polynomial as d is a constant), and they do so in time mcdot 2^d {text {poly}}(d) for a small polynomial {text {poly}}(d) (which is linear in the hypergraph size for d fixed). We generalize this task to the dynamic setting where hyperedges may continuously be added or deleted and one constantly has to keep track of a size-k^d kernel. This paper presents a deterministic solution with worst-case time 3^d {text {poly}}(d) for updating the kernel upon inserts and time 5^d {text {poly}}(d) for updates upon deletions. These bounds nearly match the time 2^d {text {poly}}(d) needed by the best static algorithm per hyperedge. Let us stress that for constant d our algorithm maintains a hitting set kernel with constant, deterministic, worst-case update time that is independent of n, m, and the parameter k. As a consequence, we also get a deterministic dynamic algorithm for keeping track of size-k hitting sets in d-hypergraphs with update times O(1) and query times O(c^k) where c = d - 1 + O(1/d) equals the best base known for the static setting.

A Deamortization Approach for Dynamic Spanner and Dynamic Maximal Matching

Many dynamic graph algorithms have an amortized update time, rather than a stronger worst-case guarantee. But amortized data structures are not suitable for real-time systems, where each individual operation has to be executed quickly. For this reason, there exist many recent randomized results that aim to provide a guarantee stronger than amortized expected. The strongest possible guarantee for a randomized algorithm is that it is always correct (Las Vegas) and has high-probability worst-case update time, which gives a bound on the time for each individual operation that holds with high probability. In this article, we present the first polylogarithmic high-probability worst-case time bounds for the dynamic spanner and the dynamic maximal matching problem. (1) For dynamic spanner, the only known o ( n ) worst-case bounds were O ( n 3/4 ) high-probability worst-case update time for maintaining a 3-spanner and O ( n 5/9 ) for maintaining a 5-spanner. We give a O (1) k log 3 ( n ) high-probability worst-case time bound for maintaining a ( 2k-1 )-spanner, which yields the first worst-case polylog update time for all constant k . (All the results above maintain the optimal tradeoff of stretch 2k-1 and Õ( n 1+1/k ) edges.) (2) For dynamic maximal matching, or dynamic 2-approximate maximum matching, no algorithm with o(n) worst-case time bound was known and we present an algorithm with O (log 5 ( n )) high-probability worst-case time; similar worst-case bounds existed only for maintaining a matching that was (2+ϵ)-approximate, and hence not maximal. Our results are achieved using a new approach for converting amortized guarantees to worst-case ones for randomized data structures by going through a third type of guarantee, which is a middle ground between the two above: An algorithm is said to have worst-case expected update time ɑ if for every update σ, the expected time to process σ is at most ɑ. Although stronger than amortized expected, the worst-case expected guarantee does not resolve the fundamental problem of amortization: A worst-case expected update time of O(1) still allows for the possibility that every 1/ f(n) updates requires ϴ ( f(n) ) time to process, for arbitrarily high f(n) . In this article, we present a black-box reduction that converts any data structure with worst-case expected update time into one with a high-probability worst-case update time: The query time remains the same, while the update time increases by a factor of O (log 2(n) ). Thus, we achieve our results in two steps: (1) First, we show how to convert existing dynamic graph algorithms with amortized expected polylogarithmic running times into algorithms with worst-case expected polylogarithmic running times. (2) Then, we use our black-box reduction to achieve the polylogarithmic high-probability worst-case time bound. All our algorithms are Las-Vegas-type algorithms.

Single-source shortest paths and strong connectivity in dynamic planar graphs

We give a fully dynamic single-source shortest paths data structure for planar weighted digraphs with O˜(n4/5) worst-case update time and O(log2⁡n) query time. Here, a single update can either change the graph by inserting or deleting an edge, or reset the source s of interest. All known non-trivial planarity-exploiting exact dynamic single-source shortest paths algorithms to date had polynomial query time. We then extend our approach, obtaining a data structure that can maintain a planar digraph under edge insertions and deletions, and is capable of returning the identifier of the strongly connected component of any query vertex. The worst-case update and query time bounds are the same as for our single-source distance oracle. To the best of our knowledge, this is the first fully dynamic strong-connectivity algorithm achieving both sublinear update time and polylogarithmic query time for an important class of digraphs.

Constant-time dynamic weight approximation for minimum spanning forest

We give two fully dynamic algorithms that maintain a (1+ε)-approximation of the weight M of a minimum spanning forest (MSF) of an n-node graph G with edges weights in [1,W], for any ε>0. (1) Our deterministic algorithm takes O(W2log⁡W/ε3)worst-case update time, which is O(1) if both W and ε are constants. (2) Our randomized (Monte-Carlo style) algorithm works with high probability and runs in worst-caseO(log⁡W/ε4) update time if W=O((m⁎)1/6/log2/3⁡n), where m⁎ is the minimum number of edges in the graph throughout all the updates. It works even against an adaptive adversary.We complement our algorithmic results with two cell-probe lower bounds for dynamically maintaining an approximation of the weight of an MSF of a graph.

Dynamic Clustering to Minimize the Sum of Radii

In this paper, we study the problem of opening centers to cluster a set of clients in a metric space so as to minimize the sum of the costs of the centers and of the cluster radii, in a dynamic environment where clients arrive and depart, and the solution must be updated efficiently while remaining competitive with respect to the current optimal solution. We call this dynamic sum-of-radii clustering problem. We present a data structure that maintains a solution whose cost is within a constant factor of the cost of an optimal solution in metric spaces with bounded doubling dimension and whose worst-case update time is logarithmic in the parameters of the problem.

Maximum Matching on Trees in the Online Preemptive and the Incremental Graph Models

We study the Maximum Cardinality Matching (MCM) and the Maximum Weight Matching (MWM) problems, on trees and on some special classes of graphs, in the online preemptive and the incremental graph models. In the Online Preemptive model, the edges of a graph are revealed one by one and the algorithm is required to always maintain a valid matching. On seeing an edge, the algorithm has to either accept or reject the edge. If accepted, then the adjacent edges are discarded, and all rejections are permanent. In this model, the complexity of the problems is settled for deterministic algorithms (McGregor, in: Proceedings of the 8th international workshop on approximation, randomization and combinatorial optimization problems, and proceedings of the 9th international conference on randomization and computation: algorithms and techniques, APPROX’05/RANDOM’05, Springer, Berlin, pp. 170–181, 2005; Varadaraja, in: Automata, languages and programming: 38th international colloquium, ICALP 2011, Zurich, Switzerland, proceedings, part I, pp. 379–390, 2011. https://doi.org/10.1007/978-3-642-22006-7_32 ). Epstein et al. (in: 30th international symposium on theoretical aspects of computer science, STACS 2013, Kiel, Germany, pp. 389–399, 2013. https://doi.org/10.4230/LIPIcs.STACS.2013.389 ) gave a 5.356-competitive randomized algorithm for MWM, and also proved a lower bound on the competitive ratio of $$(1+\ln 2) \approx 1.693$$ for MCM. The same lower bound applies for MWM. In the Incremental Graph model, at each step an edge is added to the graph, and the algorithm is supposed to quickly update its current matching. Gupta (in: 34th international conference on foundation of software technology and theoretical computer science, FSTTCS 2014, 15–17 Dec 2014, New Delhi, India, pp. 227–239, 2014. https://doi.org/10.4230/LIPIcs.FSTTCS.2014.227 ) proved that for any $$\epsilon \le 1/2$$ , there exists an algorithm that maintains a $$(1+\epsilon )$$ -approximate MCM for an incremental bipartite graph in an amortized update time of $$O\left( \frac{\log ^2 n}{\epsilon ^4}\right) $$ . No $$(2-\epsilon )$$ -approximation algorithm with a worst case update time of O(1) is known in this model, even for special classes of graphs. In this paper we show that some of the results can be improved for trees, and for some special classes of graphs. In the online preemptive model, we present a 64 / 33-competitive randomized algorithm (which uses only two bits of randomness) for MCM on trees. Inspired by the above mentioned algorithm for MCM, we present the main result of the paper, a randomized algorithm for MCM with a worst case update time of O(1), in the incremental graph model, which is 3 / 2-approximate (in expectation) on trees, and 1.8-approximate (in expectation) on general graphs with maximum degree 3. Note that this algorithm works only against an oblivious adversary. We derandomize this algorithm, and give a $$(3/2+\epsilon )$$ -approximate deterministic algorithm for MCM on trees, with an amortized update time of $$O(1/\epsilon )$$ . We also present a minor result for MWM in the online preemptive model, a 3-competitive randomized algorithm (that uses only O(1) bits of randomness) on growing trees (where the input revealed upto any stage is always a tree, i.e. a new edge never connects two disconnected trees).

Red–black trees with constant update time

We show how a few modifications to the red–black trees allow for constant worst-case update time (once the position of the element to be inserted or deleted is known). The resulting structure is based on relaxing some of the properties of the red–black trees while guaranteeing that the height remains logarithmic with respect to the number of nodes. Compared to the other search trees with constant worst-case update time, our tree is the first to provide a tailored deletion procedure without using the global rebuilding technique. In addition, our procedures are simpler and allow for an easier proof of correctness than those alternative trees.

Stream sampling over windows with worst-case optimality and $$\ell $$ ℓ -overlap independence

Sampling provides fundamental support to numerous applications that cannot afford to materialize all the objects arriving at a rapid speed. Existing stream sampling algorithms guarantee small space and query overhead, but all require worst-case update time proportional to the number of samples. This creates a performance issue when a large sample set is required. In this paper, we propose a new sampling algorithm that is optimal simultaneously in all the three aspects: space, query time, and update time. In particular, the algorithm handles an update in O(1) worst-case time with a very small hidden constant. Our algorithm also ensures a strong independence guarantee: the sample sets of all the queries are mutually independent as long as the overlap between two query windows is small.

Query-Optimal Partially Persistent B-Trees with Constant Worst-Case Update Time

In this paper we present the first data structure for partially persistent B-trees with constant worst-case update time, where deletions are handled in a symmetrical to insertions manner. Our structure matches the query times of optimal partially persistent B-trees that do not support constant update time thus, we have managed to reduce the worst-case update time to a constant, without a penalty in the query times. The new data structure is produced by mixing two other data structures, (a) the partially persistent B-tree and (b) the balanced search tree with constant worst-case update time.

Compressing IP Forwarding Tables with Small Bounded Update Time

With the fast development of the Internet, the size of Forwarding Information Base (FIB) maintained at backbone routers is experiencing an exponential growth, making the storage support and lookup process of FIBs a severe challenge. One effective way to address the challenge is FIB compression, and various solutions have been proposed in the literature. The main shortcoming of FIB compression is the overhead of updating the compressed FIB when routing update messages arrive. Only when the update time of FIB compression algorithms is small bounded can the probability of packet loss incurred by FIB compression operations during update be completely avoided. However, no prior FIB compression algorithm can achieve small bounded worst case update time, and hence a mature solution with complete avoidance of packet loss is still yet to be identified. To address this issue, we propose the Unite and Split (US) compression algorithm to enable fast update with controlled worst case update time. Further, we use the US algorithm to improve the performance of a number of classic software and hardware lookup algorithms. Simulation results show that the average update speed of the US algorithm is a little faster than that of the binary trie without any compression, while prior compression algorithms inevitably seriously degrade the update performance. After applying the US algorithm, the evaluated lookup algorithms exhibit significantly smaller on-chip memory consumption with little additional update overhead.

Simple Deterministic Algorithms for Fully Dynamic Maximal Matching

A maximal matching can be maintained in fully dynamic (supporting both addition and deletion of edges) n -vertex graphs using a trivial deterministic algorithm with a worst-case update time of O ( n ). No deterministic algorithm that outperforms the naïve O ( n ) one was reported up to this date. The only progress in this direction is due to Ivković and Lloyd, who in 1993 devised a deterministic algorithm with an amortized update time of O (( n + m ) √2/2 ), where m is the number of edges. In this article, we show the first deterministic fully dynamic algorithm that outperforms the trivial one. Specifically, we provide a deterministic worst-case update time of O (√ m ). Moreover, our algorithm maintains a matching, which in fact is a 3/2-approximate maximum cardinality matching (MCM). We remark that no fully dynamic algorithm for maintaining (2 − ϵ)-approximate MCM improving upon the naïve O ( n ) was known prior to this work, even allowing amortized time bounds and randomization. For low arboricity graphs (e.g., planar graphs and graphs excluding fixed minors), we devise another simple deterministic algorithm with sublogarithmic update time. Specifically, it maintains a fully dynamic maximal matching with amortized update time of O (log n /log log n ). This result addresses an open question of Onak and Rubinfeld [2010]. We also show a deterministic algorithm with optimal space usage, which for arbitrary graphs maintains a maximal matching in amortized O (√ m ) time and uses only O ( n + m ) space.

On Range Searching in the Group Model and Combinatorial Discrepancy

In this paper we establish an intimate connection between dynamic range searching in the group model and combinatorial discrepancy. Our result states that, for a broad class of range searching data structures (including all known upper bounds), it must hold that $t_u t_q=\Omega(\mbox{disc}^2)$, where $t_u$ is the worst case update time, $t_q$ is the worst case query time, and disc is the combinatorial discrepancy of the range searching problem in question. This relation immediately implies a whole range of exceptionally high and near-tight lower bounds for all of the basic range searching problems. We list a few of them in the following: (1) For $d$-dimensional halfspace range searching, we get a lower bound of $t_u t_q=\Omega(n^{1-1/d})$. This comes within an lg lg $n$ factor of the best known upper bound. (2) For orthogonal range searching, we get a lower bound of $t_u t_q=\Omega(\mbox{lg}^{d-1}n)$. (3) For ball range searching, we get a lower bound of $t_u t_q=\Omega(n^{1-1/d})$. We note that the previ...

Partially persistent B-trees with constant worst-case update time

We present two solutions for achieving a partially persistent B-tree with a worst case constant update time, in the case that the position of the update is given. The motivation for this work came from the observation that a known, general approach, which reduces the update cost of partially persistent data structures to a constant, has an inherent weakness concerning partially persistent B-trees, because it creates big nodes that cannot be retrieved from secondary memory in a constant time. Due to this, the I/O complexity of the resulting partially persistent B-tree is affected. Thus, we attack this specific problem, i.e. we do not develop a general approach for all partially persistent data structures. For our objectives, we add partial persistence to an ephemeral B-tree with constant worst case update time, by applying two known general methods, the fat-node and the node-copying method, that transform an ephemeral data structure into a partially persistent. The solution based on node-copying is asymptotically optimal.

A SIMPLE BALANCED SEARCH TREE WITH O(1) WORST-CASE UPDATE TIME

In this paper we show how a slight modification of (a, 2b)-trees allows us to perform member and neighbor queries in O( log n) time and updates in O(1) worst-case time (once the position of the inserted or deleted key is known). Our data structure is quite natural and much simpler than previous worst-case optimal solutions. It is based on two techniques : 1) bucketing, i.e., storing an ordered list of 2 log n keys in each leaf of an (a, 2b) tree, and 2) preventive splitting, i.e., splitting nodes before they can grow bigger than allowed. If only insertions are allowed, it can also be used as a finger search tree with O( log * n) worst-case update time.

Lower Bounds for Dynamic Transitive Closure, Planar Point Location, and Parentheses Matching

We give a number of new lower bounds in the cell probe model<br />with logarithmic cell size, which entails the same bounds on the random access computer with logarithmic word size and unit cost operations. We study the signed prefix sum problem: given a string of length n of zeroes and signed ones, compute the sum of its ith prefix during updates. We show a<br />lower bound of Omega(log n/log log n) time per operations, even if the prefix sums are bounded by log n/log log n during all updates. We also show that if the update time is bounded by the product of the worst-case update time and the<br />answer to the query, then the update time must be Omega(sqrt(log n/ log log n)).<br /> These results allow us to prove lower bounds for a variety of seemingly unrelated<br />dynamic problems. We give a lower bound for the dynamic planar point location in monotone subdivisions of <br />Omega(log n/ log log n) per operation. We give<br />a lower bound for the dynamic transitive closure problem on upward planar graphs with one source and one sink of <br />Omega(log n/(log logn)^2) per operation. We give a lower bound of Omega(sqrt(log n/log log n)) for the dynamic membership problem of any Dyck language with two or more letters. This implies the same<br />lower bound for the dynamic word problem for the free group with k generators. We also give lower bounds for the dynamic prefix majority and prefix equality problems.

A constant update time finger search tree

Levcopolous and Overmars ( Acta Inform., 26 (1988) 269-277) describe a search tree with O(1) worst-case update time, i.e., the time to insert or delete a key is O(1) in the worst case if the position of the key is known. Their data structure does not support fingers, pointers to specific keys such that access and update operations in the vicinity of a finger are especially efficient. We modify their data structure to support fingers while still maintaining O(1) worst-case update time, partially improving upon an earlier result of Harel (University of California, Davis, TR #154, 1980) who achieved O(log * n) worst-case update time in a search tree with fingers. Our data structure uses the random-access machine (RAM) model with unit-cost measure and logarithmic word size; the data structures of Levcopolous and Overmars and Harel use the weaker pointer machine model.

New Results on Dynamic Planar Point Location

A point location scheme is presented for a dynamic planar subdivision whose underlying graph is only required to be connected. The operations supported include: reporting the name of the region containing a query point, inserting/deleting an edge, and inserting/deleting/moving a degree-2 vertex. The scheme uses $O(n)$ space, has a worst-case query time of $O(\log ^2 n)$, and a worst-case update time of $O(\log n)$, where n is the number of vertices currently in the subdivision. Insertion (respectively, deletion) of an arbitrary k-edge chain inside a region can be performed in $O(k\log (n + k))$ (respectively, $O(k\log n)$) time in worst-case. The scheme outperforms the solutions given in works by Fries, Mehlhorn, and Naeher and by Overmars and also handles more general subdivisions than the schemes given in works by Preparata and Tamassia. The result is based on a new solution to a dynamic visibility problem for a set of line segments in the plane that are nonintersecting, except possibly at endpoints. Th...