[Paper Review] Encoding 2-D Range Maximum Queries

Mordecai J. Golin, John Iacono+4 more|arXiv (Cornell University)|Sep 13, 2011

Algorithms and Data Compression16 references13 citations

TL;DR

This paper presents tight bounds on the effective entropy of 2D range maximum queries (2D-RMQ), showing that random matrices require only O(N) expected bits for encoding, while small-row matrices (fixed m) achieve precise entropy bounds. It introduces efficient data structures using microtree decomposition and compressed representations to support O(k)-time queries with space close to the theoretical minimum.

ABSTRACT

We consider the \emph{two-dimensional range maximum query (2D-RMQ)} problem: given an array $A$ of ordered values, to pre-process it so that we can find the position of the smallest element in the sub-matrix defined by a (user-specified) range of rows and range of columns. We focus on determining the \emph{effective} entropy of 2D-RMQ, i.e., how many bits are needed to encode $A$ so that 2D-RMQ queries can be answered \emph{without} access to $A$. We give tight upper and lower bounds on the expected effective entropy for the case when $A$ contains independent identically-distributed random values, and new upper and lower bounds for arbitrary $A$, for the case when $A$ contains few rows. The latter results improve upon previous upper and lower bounds by Brodal et al. (ESA 2010). In some cases we also give data structures whose space usage is close to the effective entropy and answer 2D-RMQ queries rapidly.

Motivation & Objective

• To determine the effective entropy of 2D-RMQ, i.e., the minimum number of bits needed to encode an array so that maximum queries can be answered without accessing the original data.
• To improve upon prior bounds—especially those of Brodal et al.—for both random inputs and matrices with a small number of rows (fixed m).
• To design practical data structures whose space usage is close to the effective entropy, enabling efficient query resolution.
• To explore the implications of these results for succinct data structures and applications such as compressed suffix arrays and OLAP cubes.

Proposed method

• Proposes a microtree decomposition of the array into chunks, where each microtree represents a subtree of a Cartesian tree built over the 2D array.
• Uses a bit vector M to encode parent-child relationships and subtree structures, enabling reconstruction of any microtree in time linear in its size.
• Employs balanced parenthesis sequences and auxiliary structures (e.g., FID, rank/select) to support fast navigation and identification of microtrees and their constituent chunks.
• Reconstructs microtrees on demand using the stored bit vector M and auxiliary structures, ensuring O(k) query time for k-sized microtrees.
• Combines compressed representations of microtrees and chunk boundaries using bit vectors B1 and B2, which are stored via the FID structure to achieve O(n log k / k) bits of space.
• Uses a hierarchical decomposition strategy where each microtree is built recursively by comparing maxima in top and bottom rows, ensuring correct tree structure reconstruction.

Experimental results

Research questions

• RQ1 What is the effective entropy of 2D-RMQ for random matrices with i.i.d. uniform values?
• RQ2 How does the effective entropy scale for matrices with a fixed, small number of rows (m = O(1))?
• RQ3 Can we design data structures that use space close to the effective entropy while supporting fast 2D-RMQ queries?
• RQ4 How do the new bounds improve upon the previous Ω(N log m) lower bound and O(N min{m, log n}) upper bound by Brodal et al.?
• RQ5 What is the trade-off between space usage and query time in the encoding model for 2D-RMQ?

Key findings

• For random matrices with i.i.d. uniform values, the effective entropy is O(N) expected bits, significantly lower than the Ω(N log m) worst-case bound.
• For fixed m, the paper provides tight upper and lower bounds on the effective entropy, improving upon Brodal et al.'s bounds by determining precise constants for small m.
• The proposed data structure uses 5n + O(n log k / k) bits of space for any k = (log n)^O(1), achieving space close to the theoretical minimum.
• Query time is O(k) per microtree, and since only O(1) microtrees are accessed per query, the total query time is O(k).
• The structure supports dynamic reconstruction of microtrees from compressed bit vectors, enabling efficient on-demand access without storing full microtree representations.
• The results demonstrate that practical inputs (e.g., OLAP cubes) can be encoded using significantly less space than worst-case bounds suggest, especially when m is small or data is random.