Results 1  10
of
23
Integer Priority Queues with Decrease Key in . . .
 STOC'03
, 2003
"... We consider Fibonacci heap style integer priority queues supporting insert and decrease key operations in constant time. We present a deterministic linear space solution that with n integer keys support delete in O(log log n) time. If the integers are in the range [0,N), we can also support delete i ..."
Abstract

Cited by 27 (2 self)
 Add to MetaCart
We consider Fibonacci heap style integer priority queues supporting insert and decrease key operations in constant time. We present a deterministic linear space solution that with n integer keys support delete in O(log log n) time. If the integers are in the range [0,N), we can also support delete in O(log log N) time. Even for the special case of monotone priority queues, where the minimum has to be nondecreasing, the best previous bounds on delete were O((log n) 1/(3−ε) ) and O((log N) 1/(4−ε)). These previous bounds used both randomization and amortization. Our new bounds a deterministic, worstcase, with no restriction to monotonicity, and exponentially faster. As a classical application, for a directed graph with n nodes and m edges with nonnegative integer weights, we get single source shortest paths in O(m + n log log n) time, or O(m + n log log C) ifC is the maximal edge weight. The later solves an open problem of Ahuja, Mehlhorn, Orlin, and
Topk document retrieval in optimal time and linear space
 In Proc. 22nd Annual ACMSIAM Symposium on Discrete Algorithms (SODA 2012
, 2012
"... We describe a data structure that uses O(n)word space and reports k most relevant documents that contain a query pattern P in optimal O(P  + k) time. Our construction supports an ample set of important relevance measures, such as the frequency of P in a document and the minimal distance between t ..."
Abstract

Cited by 13 (7 self)
 Add to MetaCart
We describe a data structure that uses O(n)word space and reports k most relevant documents that contain a query pattern P in optimal O(P  + k) time. Our construction supports an ample set of important relevance measures, such as the frequency of P in a document and the minimal distance between two occurrences of P in a document. We show how to reduce the space of the data structure from O(n log n) to O(n(log σ+log D+log log n)) bits, where σ is the alphabet size and D is the total number of documents. 1
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.
WorstCase Optimal Adaptive Prefix Coding
 IN: PROCEEDINGS OF THE ALGORITHMS AND DATA STRUCTURES SYMPOSIUM (WADS
, 2009
"... A common complaint about adaptive prefix coding is that it is much slower than static prefix coding. Karpinski and Nekrich recently took an important step towards resolving this: they gave an adaptive Shannon coding algorithm that encodes each character in O(1) amortized time and decodes it in O(l ..."
Abstract

Cited by 4 (4 self)
 Add to MetaCart
A common complaint about adaptive prefix coding is that it is much slower than static prefix coding. Karpinski and Nekrich recently took an important step towards resolving this: they gave an adaptive Shannon coding algorithm that encodes each character in O(1) amortized time and decodes it in O(log H) amortized time, where H is the empirical entropy of the input string s. For comparison, Gagie’s adaptive Shannon coder and both Knuth’s and Vitter’s adaptive Huffman coders all use Θ(H) amortized time for each character. In this paper we give an adaptive Shannon coder that both encodes and decodes each character in O(1) worstcase time. As with both previous adaptive Shannon coders, we store s in at most (H + 1)s  + o(s) bits. We also show that this encoding length is worstcase optimal up to the lower order term.
Achieving Spatial Adaptivity while Finding Approximate Nearest Neighbors
"... We present the first spatially adaptive data structure that answers approximate nearest neighbor (ANN) queries to points that reside in a geometric space of any constant dimension d. The Ltnorm approximation ratio is O(d 1+1/t), and the running time for a query q is O(d 2 lg δ(p, q)), where p is th ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
We present the first spatially adaptive data structure that answers approximate nearest neighbor (ANN) queries to points that reside in a geometric space of any constant dimension d. The Ltnorm approximation ratio is O(d 1+1/t), and the running time for a query q is O(d 2 lg δ(p, q)), where p is the result of the preceding query and δ(p, q) is the number of input points in a suitablysized box containing p and q. Our data structure has O(dn) size and requires O(d 2 n lg n) preprocessing time, where n is the number of points in the data structure. The size of the bounding box for δ depends on d, and our results rely on the Random Access Machine (RAM) model with word size Θ(lg n). 1
Searching for frequent colors in rectangles
 in: Proc. 20th Canadian Conference on Computational Geometry (CCCG
"... We study a new variant of colored orthogonal range searching problem: given a query rectangle Q all colors c, such that at least a fraction τ of all points in Q are of color c, must be reported. We describe several data structures for that problem that use pseudolinear space and answer queries in p ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
We study a new variant of colored orthogonal range searching problem: given a query rectangle Q all colors c, such that at least a fraction τ of all points in Q are of color c, must be reported. We describe several data structures for that problem that use pseudolinear space and answer queries in polylogarithmic time. 1
Dynamic 3sided Planar Range Queries with Expected Doubly Logarithmic Time
 Proceedings of ISAAC, 2009
"... Abstract. We consider the problem of maintaining dynamically a set of points in the plane and supporting range queries of the type [a, b] × (−∞, c]. We assume that the inserted points have their xcoordinates drawn from a class of smooth distributions, whereas the ycoordinates are arbitrarily distr ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
Abstract. We consider the problem of maintaining dynamically a set of points in the plane and supporting range queries of the type [a, b] × (−∞, c]. We assume that the inserted points have their xcoordinates drawn from a class of smooth distributions, whereas the ycoordinates are arbitrarily distributed. The points to be deleted are selected uniformly at random among the inserted points. For the RAM model, we present a linear space data structure that supports queries in O(log log n + t) expected time with high probability and updates in O(log log n) expected amortized time, where n is the number of points stored and t is the size of the output of the query. For the I/O model we support queries in O(log log B n + t/B) expected I/Os with high probability and updates in O(log B log n) expected amortized I/Os using linear space, where B is the disk block size. The data structures are deterministic and the expectation is with respect to the input distribution. 1
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.
Adaptive Binary Search Trees
, 2009
"... A ubiquitous problem in the field of algorithms and data structures is that of searching for an element from an ordered universe. The simple yet powerful binary search tree (BST) model provides a rich family of solutions to this problem. Although BSTs require Ω(lg n) time per operation in the wors ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
A ubiquitous problem in the field of algorithms and data structures is that of searching for an element from an ordered universe. The simple yet powerful binary search tree (BST) model provides a rich family of solutions to this problem. Although BSTs require Ω(lg n) time per operation in the worst case, various adaptive BST algorithms are capable of exploiting patterns in the sequence of queries to achieve tighter, inputsensitive, bounds that can be o(lg n) in many cases. This thesis furthers our understanding of what is achievable in the BST model along two directions. First, we make progress in improving instancespecific lower bounds in the BST model. In particular, we introduce a framework for generating lower bounds on the cost that any BST algorithm must pay to execute a query sequence,
Data Structures for Approximate Orthogonal Range Counting
, 906
"... Abstract. We present new data structures for approximately counting the number of points in an orthogonal range. There is a deterministic linear space data structure that supports updates in O(1) time and approximates the number of elements in a 1D range up to an additive term k 1/c in O(log log U ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Abstract. We present new data structures for approximately counting the number of points in an orthogonal range. There is a deterministic linear space data structure that supports updates in O(1) time and approximates the number of elements in a 1D range up to an additive term k 1/c in O(log log U · log log n) time, where k is the number of elements in the answer, U is the size of the universe and c is an arbitrary fixed constant. We can estimate the number of points in a twodimensional orthogonal range up to an additive term k ρ in O(log log U +(1/ρ) log log n) time for any ρ> 0. We can estimate the number of points in a threedimensional orthogonal range up to an additive term k ρ in O(log log U + (log log n) 3 + (3 v) log log n) time for v = log 1 ρ