Compressed Range Minimum Queries

Abstract

Given a string S of n integers in [0, σ), a range minimum query RMQ(i, j) asks for the index of the smallest integer in S[i . . . j]. It is well known that the problem can be solved with a succinct data structure of size 2n + o(n) and constant query-time. In this paper we show how to preprocess S into a compressed representation that allows fast range minimum queries. This allows for sublinear size data structures with logarithmic query time. The most natural approach is to use string compression and construct a data structure for answering range minimum queries directly on the compressed string. We investigate this approach in the context of grammar compression. We then consider an alternative approach. Instead of compressing S using string compression, we compress the Cartesian tree of S using tree compression. We show that this approach can be exponentially better than the former, is never worse by more than an O(σ) factor (i.e. for constant alphabets it is never asymptotically worse), and can in fact be worse by an Ω(σ) factor.

Balancing Straight-Line Programs

“…7 As the time bound O(log σ • log n) comes from the height of the constructed top dag, using Corollary 12.3 we can enforce the bound O(log n) on the height of the constructed top dag and ensure that the transformation can be applied to any input SSLP. This yields the following improvement of the result of [19]: The rest of the paper is devoted to the proof of Theorem 9.1.…”

“…, s j (the substring of s from position i to j). We are interested in the variant of the problem, in which the input is given as an SSLP G. It is known, that after a preprocessing taking O(|G|) time, one can answer range minimum queries in time O(log n) [19,Theorem 1.1]. This implementation extends the data structure for random access for SSLP [8] with some additional information, which includes in particular adding standard range minimum data structures for subtrees leaving the heavy path and extending the original analysis.…”

“…In [19] top dags have been used for compressed range minimum queries (RMQs). It is well known that for a string s of integers one can reduce RMQs to lowest common ancestor queries on the Cartesian tree corresponding to s. Two compressed data structures for answering RMQs for s are proposed in [19]: one is based on an SSLP for s (we commented on it already in Section 10), the other one uses a top dag for the Cartesian tree corresponding to s. The following result has been shown, see [19,Corollary 1.4]: Given a string s of length n over an alphabet of σ many integers, let m opt denote the size of a smallest SSLP for s. There is a top dag G for the Cartesian tree corresponding to s of size |G| ≤ min(O(n/ log n), O(m opt • log n • σ)), and there is a data structure of size O(|G|) that answers range minimum queries on s in time O(log σ • log n). 7 As the time bound O(log σ • log n) comes from the height of the constructed top dag, using Corollary 12.3 we can enforce the bound O(log n) on the height of the constructed top dag and ensure that the transformation can be applied to any input SSLP.…”

“…Note that[19, Corollary 1.4] states the size bound |G| ≤ min(O(n/ log n), O(mopt • σ)), i.e., without the additional log n factor. However, this seems to be a typo: the proof follows by an algorithmic transformation of an SSLP G 0 for s to a top dag for the Cartesian tree of size O(|G 0 |•σ) and depth O(log σ • depth(G 0 )).…”