Yakov Nekrich

Alphabet Partitioning for Compressed Rank/Select and Applications

We present a data structure that stores a string s[1..n] over the alphabet [1..σ] in nH 0(s) + o(n)(H 0(s) + 1) bits, where H 0(s) is the zero-order entropy of s. This data structure supports the queries access and rank in time \(({\mathcal O}{{\rm lg lg}\sigma})\), and the select query in constant time. This result improves on previously known data structures using \(nH_0(s)+o(n\lg\sigma)\) bits, where on highly compressible instances the redundancy \(o(n\lg\sigma)\) cease to be negligible compared to the nH 0(s) bits that encode the data. The technique is based on combining previous results through an ingenious partitioning of the alphabet, and practical enough to be implementable. It applies not only to strings, but also to several other compact data structures. For example, we achieve (i) faster search times and lower redundancy for the smallest existing full-text self-index; (ii) compressed permutations π with times for π() and π − 1() improved to log-logarithmic; and (iii) the first compressed representation of dynamic collections of disjoint sets.

A faster grammar-based self-index

To store and search genomic databases efficiently, researchers have recently started building compressed self-indexes based on straight-line programs and LZ77. In this paper we show how, given a balanced straight-line program for a string S[1..n] whose LZ77 parse consists of z phrases, we can add O(z log log z) words and obtain a compressed self-index for S such that, given a pattern P [1..m], we can list the occ occurrences of P in S in O(m2 + (m + occ) log log n) time. All previous self-indexes are either larger or slower in the worst case.

Orthogonal range searching in linear and almost-linear space

In this paper we describe space-efficient data structures for the two-dimensional range searching problem. We present a dynamic linear space data structure that supports orthogonal range reporting queries in O(logn+klog^@en) time, where k is the size of the answer. Our data structure also supports emptiness and one-reporting queries in O(logn) time and thus achieves optimal time and space for this type of queries. In the case of integer point coordinates, we describe a static and a randomized dynamic linear space data structures that support range reporting, emptiness and one-reporting queries in sub-logarithmic time. These are the first linear space data structures for these problems that achieve sub-logarithmic query time. We also present a dynamic linear space data structure for range counting queries with O((logn/loglogn)^2) time and a dynamic O(nlogn/loglogn) space data structure for semigroup range queries with O((logn/loglogn)^2) query time.

Optimal Dynamic Sequence Representations

We describe a data structure that supports access, rank and select queries, as well as symbol insertions and deletions, on a string S[1, n] over alphabet [1..σ] in time O(lg n/lg lg n), which is optimal. The time is worst-case for the queries and amortized for the updates. This complexity is better than the best previous ones by a Θ(1 + lg σ/lg lg n) factor. Our structure uses nH0(S) + O(n + σ(lg σ + lg1+e n)) bits, where H0(S) is the zero-order entropy of S and 0 < e < 1 is any constant. This space redundancy over nH0(S) is also better, almost always, than that of the best previous dynamic structures, o(n lg σ) + O(σ(lg σ+lg n)). We can also handle general alphabets in optimal time, which has been an open problem in dynamic sequence representations.

Sorted range reporting

We consider a variant of the orthogonal range reporting problem when all points should be reported in the sorted order of their x-coordinates. We show that reporting two-dimensional points with this additional condition can be organized (almost) as efficiently as the standard range reporting. Moreover, our results generalize and improve the previously known results for the orthogonal range successor problem and can be used to obtain better solutions for some stringology problems.

LZ77‐based Self‐indexing with Faster Pattern Matching

To store and search genomic databases efficiently, researchers have recently started building self-indexes based on LZ77. As the name suggests, a self-index for a string supports both random access and pattern matching queries. In this paper we show how, given a string S [1..n] whose LZ77 parse consists of z phrases, we can store a self-index for S in \(\mathcal{O}({z \log (n / z)})\) space such that later, first, given a position i and a length l, we can extract S [i..i + l − 1] in \(\mathcal{O}({\ell + \log n})\) time; second, given a pattern P [1..m], we can list the occ occurrences of P in S in \(\mathcal{O}({m \log m + occ \log \log n})\) time.

Space-efficient data-analysis queries on grids

We consider various data-analysis queries on two-dimensional points. We give new space/time tradeoffs over previous work on geometric queries such as dominance and rectangle visibility, and on semigroup and group queries such as sum, average, variance, minimum and maximum. We also introduce new solutions to queries less frequently considered in the literature such as two-dimensional quantiles, majorities, successor/predecessor, mode, and various top-k queries, considering static and dynamic scenarios.

A data structure for multi-dimensional range reporting

We present a static data structure for orthogonal range reporting on a U x U x U integer grid. Our data structure supports orthogonal range reporting queries in O((log log n)² + log log U + k) time and uses O(n log⁴ n) space, where k is the size of the answer. We describe a static data structure for range reporting in R⁴ with O(log nlog log n +k) query time and a static data structure for range reporting in R^d, d ≥ 5, with query time O((log^d-3 n)/(log log n)^d-5 +k). We also describe a semi-dynamic data structure that supports range reporting queries in R³ in O(log nlog log n +k) time and insertions in polylogarithmic time.

Optimal trade-off for Merkle tree traversal

In this paper we describe optimal trade-offs between time and space complexity of Merkle tree traversals with their associated authentication paths, improving on the previous results of M. Jakobsson, T. Leighton, S. Micali, and M. Szydlo [Fractal Merkle tree representation and traversal, in: RSA Cryptographers Track, RSA Security Conference, 2003] and M. Szydlo [Merkle tree traversal in log space and time, in: Proc. Eurocrypt, in: LNCS, vol. 3027, 2004, pp. 541-554; Merkle tree traversal in log space and time, Preprint version 2003, available at http://www.szydlo.com]. In particular, we show that our algorithm requires 2logn/log^(^3^)n hash function computations and storage for less than (logn/log^(^3^)n+1)loglogn+2logn hash values, where n is the number of leaves in the Merkle tree. We also prove that these trade-offs are optimal, i.e. there is no algorithm that requires less than O(logn/logt) time and less than O(tlogn/logt) space for any choice of parameter t>=2. Our algorithm could be of special interest in the case when both time and space are limited.

Data Structures for Approximate Orthogonal Range Counting

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 1-D range up to an additive term k 1/c in O(loglogU·loglogn) 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 two-dimensional orthogonal range up to an additive term k ρ in O(loglogU + (1/ρ)loglogn) time for any ρ> 0. We can estimate the number of points in a three-dimensional orthogonal range up to an additive term k ρ in O(loglogU + (loglogn)3 + (3 v )loglogn) time for