Results 1  10
of
31
Fullyfunctional succinct trees
 In Proc. 21st SODA
, 2010
"... We propose new succinct representations of ordinal trees, which have been studied extensively. It is known that any nnode static tree can be represented in 2n + o(n) bits and a large number of operations on the tree can be supported in constant time under the wordRAM model. However existing data s ..."
Abstract

Cited by 33 (12 self)
 Add to MetaCart
We propose new succinct representations of ordinal trees, which have been studied extensively. It is known that any nnode static tree can be represented in 2n + o(n) bits and a large number of operations on the tree can be supported in constant time under the wordRAM model. However existing data structures are not satisfactory in both theory and practice because (1) the lowerorder term is Ω(nlog log n / log n), which cannot be neglected in practice, (2) the hidden constant is also large, (3) the data structures are complicated and difficult to implement, and (4) the techniques do not extend to dynamic trees supporting insertions and deletions of nodes. We propose a simple and flexible data structure, called the range minmax tree, that reduces the large number of relevant tree operations considered in the literature to a few primitives, which are carried out in constant time on sufficiently small trees. The result is then extended to trees of arbitrary size, achieving 2n + O(n/polylog(n)) bits of space. The redundancy is significantly lower than in any previous proposal, and the data structure is easily implemented. Furthermore, using the same framework, we derive the first fullyfunctional dynamic succinct trees. 1
Dynamic Ordered Sets with Exponential Search Trees
 Combination of results presented in FOCS 1996, STOC 2000 and SODA
, 2001
"... We introduce exponential search trees as a novel technique for converting static polynomial space search structures for ordered sets into fullydynamic linear space data structures. This leads to an optimal bound of O ( √ log n/log log n) for searching and updating a dynamic set of n integer keys i ..."
Abstract

Cited by 26 (1 self)
 Add to MetaCart
We introduce exponential search trees as a novel technique for converting static polynomial space search structures for ordered sets into fullydynamic linear space data structures. This leads to an optimal bound of O ( √ log n/log log n) for searching and updating a dynamic set of n integer keys in linear space. Here searching an integer y means finding the maximum key in the set which is smaller than or equal to y. This problem is equivalent to the standard text book problem of maintaining an ordered set (see, e.g., Cormen, Leiserson, Rivest, and Stein: Introduction to Algorithms, 2nd ed., MIT Press, 2001). The best previous deterministic linear space bound was O(log n/log log n) due Fredman and Willard from STOC 1990. No better deterministic search bound was known using polynomial space.
Tight lower bounds for selection in randomly ordered streams
 In SODA
, 2008
"... We show that any algorithm computing the median of a stream presented in random order, using polylog(n) space, requires an optimal Ω(log log n) passes, resolving an open question from the seminal paper on streaming by Munro and Paterson, from FOCS 1978. 1 ..."
Abstract

Cited by 16 (3 self)
 Add to MetaCart
We show that any algorithm computing the median of a stream presented in random order, using polylog(n) space, requires an optimal Ω(log log n) passes, resolving an open question from the seminal paper on streaming by Munro and Paterson, from FOCS 1978. 1
Orthogonal Range Searching on the RAM, Revisited
, 2011
"... We present a number of new results on one of the most extensively studied topics in computational geometry, orthogonal range searching. All our results are in the standard word RAM model: 1. We present two data structures for 2d orthogonal range emptiness. The first achieves O(n lg lg n) space and ..."
Abstract

Cited by 15 (4 self)
 Add to MetaCart
We present a number of new results on one of the most extensively studied topics in computational geometry, orthogonal range searching. All our results are in the standard word RAM model: 1. We present two data structures for 2d orthogonal range emptiness. The first achieves O(n lg lg n) space and O(lg lg n) query time, assuming that the n given points are in rank space. This improves the previous results by Alstrup, Brodal, and Rauhe (FOCS’00), with O(n lg ε n) space and O(lg lg n) query time, or with O(n lg lg n) space and O(lg 2 lg n) query time. Our second data structure uses O(n) space and answers queries in O(lg ε n) time. The best previous O(n)space data structure, due to Nekrich (WADS’07), answers queries in O(lg n / lg lg n) time. 2. We give a data structure for 3d orthogonal range reporting with O(n lg 1+ε n) space and O(lg lg n+ k) query time for points in rank space, for any constant ε> 0. This improves the previous results by Afshani (ESA’08), Karpinski and Nekrich (COCOON’09), and Chan (SODA’11), with O(n lg 3 n) space and O(lg lg n + k) query time, or with O(n lg 1+ε n) space and O(lg 2 lg n + k) query time. Consequently, we obtain improved upper bounds for orthogonal range reporting in all constant dimensions above 3.
Planning for fast connectivity updates
 In Proceedings 48th IEEE Symposium on Foundations of Computer Science (FOCS
, 2007
"... Understanding how a single edge deletion can affect the connectivity of a graph amounts to finding the graph bridges. But when faced with d> 1 deletions, can we establish as easily how the connectivity changes? When planning for an emergency, we want to understand the structure of our network ahead ..."
Abstract

Cited by 10 (0 self)
 Add to MetaCart
Understanding how a single edge deletion can affect the connectivity of a graph amounts to finding the graph bridges. But when faced with d> 1 deletions, can we establish as easily how the connectivity changes? When planning for an emergency, we want to understand the structure of our network ahead of time, and respond swiftly when an emergency actually happens. We describe a linearspace representation of graphs which enables us to determine how a batch of edge updates can impact the graph. Given a set of d edge updates, in time O(d polylg n) we can obtain the number of connected components, the size of each component, and a fast oracle for answering connectivity queries in the updated graph. The initial representation is polynomialtime constructible. 1.
New lower and upper bounds for representing sequences
 CoRR
"... Abstract. Sequence representations supporting queries access, select and rank are at the core of many data structures. There is a considerable gap between different upper bounds, and the few lower bounds, known for such representations, and how they interact with the space used. In this article we p ..."
Abstract

Cited by 9 (8 self)
 Add to MetaCart
Abstract. Sequence representations supporting queries access, select and rank are at the core of many data structures. There is a considerable gap between different upper bounds, and the few lower bounds, known for such representations, and how they interact with the space used. In this article we prove a strong lower bound for rank, which holds for rather permissive assumptions on the space used, and give matching upper bounds that require only a compressed representation of the sequence. Within this compressed space, operations access and select can be solved within almostconstant time. 1
Mikkel Thorup: Randomization does not help searching predecessors
 Symposium on Discreat Algorithms
"... At STOC’06, we presented a new technique for proving cellprobe lower bounds for static data structures with deterministic queries. This was the first technique which could prove a bound higher than communication complexity, and it gave the first separation between data structures with linear and po ..."
Abstract

Cited by 7 (0 self)
 Add to MetaCart
At STOC’06, we presented a new technique for proving cellprobe lower bounds for static data structures with deterministic queries. This was the first technique which could prove a bound higher than communication complexity, and it gave the first separation between data structures with linear and polynomial space. The new technique was, however, heavily tuned for the deterministic worstcase, demonstrating long query times only for an exponentially small fraction of the input. In this paper, we extend the technique to give lower bounds for randomized query algorithms with constant error probability. Our main application is the problem of searching predecessors in a static set of n integers, each contained in a ℓbit word. Our tradeoff lower bounds are tight for any combination of parameters. For small space, i.e. n 1+o(1) , proving such lower bounds was inherently impossible through known techniques. An interesting new consequence is that for near linear space, the classic van Emde Boas search time of O(lg ℓ) cannot be improved, even if we allow randomization. This is a separation from polynomial space, since Beame and Fich [STOC’02] give a predecessor search time of O(lg ℓ / lg lg ℓ) using quadratic space. We also show a tight Ω(lg lg n) lower bound for 2dimensional range queries, via a new reduction. This holds even in rank space, where no superconstant lower bound was known, neither randomized nor worstcase. We also slightly improve the best lower bound for the approximate nearest neighbor problem, when small space is available. 1
EFFICIENT AND ERRORCORRECTING DATA STRUCTURES FOR MEMBERSHIP AND POLYNOMIAL EVALUATION
 SUBMITTED TO THE SYMPOSIUM ON THEORETICAL ASPECTS OF COMPUTER SCIENCE
"... We construct efficient data structures that are resilient against a constant fraction of adversarial noise. Our model requires that the decoder answers most queries correctly with high probability and for the remaining queries, the decoder with high probability either answers correctly or declares “ ..."
Abstract

Cited by 7 (4 self)
 Add to MetaCart
We construct efficient data structures that are resilient against a constant fraction of adversarial noise. Our model requires that the decoder answers most queries correctly with high probability and for the remaining queries, the decoder with high probability either answers correctly or declares “don’t know.” Furthermore, if there is no noise on the data structure, it answers all queries correctly with high probability. Our model is the common generalization of an errorcorrecting data structure model proposed recently by de Wolf, and the notion of “relaxed locally decodable codes” developed in the PCP literature. We measure the efficiency of a data structure in terms of its length (the number of bits in its representation), and queryanswering time, measured by the number of bitprobes to the (possibly corrupted) representation. We obtain results for the following two data structure problems: • (Membership) Store a subset S of size at most s from a universe of size n such that membership queries can be answered efficiently, i.e., decide if a given element from the universe is in S. We construct an errorcorrecting data structure for this problem with length nearly linear in s log n that answers membership queries with O(1) bitprobes. This nearly matches the asymptotically optimal parameters for the noiseless case: length O(s log n) and one bitprobe, due to
Tight Lower Bounds for MultiPass Stream Computation via Pass Elimination
, 2008
"... There is a natural relationship between lower bounds in the multipass stream model and lower bounds in multiround communication. However, this connection is less understood than the connection between singlepass stream computation and oneway communication. In this paper, we consider datastream ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
There is a natural relationship between lower bounds in the multipass stream model and lower bounds in multiround communication. However, this connection is less understood than the connection between singlepass stream computation and oneway communication. In this paper, we consider datastream problems for which reductions from natural multiround communication problems do not yield tight bounds or do not apply. While lower bounds are known for some of these datastream problems, many of these only apply to deterministic or comparisonbased algorithms, whereas the lower bounds we present apply to any (possibly randomized) algorithms. Our results are particularly relevant to evaluating functions that are dependent on the ordering of the stream, such as the longest increasing subsequence and a variant of tree pointer jumping in which pointers are revealed according to a postorder traversal. Our approach is based on establishing “passelimination” type results that are analogous to the roundelimination results of Miltersen et al. [23] and Sen [29]. We demonstrate our approach by proving tight bounds for a range of datastream problems including finding the longest increasing sequences (a problem that has recently become very