Results 1 
8 of
8
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.
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)
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
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.
permission. Proof Sketches: Verifiable MultiParty Aggregation
, 2006
"... personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires pri ..."
Abstract
 Add to MetaCart
personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific
unknown title
"... 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