Results 1  10
of
10
Optimal Bounds for the Predecessor Problem and Related Problems
 Journal of Computer and System Sciences
, 2001
"... We obtain matching upper and lower bounds for the amount of time to find the predecessor of a given element among the elements of a fixed compactly stored set. Our algorithms are for the unitcost word RAM with multiplication and are extended to give dynamic algorithms. The lower bounds are proved ..."
Abstract

Cited by 55 (0 self)
 Add to MetaCart
We obtain matching upper and lower bounds for the amount of time to find the predecessor of a given element among the elements of a fixed compactly stored set. Our algorithms are for the unitcost word RAM with multiplication and are extended to give dynamic algorithms. The lower bounds are proved for a large class of problems, including both static and dynamic predecessor problems, in a much stronger communication game model, but they apply to the cell probe and RAM models.
Succinct Data Structures for Retrieval and Approximate Membership
"... Abstract. The retrieval problem is the problem of associating data with keys in a set. Formally, the data structure must store a function f: U → {0, 1} r that has specified values on the elements of a given set S ⊆ U, S  = n, but may have any value on elements outside S. All known methods (e. g. ..."
Abstract

Cited by 13 (6 self)
 Add to MetaCart
Abstract. The retrieval problem is the problem of associating data with keys in a set. Formally, the data structure must store a function f: U → {0, 1} r that has specified values on the elements of a given set S ⊆ U, S  = n, but may have any value on elements outside S. All known methods (e. g. those based on perfect hash functions), induce a space overhead of Θ(n) bits over the optimum, regardless of the evaluation time. We show that for any k, query time O(k) can be achieved using space that is within a factor 1 + e −k of optimal, asymptotically for large n. The time to construct the data structure is O(n), expected. If we allow logarithmic evaluation time, the additive overhead can be reduced to O(log log n) bits whp. A general reduction transfers the results on retrieval into analogous results on approximate membership, a problem traditionally addressed using Bloom filters. Thus we obtain space bounds arbitrarily close to the lower bound for this problem as well. The evaluation procedures of our data structures are extremely simple. For the results stated above we assume free access to fully random hash functions. This assumption can be justified using space o(n) to simulate full randomness on a RAM. 1
Counting Inversions, Offline Orthogonal Range Counting, and Related Problems
"... We give an O(n √ lg n)time algorithm for counting the number of inversions in a permutation on n elements. This improves a longstanding previous bound of O(n lg n / lg lg n) that followed from Dietz’s data structure [WADS’89], and answers a question of Andersson and Petersson [SODA’95]. As Dietz’s ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
We give an O(n √ lg n)time algorithm for counting the number of inversions in a permutation on n elements. This improves a longstanding previous bound of O(n lg n / lg lg n) that followed from Dietz’s data structure [WADS’89], and answers a question of Andersson and Petersson [SODA’95]. As Dietz’s result is known to be optimal for the related dynamic rank problem, our result demonstrates a significant improvement in the offline setting. Our new technique is quite simple: we perform a “vertical partitioning ” of a trie (akin to van Emde Boas trees), and use ideas from external memory. However, the technique finds numerous applications: for example, we obtain • in d dimensions, an algorithm to answer n offline orthogonal range counting queries in time O(n lg d−2+1/d n); • an improved construction time for online data structures for orthogonal range counting; • an improved update time for the partial sums problem; • faster Word RAM algorithms for finding the maximum depth in an arrangement of axisaligned rectangles, and for the slope selection problem. As a bonus, we also give a simple (1 + ε)approximation algorithm for counting inversions that runs in linear time, improving the previous O(n lg lg n) bound by Andersson and Petersson.
Persistent Predecessor Search and Orthogonal Point Location on the Word RAM
"... We answer a basic data structuring question (for example, raised by Dietz and Raman back in SODA 1991): can van Emde Boas trees be made persistent, without changing their asymptotic query/update time? We present a (partially) persistent data structure that supports predecessor search in a set of int ..."
Abstract

Cited by 6 (3 self)
 Add to MetaCart
We answer a basic data structuring question (for example, raised by Dietz and Raman back in SODA 1991): can van Emde Boas trees be made persistent, without changing their asymptotic query/update time? We present a (partially) persistent data structure that supports predecessor search in a set of integers in {1,..., U} under an arbitrary sequence of n insertions and deletions, with O(log log U) expected query time and expected amortized update time, and O(n) space. The query bound is optimal in U for linearspace structures and improves previous nearO((log log U) 2) methods. The same method solves a fundamental problem from computational geometry: point location in orthogonal planar subdivisions (where edges are vertical or horizontal). We obtain the first static data structure achieving O(log log U) worstcase query time and linear space. This result is again optimal in U for linearspace structures and improves the previous O((log log U) 2) method by de Berg, Snoeyink, and van Kreveld (1992). The same result also holds for higherdimensional subdivisions that are orthogonal binary space partitions, and for certain nonorthogonal planar subdivisions such as triangulations without small angles. Many geometric applications follow, including improved query times for orthogonal range reporting for dimensions ≥ 3 on the RAM. Our key technique is an interesting new vanEmdeBoas–style recursion that alternates between two strategies, both quite simple.
I/OEfficient Data Structures for Colored Range and Prefix Reporting
"... Motivated by information retrieval applications, we consider the onedimensional colored range reporting problem in rank space. The goal is to build a static data structure for sets C1,..., Cm ⊆ {1,..., σ} that supports queries of the kind: Given indices a, b, report the set ⋃ a≤i≤b Ci. We study the ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
Motivated by information retrieval applications, we consider the onedimensional colored range reporting problem in rank space. The goal is to build a static data structure for sets C1,..., Cm ⊆ {1,..., σ} that supports queries of the kind: Given indices a, b, report the set ⋃ a≤i≤b Ci. We study the problem in the I/O model, and show that there exists an optimal linearspace data structure that answers queries in O(1 + k/B) I/Os, where k denotes the output size and B the disk block size in words. In fact, we obtain the same bound for the harder problem of threesided orthogonal range reporting. In this problem, we are to preprocess a set of n twodimensional points in rank space, such that all points inside a query rectangle of the form [x1, x2]×(−∞, y] can be reported. The best previous bounds for this problem is either O(n lg 2 B n) space and O(1 + k/B) query I/Os, or O(n) space and O(lg (h) B n + k/B) query I/Os, where lg(h)
Dynamic Indexability and Lower . . .
, 2009
"... The Btree is a fundamental external index structure that is widely used for answering onedimensional range reporting queries. Given a set of N keys, a range query can be an ..."
Abstract
 Add to MetaCart
The Btree is a fundamental external index structure that is widely used for answering onedimensional range reporting queries. Given a set of N keys, a range query can be an
Computational Geometry through the Information Lens
, 2007
"... revisits classic problems in computational geometry from the modern algorithmic ..."
Abstract
 Add to MetaCart
revisits classic problems in computational geometry from the modern algorithmic
Transdichotomous Results in Computational Geometry, I: Point Location in Sublogarithmic Time ∗
, 2008
"... Given a planar subdivision whose coordinates are integers bounded by U ≤ 2 w, we present a linearspace data structure that can answer point location queries in O(min{lg n / lg lg n, √ lg U/lg lg U}) time on the unitcost RAM with word size w. Thisisthe first result to beat the standard Θ(lg n) bou ..."
Abstract
 Add to MetaCart
Given a planar subdivision whose coordinates are integers bounded by U ≤ 2 w, we present a linearspace data structure that can answer point location queries in O(min{lg n / lg lg n, √ lg U/lg lg U}) time on the unitcost RAM with word size w. Thisisthe first result to beat the standard Θ(lg n) bound for infinite precision models. As a consequence, we obtain the first o(n lg n) (randomized) algorithms for many fundamental problems in computational geometry for arbitrary integer input on the word RAM, including: constructing the convex hull of a threedimensional point set, computing the Voronoi diagram or the Euclidean minimum spanning tree of a planar point set, triangulating a polygon with holes, and finding intersections among a set of line segments. Higherdimensional extensions and applications are also discussed. Though computational geometry with bounded precision input has been investigated for a long time, improvements have been limited largely to problems of an orthogonal flavor. Our results surpass this longstanding limitation, answering, for example, a question of Willard (SODA’92). Key words. Computational geometry, wordRAM algorithms, data structures, sorting, searching, convex hulls, Voronoi diagrams, segment intersection AMS subject classifications. 68Q25, 68P05, 68U05 Abbreviated title. Point location in sublogarithmic time
Dynamic Indexability: The QueryUpdate Tradeoff for OneDimensional Range Queries
, 811
"... The Btree is a fundamental secondary index structure that is widely used for answering onedimensional range N K reporting queries. Given a set of N keys, a range query can be answered in O(logB +) I/Os, where B is the disk M B block size, K the output size, and M the size of the main memory buffer ..."
Abstract
 Add to MetaCart
The Btree is a fundamental secondary index structure that is widely used for answering onedimensional range N K reporting queries. Given a set of N keys, a range query can be answered in O(logB +) I/Os, where B is the disk M B block size, K the output size, and M the size of the main memory buffer. When keys are inserted or deleted, the Btree is updated in O(logB N) I/Os, if we require the resulting changes to be committed to disk right away. Otherwise, the memory buffer can be used to buffer the recent updates, and changes can be written to disk in batches, which significantly lowers the amortized update cost. A systematic way of batching up updates is to use the logarithmic method, combined with fractional cascading, resulting in a dynamic Btree that supports insertions in O ( 1
On Dynamic Range Reporting in One Dimension Christian Worm Mortensen ∗ IT U. Copenhagen
, 2005
"... We consider the problem of maintaining a dynamic set of integers and answering queries of the form: report a point (equivalently, all points) in a given interval. Range searching is a natural and fundamental variant of integer search, and can be solved using predecessor search. However, for a RAM wi ..."
Abstract
 Add to MetaCart
We consider the problem of maintaining a dynamic set of integers and answering queries of the form: report a point (equivalently, all points) in a given interval. Range searching is a natural and fundamental variant of integer search, and can be solved using predecessor search. However, for a RAM with wbit words, we show how to perform updates in O(lg w) time and answer queries in O(lg lg w) time. The update time is identical to the van Emde Boas structure, but the query time is exponentially faster. Existing lower bounds show that achieving our query time for predecessor search requires doublyexponentially slower updates. We present some arguments supporting the conjecture that our solution is optimal. Our solution is based on a new and interesting recursion idea which is “more extreme” that the van Emde Boas recursion. Whereas van Emde Boas uses a simple recursion (repeated halving) on each path in a trie, we use a nontrivial, van Emde Boaslike recursion on every such path. Despite this, our algorithm is quite clean when seen from the right angle. To achieve linear space for our data structure, we solve a problem which is of independent interest. We develop the first scheme for dynamic perfect hashing requiring sublinear space. This gives a dynamic Bloomier filter (an approximate storage scheme for sparse vectors) which uses low space. We strengthen previous lower bounds to show that these results are optimal. 1