Worst-case Analysis of Set Union Algorithms
Journal of the ACM (JACM)
On the single-operation worst-case time complexity of the disjoint set union problem
SIAM Journal on Computing
The cell probe complexity of dynamic data structures
STOC '89 Proceedings of the twenty-first annual ACM symposium on Theory of computing
Lower bounds for the union-find and the split-find problem on pointer machines
Journal of Computer and System Sciences
Worst-case and amortised optimality in union-find (extended abstract)
STOC '99 Proceedings of the thirty-first annual ACM symposium on Theory of computing
New techniques for the union-find problem
SODA '90 Proceedings of the first annual ACM-SIAM symposium on Discrete algorithms
Efficiency of a Good But Not Linear Set Union Algorithm
Journal of the ACM (JACM)
Near-optimal fully-dynamic graph connectivity
STOC '00 Proceedings of the thirty-second annual ACM symposium on Theory of computing
Space/time trade-offs in hash coding with allowable errors
Communications of the ACM
Meldable heaps and boolean union-find
STOC '02 Proceedings of the thiry-fourth annual ACM symposium on Theory of computing
SODA '02 Proceedings of the thirteenth annual ACM-SIAM symposium on Discrete algorithms
Logarithmic Lower Bounds in the Cell-Probe Model
SIAM Journal on Computing
Succinct Data Structures for Retrieval and Approximate Membership (Extended Abstract)
ICALP '08 Proceedings of the 35th international colloquium on Automata, Languages and Programming, Part I
Union-find with constant time deletions
ICALP'05 Proceedings of the 32nd international conference on Automata, Languages and Programming
The cell probe complexity of dynamic range counting
STOC '12 Proceedings of the forty-fourth annual ACM symposium on Theory of computing
| Hi-index | 0.00 |
We present a new threshold phenomenon in data structure lower bounds where slightly reduced update times lead to exploding query times. Consider incremental connectivity, letting tu be the time to insert an edge and tq be the query time. For tu = Omega(tq), the problem is equivalent to the well-understood union-find problem: proc{InsertEdge}(s,t) can be implemented by Union(Find(s), Find(t)). This gives worst-case time tu = tq = O(lg n / lg lg n) and amortized tu = tq = O(α(n)). By contrast, we show that if tu = o(lg n / lg lg n), the query time explodes to tq ≥ n1-o(1). In other words, if the data structure doesn't have time to find the roots of each disjoint set (tree) during edge insertion, there is no effective way to organize the information! For amortized complexity, we demonstrate a new inverse-Ackermann type trade-off in the regime tu = o(tq). A similar lower bound is given for fully dynamic connectivity, where an update time of o(lg n) forces the query time to be n1-o(1). This lower bound allows for amortization and Las Vegas randomization, and comes close to the known O(lg n • (lg lg n)O(1)) upper bound.