Results 1  10
of
15
Design and Analysis of Data Structures for Dynamic Trees
, 2006
"... The dynamic trees problem is that of maintaining a forest that changes over time through edge insertions and deletions. We can associate data with vertices or edges and manipulate this data, individually or in bulk, with operations that deal with whole paths or trees. Efficient solutions to this pr ..."
Abstract

Cited by 5 (1 self)
 Add to MetaCart
The dynamic trees problem is that of maintaining a forest that changes over time through edge insertions and deletions. We can associate data with vertices or edges and manipulate this data, individually or in bulk, with operations that deal with whole paths or trees. Efficient solutions to this problem have numerous applications, particularly in algorithms for network flows and dynamic graphs in general. Several data structures capable of logarithmictime dynamic tree operations have been proposed. The first was Sleator and Tarjan’s STtree, which represents a partition of the tree into paths. Although reasonably fast in practice, adapting STtrees to different applications is nontrivial. Frederickson’s topology trees, Alstrup et al.’s top trees, and Acar et al.’s RCtrees are based on tree contractions: they progressively combine vertices or edges to obtain a hierarchical representation of the tree. This approach is more flexible in theory, but all known implementations assume the trees have bounded degree; arbitrary trees are supported only after ternarization. This thesis shows how these two approaches can be combined (with very little overhead) to produce a data structure that is at least as generic as any other, very easy to
Lower Bound Techniques for Data Structures
, 2008
"... We describe new techniques for proving lower bounds on datastructure problems, with the following broad consequences:
â¢ the first Î©(lgn) lower bound for any dynamic problem, improving on a bound that had been standing since 1989;
â¢ for static data structures, the first separation between linea ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We describe new techniques for proving lower bounds on datastructure problems, with the following broad consequences:
â¢ the first Î©(lgn) lower bound for any dynamic problem, improving on a bound that had been standing since 1989;
â¢ for static data structures, the first separation between linear and polynomial space. Specifically, for some problems that have constant query time when polynomial space is allowed, we can show Î©(lg n/ lg lg n) bounds when the space is O(n Â· polylog n).
Using these techniques, we analyze a variety of central datastructure problems, and obtain improved lower bounds for the following:
â¢ the partialsums problem (a fundamental application of augmented binary search trees);
â¢ the predecessor problem (which is equivalent to IP lookup in Internet routers);
â¢ dynamic trees and dynamic connectivity;
â¢ orthogonal range stabbing;
â¢ orthogonal range counting, and orthogonal range reporting;
â¢ the partial match problem (searching with wildcards);
â¢ (1 + Îµ)approximate near neighbor on the hypercube;
â¢ approximate nearest neighbor in the lâ metric.
Our new techniques lead to surprisingly nontechnical proofs. For several problems, we obtain simpler proofs for bounds that were already known.
unknown title
"... Last lecture we covered dynamic trees, also known as linkcut trees. Linkcut trees are able to represent a dynamic forest of rooted trees in O(log n) amortized time per operation. In this lecture we will see how to maintain connectivity information for general graphs. We will start by examining a s ..."
Abstract
 Add to MetaCart
Last lecture we covered dynamic trees, also known as linkcut trees. Linkcut trees are able to represent a dynamic forest of rooted trees in O(log n) amortized time per operation. In this lecture we will see how to maintain connectivity information for general graphs. We will start by examining a simpler, although not strictly better, alternative to linkcut trees known as Eulertour trees. Then, for the special case of Decremental Connectivity, in which edges may only be deleted, we will achieve constant runtime. We will then use Eulertour trees to achieve dynamic connectivity in general graphs in O(log 2 n) time. Finally we will survey some of what is and is not known for dynamic graphs. The next class will be about lower bounds. 2 Dynamic Connectivity Our goal is to maintain an undirected graph subject to: • insert/delete of edges or vertices (with no edges). • connected(u, v): whether u and v are connected, on general undirected graphs that are subject to vertex and edge insertion and deletion. • Another possible query is to determine whether the entire graph is connected; though this may seem easier, the current lower and upper bounds are the same as for pairwise connectivity.
Complexity of UnionSplitFind Problems
, 2007
"... In this thesis, we investigate various interpretations of the UnionSplitFind problem, an extension of the classic UnionFind problem. In the UnionSplitFind problem, we maintain disjoint sets of ordered elements subject to the operations of constructing singleton sets, merging two sets together, ..."
Abstract
 Add to MetaCart
In this thesis, we investigate various interpretations of the UnionSplitFind problem, an extension of the classic UnionFind problem. In the UnionSplitFind problem, we maintain disjoint sets of ordered elements subject to the operations of constructing singleton sets, merging two sets together, splitting a set by partitioning it around a specified value, and finding the set that contains a given element. The different interpretations of this problem arise from the different assumptions made regarding when sets can be merged and any special properties the sets may have. We define and analyze the Interval, Cyclic, Ordered, and General UnionSplitFind problems. Previous work implies optimal solutions to the Interval and Ordered UnionSplitFind problems and an Ω(log n / log log n) lower bound for the Cyclic UnionSplitFind problem in the cellprobe model. We present a new data
Some Notes on the Dynamic Connectivity Lower Bound ⋆
"... We want to encode a graph of n vertices in a data structure supporting the following operations: – insert edge(u, v): inserts and edge connecting vertex u to vertex v in the graph encoding. – delete edge(u, v): removes from the encoding the edge between u and v. – connected(u, v): answers yes if the ..."
Abstract
 Add to MetaCart
We want to encode a graph of n vertices in a data structure supporting the following operations: – insert edge(u, v): inserts and edge connecting vertex u to vertex v in the graph encoding. – delete edge(u, v): removes from the encoding the edge between u and v. – connected(u, v): answers yes if there is a path connecting u to v in the encoded graph, otherwise answers no. The first two are update operations, while the third is a query operation. Solutions: Not comparable, but exhibiting the existence of updatequery tradeoff. 1. Updates in O(lg n(lg lg n) 3), queries in O(lg n / lg lg lg n) [3]. 2. Updates in O(lg 2 n), queries in O(lg n / lg lg n) [4]. What is the best achievable amortized time for a mixed sequence of updates and queries? 2 The CellProbe Complexity Model What is? A combinatorial model for proving complexity lower bounds for static and dynamic data structures. It gives a concrete combinatorial representation of data structures
Lecturer: Jeff Erickson Scribe: Reza ZamaniNasab
"... We refer to the problem of dynamic connectivity as the following problem: For every positive integer n, design a data structure to maintain an undirected graph on n vertices, supporting the following actions: inserting an edge (represented by insert(u,v)), deleting an edge (represented by delete(u,v ..."
Abstract
 Add to MetaCart
We refer to the problem of dynamic connectivity as the following problem: For every positive integer n, design a data structure to maintain an undirected graph on n vertices, supporting the following actions: inserting an edge (represented by insert(u,v)), deleting an edge (represented by delete(u,v)), and detecting whether two vertices are connected to each other in the graph (represented by connected(u,v)). Our final goal here is to present a lower bound on the worst case time complexity 1 of any data structure that solves this problem in the cell probe model of computation. The same idea, together with more careful analysis, can be used to establish a tradeoff lower bound for this problem. For a data structure that solves dynamic connectivity (in cell probe model), assume the amortized update 2 time be tu(n) and the amortized query time be tq(n), where n indicates the order of graph. It can be shown that [3] min{tq, tu} lg ( max{tq, tu}) = Ω(lg n) min{tq, tu} This shows that both the solution of Thorup [1] to this problem with tu = O(lg n(lg lg n) 3) and tq = O(lg n / lg lg lg n), and that of Holm et. al. [2] with tu = O(lg 2 n) and tq = O(lg n / lg lg n) can be considered as optimal solutions. 10.1.1 The Cell Probe Model This is a rather general model of computation. The main object in this model is a “permanent” random access memory with 2 w words (which we call cells), each of size w bits 3. When an algorithm in this model processes an input of size n, we assume that w = θ(lg n) 4. As you may expect, the algorithm is allowed to store anything it wants in the cells, in 1 Actually it can be shown that the result is true in amortized sense and in the presence of randomization 2 insertion/deletion 3 Note that the number of words is limited to 2 w to make memory words addressaccessible, since addresses must be storable in the cells 4 w = Ω(lg n) enables the algorithm to read and remember the input, and w = O(lg n) avoids having weired algorithms in cell probe model, like sorters with time bound o(n lg n)
6.851: Advanced Data Structures Spring 2007
, 2007
"... The topic of this lecture is the fusion tree, another data structure to solve the predecessor/successor problem. Given a static set S ⊆ {0, 1, 2,..., 2 w − 1}, fusion trees can answer predecessor/successor queries in O(log w n). Essentially, fusion trees are Btrees with a branching factor of k = Θ( ..."
Abstract
 Add to MetaCart
The topic of this lecture is the fusion tree, another data structure to solve the predecessor/successor problem. Given a static set S ⊆ {0, 1, 2,..., 2 w − 1}, fusion trees can answer predecessor/successor queries in O(log w n). Essentially, fusion trees are Btrees with a branching factor of k = Θ(w1/5). Tree height is
6.851: Advanced Data Structures Spring 2011
, 2012
"... In the next two lectures we study the question of dynamic optimality, or whether there exists a binary search tree algorithm that performs ”as well ” as all other algorithms on any input string. In this lecture we will define a binary search tree as a formal model of computation, show some analytic ..."
Abstract
 Add to MetaCart
In the next two lectures we study the question of dynamic optimality, or whether there exists a binary search tree algorithm that performs ”as well ” as all other algorithms on any input string. In this lecture we will define a binary search tree as a formal model of computation, show some analytic bounds that a dynamically optimal binary search tree needs to satisfy, and show two search trees that are conjectured to be dynamically optimal. The first is the splay tree, which we will cover only briefly. The second will require us to build up a geometric view of a sequence of binary search tree queries. 2 Binary Search Trees The question we will explore in this lecture is whether or not there is a ”best ” binary search tree. We know that there are selfbalancing binary search trees that take O(logn) per query. Can we do better? In order to explore this question, we need a more rigorous definition of binary search tree. In this lecture we will treat the binary search tree (BST) as a model of computation that is a subset of the pointer machine model of computation. 2.1 Model of Computation A BST can be viewed is a model of computation where data must be stored as keys in a binary search tree. Each key has a pointer to its parent (unless it is the root) and a pointer to its left and right children, or a null pointer if they do not exist. The value of the key stored in the left child of a node must be less than or equal to the value of the key stored at the node, which is in turn less than or equal to the value of the key stored at the right child. The model supports the following unitcost operations: • Walk to left child. • Walk to right child. • Walk to parent. • Rotate node x. 1 p x x
unknown title
, 2007
"... In the last lecture we introduced Euler tour trees [3], dynamic data structures that can perform linkcut tree operations in O(lg n) time. We then showed how to implement an efficient dynamic connectivity algorithm using a spanning forest of Euler tour trees, as demonstrated in [4]. This yielded an ..."
Abstract
 Add to MetaCart
In the last lecture we introduced Euler tour trees [3], dynamic data structures that can perform linkcut tree operations in O(lg n) time. We then showed how to implement an efficient dynamic connectivity algorithm using a spanning forest of Euler tour trees, as demonstrated in [4]. This yielded an amortized time bound of O(lg 2 n) for update operations (such as edge insertion and deletion), and O(lg n / lg lg n) for querying the connectivity of two vertices. In this lecture, we switch to examining the lower bound of dynamic connectivity algorithms. Until recently, the best lower bound for dynamic connectivity operations was Ω(lg n / lg lg n), as described by Fredman and Henzinger in [1] and independently by Miltersen in [2]. However, we will show below that it is possible to prove Ω(lg n), using the method given by Pǎtra¸scu and Demaine in [6]. 2 Cell Probe Complexity Model The Ω(lg n) bound relies on a model of computation called the cell probe complexity model, originally described in the context of proving dynamic lower bounds by Fredman and Saks in [5]. The cell probe model views a data structure as a sequence of cells, or words, each containing a wbit field. The model calculates the complexity of an algorithm by counting the number of reads and writes to the cells; any additional computation is free. This makes the model comparable to a RAM model