We present an O(n 1.5 )-space distance oracle for directed planar graphs that answers distance queries in O(log n) time. Our oracle both significantly simplifies and significantly improves the recent oracle of Cohen-Addad, Dahlgaard and Wulff-Nilsen [FOCS 2017], which uses O(n 5/3 )-space and answers queries in O(log n) time. We achieve this by designing an elegant and efficient point location data structure for Voronoi diagrams on planar graphs.We further show a smooth tradeoff between space and query-time. For any S ∈ [n, n 2 ], we show an oracle of size S that answers queries inÕ(max{1, n 1.5 /S}) time. This new tradeoff is currently the best (up to polylogarithmic factors) for the entire range of S and improves by polynomial factors over all previously known tradeoffs for the range S ∈ [n, n 5/3 ].

We present an improved wavelet tree construction algorithm and discuss its applications to a number of rank/select problems for integer keys and strings.Given a string of length n over an alphabet of size σ ≤ n, our method builds the wavelet tree in O(n log σ/ √ log n) time, improving upon the state-of-the-art algorithm by a factor of √ log n. As a consequence, given an array of n integers we can construct in O(n √ log n) time a data structure consisting of O(n) machine words and capable of answering rank/select queries for the subranges of the array in O(log n/ log log n) time. This is a log log n-factor improvement in query time compared to Chan and Pȃtraşcu (SODA 2010) and a √ log n-factor improvement in construction time compared to Brodal et al. (Theor. Comput. Sci. 2011).Next, we switch to stringological context and propose a novel notion of wavelet suffix trees. For a string w of length n, this data structure occupies O(n) words, takes O(n √ log n) time to construct, and simultaneously captures the combinatorial structure of substrings of w while enabling efficient top-down traversal and binary search. In particular, with a wavelet suffix tree we are able to answer in O(log |x|) time the following two natural analogues of rank/select queries for suffixes of substrings: 1) For substrings x and y of w (given by their endpoints) count the number of suffixes of x that are lexicographically smaller than y; 2) For a substring x of w (given by its endpoints) and an integer k, find the k-th lexicographically smallest suffix of x. We further show that wavelet suffix trees allow to compute a run-length-encoded Burrows-Wheeler transform of a substring x of w (again, given by its endpoints) in O(s log |x|) time, where s denotes the length of the resulting runlength encoding. This answers a question by Cormode and Muthukrishnan (SODA 2005), who considered an analogous problem for Lempel-Ziv compression.All our algorithms, except for the construction of wavelet suffix trees, which additionally requires O(n) time in expectation, are deterministic and operate in the word RAM model.

We describe a data structure that stores a string S in space similar to that of its Lempel-Ziv encoding and efficiently supports access, rank and select queries. These queries are fundamental for implementing succinct and compressed data structures, such as compressed trees and graphs. We show that our data structure can be built in a scalable manner and is both small and fast in practice compared to other data structures supporting such queries.

No abstract

To store and search genomic databases efficiently, researchers have recently started building compressed self-indexes based on grammars. In this paper we show how, given a straight-line program with r rules for a string S[1..n] whose LZ77 parse consists of z phrases, we can store a self-index for S in O(r + z log log n) space such that, given a pattern P [1..m], we can list the occ occurrences of P in S in O m 2 + occ log log n time. If the straight-line program is balanced and we accept a small probability of building a faulty index, then we can reduce the O m 2 term to O(m log m). All previous self-indexes are larger or slower in the worst case. compression IntroductionWith the advance of DNA-sequencing technologies comes the problem of how to store many individuals' genomes compactly but such that we can search them quickly. Any two human genomes are 99.9% the same, but compressed self-indexes based on compressed suffix arrays, the Burrows-Wheeler Transform or LZ78 (see [1] for a survey) do not take full advantage of this similarity.Researchers have recently started building self-indexes based on context-free grammars (CFGs) and LZ77 [2], which better compress highly repetitive strings.A compressed self-index stores a string S[1..n] in compressed form such that,