We prove \Omega\Gamma p log log n) lower bounds on the random access machine complexity of several dynamic, partially dynamic and static data structure problems, including the union-split-find problem, dynamic prefix problems and onedimensional range query problems. The proof techniques include a general technique using perfect hashing for reducing static data structure problems (with a restriction of the size of the structure) into partially dynamic data structure problems (with no such restriction), thus providing a way to transfer lower bounds. We use a generalization of a method due to Ajtai for proving the lower bounds on the static problems, but describe the proof in terms of communication complexity, revealing a striking similarity to the proof used by Karchmer and Wigderson for proving lower bounds on the monotone circuit depth of connectivity. 1 Introduction and summary of results In this paper we give lower bounds for the complexity of implementing several dynamic and sta...

The incremental planarity testing problem is to perform the following operations on a biconnected planar graph G of at most n vertices: test if an edge can be added between two vertices while preserving planarity; add edges and vertices that preserve planarity. Let m be the total number of operations. We present fast data structures for this problem that can be used in conjunction with the previous algorithm of Di Battista and Tamassia to achieve an O(ff(m; n)) worst-case amortized time per test operation. If the graph is biconnected, a sequence of n additions can be performed in total time O(mff(m;n)) worst-case plus O(n) expected time. Our tree data structure is flexible and can answer in O(1) time queries about parents, roots, and nearest common ancestors while performing tree modifications such as inserting nodes, cutting edges, and merging or splitting nodes. If the graph is not biconnected then insertions of edges and vertices require O(log n) amortized expected time per operat...

We study several data-structures and operations that commonly arise in parallel implementations of logic programming languages. The main problems that arise in implementing such parallel systems are abstracted out and precisely stated. Upper and lower bounds are derived for several of these problems. We prove a lower bound of \Omega (log n) on the overhead incurred in implementing even a simplified version of or-parallelism. We prove that the aliasing problem in parallel logic programming is at least as hard as the union-find problem. We prove that an and-parallel implementation can be realized on an extended pointer machine with an O(1) overhead.

this paper we study the complexity of what we call the Temporal Precedence (T P) Problem on pointer machines. Intuitively, the problem is to manage the dynamic insertion of elements, with the ability of determining, given two elements, which one was inserted first. We are not aware of any study regarding the complexity of this problem on pointer machines.

Abstract. The disjoint-set data structure is used to maintain a collection of non-overlapping sets of elements from a finite universe. Algorithms that operate on this data structure are often referred to as Union-Find algorithms. They are used in numerous practical applications and are also available in several software libraries. This paper presents an extensive experimental study comparing the time required to execute 55 variations of Union-Find algorithms. The study includes all the classical algorithms, several recently suggested enhancements, and also different combinations and optimizations of these. Our results clearly show that a somewhat forgotten simple algorithm developed by Rem in 1976 is the fastest, in spite of the fact that its worst-case time complexity is inferior to that of the commonly accepted “best ” algorithms. Keywords: Union-Find, Disjoint Set, Experimental Algorithms. 1

Contents 1 Introduction 3 2 Models of computation 6 3 The Set Union Problem 9 4 The Worst--Case Time Complexity of a Single Operation 15 5 The Set Union Problem with Deunions 18 6 Split and the Set Union Problem on Intervals 22 7 The Set Union Problem with Unlimited Backtracking 26 1 Introduction An equivalence relation on a finite set S is a binary relation that is reflexive symmetric and transitive. That is, for s; t and u in S, we have that sRs, if sRt then tRs, and if sRt and tRu then sRu. Set S is partitioned by R into equivalence classes where each class cointains all and only the elements that obey R pairwise. Many computational problems involve representing, modifying and tracking the evolution of equivalenc

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 = Ω(tq), the problem is equivalent to the well-understood union–find problem: 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 ≥ n 1−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 n 1−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. 1