Enumerating Range Modes

TL;DR

This paper introduces efficient algorithms for the range mode problem and its enumeration variant, optimizing query times especially for small maximum frequencies, filling a gap in existing solutions.

Contribution

It presents the first efficient algorithms for the range mode enumeration problem, with query times linear to output size and applicable to small maximum frequency cases.

Findings

Algorithms achieve linear query time relative to output size.

Efficient solutions for small maximum frequency scenarios.

Addresses a previously unsolved problem in range mode enumeration.

Abstract

We consider the range mode problem where given a sequence and a query range in it, we want to find items with maximum frequency in the range. We give time- and space- efficient algorithms for this problem. Our algorithms are efficient for small maximum frequency cases. We also consider a natural generalization of the problem: the range mode enumeration problem, for which there has been no known efficient algorithms. Our algorithms have query time complexities which is linear to the output size plus small terms.

Figures

Tables

Table 1. Table 1 . Complexities of data structures for the range mode problem where n 𝑛 n is the number of terms of a string and m 𝑚 m is the maximum frequency of an item. The space complexities do not include one for the input string.

Data structure	Space complexity (bits)	Query time complexity	conditions
[8]	$O\left(n^{2-2ϵ}\log n\right)$	$O\left(n^{ϵ}\right)$	$0\le ϵ\le 1/2$
[1]	$O\left(n^{2-2ϵ}\right)$	$O\left(n^{ϵ}\right)$	$0\le ϵ\le 1/2$
[9]	$O\left(\frac{n^2\log \log n}{\log n}\right)$	$O\left(1\right)$
[6]	$O\left(nm\log n\right)$	$O\left(\log m\right)$
[3]	$O\left(\left(n^{1-ϵ}m+n\right)\log n\right)$	$O\left(n^{ϵ}+\log \log n\right)$	$0\le ϵ\le 1/2$
Theorem 3.22	$O\left(4^{k}nm{\left(\frac{n}{m}\right)}^{\frac{1}{2^{2^k}}}\right)$	$O\left(2^k\right)$	$k$ is any positive integer
Theorem 3.29	$O\left(nm\right)$	$O\left(\min \{\log m,\log \log n\}\right)$
Corollary 3.24	$O\left(nm{\left(\log \log \frac{n}{m}\right)}^2\right)$	$O\left(\log \log \frac{n}{m}\right)$

Table 2. Table 2 . Complexities of data structures for the range mode enumeration problem where | 𝑜𝑢𝑡𝑝𝑢𝑡 | 𝑜𝑢𝑡𝑝𝑢𝑡 |{\it output}| denotes the number of solutions, n 𝑛 n the length of the input sequence, m 𝑚 m the maximum frequency of symbols, and ϵ italic-ϵ \epsilon is a parameter between 0 0 and 1 / 2 1 2 1/2 users can choose. Note that the space complexities does not contain that for the input sequence S 𝑆 S .

Data structure	Space (bits)	Query time
Theorem 4.6	$O\left(n^{2-2ϵ}\log n\right)$	$O\left(n^{ϵ}\left|\mathrm{𝑜𝑢𝑡𝑝𝑢𝑡}\right|\right)$
Theorem 4.19	$O\left(nm{\left(\log \log \frac{n}{m}\right)}^2+n\log n\right)$	$O\left(\log \log \frac{n}{m}+\left|\mathrm{𝑜𝑢𝑡𝑝𝑢𝑡}\right|\right)$
Theorem 4.20	$O\left(nm+n\log n\right)$	$O\left(\log m+\left|\mathrm{𝑜𝑢𝑡𝑝𝑢𝑡}\right|\right)$
Theorem 4.21	$O\left(n^{1+ϵ}\log n+n^{2-ϵ}\right)$	$O\left(\log m+n^{1-ϵ}+\left|\mathrm{𝑜𝑢𝑡𝑝𝑢𝑡}\right|\right)$

Equations

$$\displaystyle C[i][j]\leq C[i][j+1]\leq C[i][j]+1\ \ \$$

$$\displaystyle C[i][j]\leq C[i-1][j]\leq C[i][j]+1\ \ \$$

$$\displaystyle A[i][j]\leq A[i][j+1]\ \ \$$

$$\displaystyle A[i][j]\leq A[i+1][j]\ \ \$$

$$\displaystyle 0\leq A[i][j]<m\ \ \$$

$$d_{i,j}$$

$$($$

$$\{((i,j),(i+1,j))|A[i][j-1]<k\text{mbox}andA[i][j]\ge k\}$$

$$\cup \{((i,j),(i,j+1))|A[i-1][j]<k\text{mbox}andA[i][j]\ge k\},$$

$$(i,j)\mapsto (E[i][j],i-j+u-1).$$

$$\Psi :\{0,\dots ,m-1\}\times \{0,\dots ,2u-2\}\to \{0,\dots ,u-1{\}}^2\cup \{\perp \}$$

$$C[i][j]=\{\begin{array}{ll}f(i,j)& (i\le j),\\ 1& (\mathrm{otherwise}).\end{array}$$

$$\{i\mid S[i]\text{mbox}isamodeandS[i]\ne S[j]\text{mbox}foranyj=i+1,i+2,\dots ,l\}.$$

$$\displaystyle B[i][j]=1\Leftrightarrow i\leq j\mbox{and $S[j]$ is a mode of range $[i,j]$}$$

$$\text{mbox}Iff(i,j)=f(i+1,j)\text{mbox}andB[i+1][j]=1,\text{mbox}thenB[i][j]=1.$$

$$H[i][j]=\max \left\{\{k\mid f(k,j)=i\text{mbox}andB[k][j]=1\}\cup \{-1\}\right\}.$$

$$c{4}^{k-1}um{\left(\frac{u}{m}\right)}^{\frac{1}{2^{2^{k-1}}}}$$

$$=c{4}^{k-1}nm{\left(\frac{1}{t}\right)}^{\frac{1}{2^{2^{k-1}}}}$$

$$=c{4}^{k-1}nm{\left(\frac{m}{n}\right)}^{\frac{1}{2^{2^{k-1}}}\frac{1}{2^{2^{k-1}}}}$$

$$\le c{4}^{k-1}nm.$$

$$\sum _{\genfrac{}{}{0ex}{}{i,j}{B_{i,j}\text{mbox}notflat}}c{4}^{k-1}t{d}_{i,j}{\left(\frac{t}{d_{i,j}}\right)}^{\frac{1}{2^{2^{k-1}}}}$$

$$\le c{4}^{k-1}{t}^{1+\frac{1}{2^{2^{k-1}}}}\sum _{i,j}{d}_{i,j}\le c{4}^{k-1}{t}^{1+\frac{1}{2^{2^{k-1}}}}\cdot \frac{2nm}{t}$$

$$=2c\cdot 4^{k-1}nm{\left(\frac{n}{m}\right)}^{\frac{1}{2^{2^{k-1}}}\frac{1}{2^{2^{k-1}}}}=2c\cdot 4^{k-1}nm{\left(\frac{n}{m}\right)}^{\frac{1}{2^{2^k}}}.$$

$$c^{1/3}\sqrt{2um\cdot c\cdot 4^{k-1}nm{\left(\frac{n}{m}\right)}^{\frac{1}{2^{2^k}}}}\le c^{5/6}{2}^{k}nm.$$

$$\underset{\text{mbox}arrayE}{\underbrace{c{4}^{k-1}nm}}+\underset{\Psi }{\underbrace{(c^{1/3}\cdot 2\sqrt{2}+2)\frac{nm}{t}}}+\underset{\text{mbox}totalspaceforF}{\underbrace{2c\cdot 4^{k-1}nm{\left(\frac{n}{m}\right)}^{\frac{1}{2^{2^k}}}}}+\underset{P}{\underbrace{c^{5/6}{2}^{k}nm}}\mathrm{bits}.$$

$$c{4}^{k-1}nm+(2\sqrt{2}{c}^{1/3}+2)\frac{nm}{t}+2c\cdot 4^{k-1}nm{\left(\frac{n}{m}\right)}^{\frac{1}{2^{2^k}}}+c^{5/6}{2}^{k}nm$$

$$\le (c{4}^{k-1}+c^{1/3}2\sqrt{2}+2+2c\cdot 4^{k-1}+c^{5/6}{2}^k)nm{\left(\frac{n}{m}\right)}^{\frac{1}{2^{2^k}}}$$

$$\le c{4}^{k}nm{\left(\frac{n}{m}\right)}^{\frac{1}{2^{2^k}}}.$$

Full text

1. Introduction

We consider the range mode problem, defined as follows.

Definition 1.1** (Mode).**

Given a non-empty multiset $S$, $x\in S$ is said to be a mode of $S$, if its multiplicity is no smaller than those of any other elements.

Definition 1.2** (Range mode problem).**

For a sequence $A[0...n-1]$ and a range $[l,r]$ of $A$ ($0\leq l\leq r<n$), output any one of the modes of the multiset $\{A[l],A[l+1],\ldots,A[r-1],A[r]\}$.

The problem has many applications in data mining and data analysis [2, 4]. Moreover, there is a strong interest in theory community as well for this problem as it is related to the famous Boolean matrix multiplication and set intersection problem [1].

In this paper, we consider the indexing version of the range mode problem. That is, given a sequence of length $n$, we first construct a data structure, called an index. Then given a query range $[l,r]$, we solve the query using the index as well as the input. The algorithm is measured by the index size (in bits) and query time complexity. There are many existing work [8, 1, 9, 6, 3]111The papers [1, 3] have the same title, but some of the results in [3] do not appear in [1]. and some of them are summarized in Table 1.

Our first contribution is space-efficient indexes for the range mode problem, for the case the maximum multiplicity $m$ of an item in the set is small. Table 1 summarizes our results. The one in Corollary 3.24 has better time and space complexities than that of [3] with $\epsilon=0$, which is also specialized for small $m$ and has space complexity ${\rm O}(nm\log n)$ bits and query time complexity ${\rm O}(\log\log n)$.

Our second contribution is efficient indexes for the range mode enumeration problem, defined as follows.

Definition 1.3** (Range Mode Enumeration Problem).**

Given a sequence $A[0...n-1]$ and a query range $[l,r]\ (0\leq l\leq r<n)$, output all items with the largest number of occurrences in the multiset $\{A[l],A[l+1],\ldots,A[r-1],A[r]\}$.

Though the problem seems to be a natural generalization of the range mode problem, there has been no existing work. A related and important problem, the set intersection problem [1], has been considered. However, the set intersection problem can be reduced to the range mode enumeration problem, whereas the converse is not true. We cannot use existing algorithms for the set intersection problem to solve the range mode enumeration problem. A simple modification of an existing algorithm [3] works, but it takes ${\rm O}(n^{\epsilon})$ time for each output of an item (see Theorem 4.6). We give faster solutions whose query time complexity is linear to the output size plus some small term. Table 2 summarizes the results.

The paper is organized as follows. In Section 2, we review basic properties of the range mode problem and existing algorithms for the range mode problem. We also explain fundamental data structures for storing integer sequences. In Section 3, we give our improved algorithms for the range mode problem. In Section 4, we give algorithms for the range mode enumeration problem. Section 5 summaries the paper. Some of the proofs, algorithms, and figures are given in the appendix.

2. Preliminaries

2.1. Basic properties

To avoid confusion between modes and frequency of modes, from now on we consider range mode problems for not integer sequences but strings on an alphabet. We define the following.

• •

$S$: input string

• •

$n$: the length of string $S$

• •

$\Sigma$: the set of characters (alphabet) of $S$

• •

$f(l,r)$: the frequency of the modes of the substring $S[l,r]$

• •

$m$: the frequency of a character with maximum frequency, that is, $m=f(0,n-1)$

We assume that there exists a bijection $\Sigma\rightarrow\{0,1,\ldots,|\Sigma|-1\}$ which can be computed in constant time. We sometimes identify characters in the alphabet and integers.

Lemma 2.1**.**

[[7]] If non-empty multisets $M,M_{1}$ and a multiset $M_{2}$ satisfies $M=M_{1}\cup M_{2}$ and if $x$ is a mode of $M$, at least one of the following holds.

• •

$x$* is a mode of $M_{1}$.*

• •

$x$* belongs to $M_{2}$.*

Lemma 2.2**.**

For $l_{2}<l_{1}\leq r_{1}<r_{2}$, if $f(l_{1},r_{1})=f(l_{2},r_{2})$, modes of range $[l_{1},r_{1}]$ are also modes of range $[l_{2},r_{2}]$.

2.2. Algorithms for the range mode problem

We review the data structure with ${\rm O}(n^{2-2\epsilon})$-word space and ${\rm O}(n^{\epsilon})$ query time [3]. The input string $S$ of length $n$ is partitioned into $n/s=n^{1-\epsilon}$ blocks of length $s=n^{\epsilon}$ each. In addition to $S$, the data structure has the following four components.

**Two-dimensional array $A$: **

: For each character in the alphabet, an array for storing positions of its occurrences is used.

**Array $B$: **

: For each position $i$ of $S$, $B[i]$ stores the number of times that the character $S[i]$ occurs in the substring $S[0,\ldots,i-1]$.

**Two-dimensional array $C$: **

: The $(i,j)$ entry of $C$ stores the frequency of modes of the substring from the $i$-th block to the $j$-th block. That is, $C[i][j]=f(i\cdot s,(j+1)\cdot s-1)$.

**Two-dimensional array $D$: **

: The $(i,j)$ entry of $D$ stores one of the modes of the substring from the $i$-th block to the $j$-th block.

The space complexity is $O(n^{2-2\epsilon})$ words, for any fixed $0\leq\epsilon\leq 1/2$. Using these arrays, any query $[l,r]$ is solved in ${\rm O}(n^{\epsilon})$ time as follows. If a query is contained inside a block, we scan the range $[l,r]$ and for each character in the alphabet, we count its number of occurrences. This takes ${\rm O}(s)={\rm O}(n^{\epsilon})$ time. If a query range $[l,r]$ lies on more than one block, we partition the query range into prefix $[l,(b_{l}+1)s-1]$, span $[(b_{l}+1)s,b_{r}s-1]$, and suffix $[b_{r}s,r]$ where $b_{l}=\lfloor l/s\rfloor,b_{r}=\lfloor r/s\rfloor$. Note that the span may be empty.

From Lemma 2.1, modes of range $[l,r]$ are either (a) modes of the span, (b) a character in the prefix, or (c) a character in the suffix. For (b) and (c), we scan the prefix and the suffix, and for each character in them, we compute its frequency using the arrays $A$ and $B$ (for details refer to [3]). For (a), one of the modes of the span and its frequency is obtained from $D[b_{l}][b_{r}]$ and $C[b_{l}][b_{r}]$, respectively. This also takes ${\rm O}(s)={\rm O}(n^{\epsilon})$ time.

There exist improved data structures which are summarized in Table 1.

2.3. Representations of integer sequences

We define ${\it IMS}(n,u)$ (increasing monotone sequences) and ${\it DMS}(n,u)$ (decreasing monotone sequences) as follows.

Definition 2.3**.**

*We define ${\it IMS}(n,u)$ as the set of all integer sequences $A$ of length $n$ such that $0\leq A[0]\leq A[1]\leq\cdots\leq A[n-1]<u$. We also define ${\it DMS}(n,u)$ as the set of all integer sequences $A$ of length $n$ such that $u>A[0]\geq A[1]\geq\cdots\geq A[n-1]\geq 0$. *

Theorem 2.4** ([11]).**

For a sequence $A\in{\it IMS}(n,u)\ \ (n>u)$ and an integer $k\geq 0$, there exists a data structure using ${\rm O}(2^{k}n^{1/2^{k}}u^{1-1/2^{k}})$ bits which can compute

• •

${\sf access}(i,A)=A[i]$**

• •

${\sf bound}(i,A)=\#\{j\mid A[j]>i\}$**

in ${\rm O}(2^{k})$ time.

Theorem 2.5** (FID [10]).**

For a bit-vector $B$ of length $n$ which contains $u$ ones, consider the following operations.

• •

${\sf access}(i,B)$: returns the $i$-th bit of $B$.

• •

${\sf rank}_{c}(i,B)$: returns $\#\{j\mid B[j]=c\}$.

• •

${\sf select}_{c}(i,B)$: returns $\min\{j\mid{\sf rank}_{c}(j,B)=i\}$.

There exists a data structure which performs the operations in constant time using $\log\binom{n}{u}+\Theta\left(\frac{n\log\log n}{\log n}\right)$ bits of space.

3. Improved Data Structures for Range Mode Problem

We propose efficient data structures for the range mode problem using $m$, the largest frequency of characters, as a parameter.

Consider the data structure of Section 2.2 with $\epsilon=0$. For simplicity we define $C[i][j]=1$ for any $i,j$ with $i>j$. Then the $n\times n$ array $C$ satisfies the following property.

Property 1**.**

For any adjacent entries in the two-dimensional array $C$, it holds

[TABLE]

From the definition, $C$ also satisfies:

Property 2**.**

Any entry of $C$ is an integer between $1$ and $m$.

Below we propose a data structure for storing $C$ in a compressed form and supporting constant time access.

3.1. An efficient representation of the array $C$

We define the set of two-dimensional arrays which have both column-wise and row-wise monotonicity as follows.

Definition 3.1**.**

We define the set of two-dimensional arrays $A[0\ldots n-1][0\ldots n-1]$ which satisfy all the following inequalities as ${\it IMS2}(n,m)$.

[TABLE]

Theorem 3.2**.**

Let $A$ be a two-dimensional array in ${\it IMS2}(n,m)$ ($n\geq m$) and $k$ be a non-negative integer. There exists a data structure $S_{k}(n,m)$ which can output an entry of $A$ in ${\rm O}\left(2^{k}\right)$ time using ${\rm O}\left(4^{k}nm\left(\frac{n}{m}\right)^{\frac{1}{2^{2^{k}}}}\right)$ bits of space.

Proof 3.3**.**

We prove by induction on $k$ that there exists a data structure $S_{k}(n,m)$ using at most $c4^{k}nm\left(\frac{n}{m}\right)^{\frac{1}{2^{2^{k}}}}$ bits of space, where $c$ is some constant satisfying:

• •

There exists a data structure $Z(n,m)$ using at most ${c^{1/3}\sqrt{nm}}$ bits of space which can read an entry of ${\it IMS}(n,m)$ in constant time.

Below we show such a constant $c$ exists, if we use the data structure of Theorem 2.4.

For $k=0$, we use the data structure $Z(n,m)$ of Theorem 2.4 for storing each column. Then the space usage is at most $c^{1/3}n^{3/2}m^{1/2}$ bits, which is at most $cn^{3/2}m^{1/2}$ bits and the claim holds.

Now we assume that the data structure $S_{k-1}$ exists, and prove $S_{k}$ also exists. We partition the two-dimensional array into $u\times u$ blocks where $u=n/t$, each of which has $t=\left(\frac{n}{m}\right)^{\frac{1}{2^{2^{k-1}}}}$ columns and rows. The block corresponding to $A[it,\ldots,(i+1)t-1][jt,\ldots,(j+1)t-1]$ is a $t\times t$ two-dimensional array and denoted by $B_{i,j}$. We define flatness of a block as follows.

Definition 3.4**.**

A block is called flat if all the entries in the block are identical.

We also define the height of a block.

Definition 3.5**.**

The height of block $B_{i,j}$, denoted by $d_{i,j}$, is defined as

[TABLE]

That is, the height of a block is the difference between the maximum and the minimum values in the block, plus one.

We prove the following:

Theorem 3.6**.**

Among $u^{2}$ blocks, there are at most $2um$ non-flat blocks.

To prove it, we define $k$-th boundary in a block for $k=0,1,\ldots,m-1$ as follows.

Definition 3.7**.**

For a two-dimensional array $A\in{\it IMS2}(n,m)$, consider the $(n+1)\times(n+1)$ grid graph $G$. The $k$-th boundary of $A$ is defined as the edge set of $G$ satisfying:

[TABLE]

where we assume $A[-1][\cdot]=A[\cdot][-1]=-1$.

Then the following holds.

Property 3**.**

The $k$-th boundary is a shortest path from vertex $(0,n)$ to vertex $(n,0)$ of the grid graph $G$. That is, if we regard the path as a directed path from $(0,n)$ to $(n,0)$, the edges in the path are of the form of either $(i,j)\rightarrow(i+1,j)$ or $(i,j)\rightarrow(i,j-1)$.

Example 3.8**.**

Figure 1 shows an ${\it IMS2}(4,4)$ array and its second boundary.

Proof 3.9** (Proof of Theorem 3.6).**

It is equivalent that a block is flat, and that any boundary does not pass inside the block. For each of $m$ boundaries, the number of blocks in which the boundary passes is $2u$. Therefore the number of blocks which contains at least one boundary in it is at most $2um$.

Based on this property, we use the following data structure.

$E$**: to store ${\it IMS2}(u,m)$: **

We define $E[i][j]=A[it][jt]\ (0\leq i<u,0\leq j<u)$. It is clear that $E\in{\it IMS2}(u,m)$.

$F_{i,j}$**: to store differences inside block $B_{i,j}$: **

For non-flat block $B_{i,j}$, we define $F_{i,j}[x][y]:=B_{i,j}[x][y]-B_{i,j}[0][0]$. Then it holds $F_{i,j}\in{\it IMS2}(t,d_{i,j})$.

It holds for the original array $A$, $A[i][j]=E[i/t][j/t]+F_{i/t,j/t}[i\%t][j\%t]$, and for flat block $B_{i,j}$, the two-dimensional array $F_{i,j}$ is the zero-value array. Then an access to the array $A$ is done by Algorithm 1. At line 6 of the algorithm, it is necessary to decide if a block is flat or not. Because a naive data structure using a $u\times u$ Boolean array is space-consuming, we develop a space-efficient solution. To do so, we define the following mapping.

Definition 3.10** (Mapping to decide if a block is flat or not).**

*We define a mapping from a block number to a pair of integers $\Phi:\ \{0,\ldots,u-1\}^{2}\rightarrow\{0,\ldots,m-1\}\times\{0,\ldots,2u-2\}$ as *

[TABLE]

We obtain the following.

Theorem 3.11**.**

For any two distinct non-flat blocks $B_{i_{1},j_{1}}$ and $B_{i_{2},j_{2}}$, it holds $\Phi(i_{1},j_{1})\neq\Phi(i_{2},j_{2})$.

Proof 3.12**.**

Let $B_{i_{1},j_{1}}$ and $B_{i_{2},j_{2}}$ be two distinct non-flat blocks. From the definition of $\Phi$ the claim holds if $E[i_{1}][j_{1}]\neq E[i_{2}][j_{2}]$. If $E[i_{1}][j_{1}]=E[i_{2}][j_{2}]$, the $E[i_{2}][j_{2}]$-th boundary must pass both $B_{i_{1},j_{1}}$ and $B_{i_{2},j_{2}}$. It is however not possible to pass both of them if $i_{1}-j_{1}=i_{2}-j_{2}$ from Property 3. Thus it holds $\Phi(i_{1},j_{1})\neq\Phi(i_{2},j_{2})$.

We also define a mapping, which is something like an inverse of $\Phi$.

Definition 3.13**.**

We define a mapping

[TABLE]

as $\Psi(x,y)=(i,j)$ if there exists a non-flat block $B_{i,j}$ with $\Phi(i,j)=(x,y)$, and $\Psi(x,y)=\bot$ otherwise.

Then it holds $\mbox{block }b_{i,j}\mbox{ is not flat }\Leftrightarrow\Psi(\Phi(i,j))=(i,j)$. To use this fact, we have to compute both $\Psi$ and $\Phi$. We can compute $\Phi$ at line 3 of Algorithm 1 from Definition 3.10. To compute $\Psi$, we use the following.

Lemma 3.14**.**

Assume that $\Psi(x,y_{1})=(i_{1},j_{1}),\Psi(x,y_{2})=(i_{2},j_{2})$. Then if $y_{1}\leq y_{2}$, it holds $i_{1}\leq i_{2}$ and $j_{1}\geq j_{2}$.

Finally we obtain:

Theorem 3.15**.**

$\Psi(x,y)$* is computed in constant time using a data structure of $(2\sqrt{2}c^{1/3}+2)\displaystyle\frac{nm}{t}$ bits.*

Therefore the decision at line 6 of Algorithm 1 is done by using Algorithm 2.

We analyze the space complexity of the data structure $S_{k}$.

Lemma 3.16**.**

The size of the data structure $S_{k}$ is $c4^{k}nm\left(\frac{n}{m}\right)^{\frac{1}{2^{2^{k}}}}$

Next we consider the time $T_{k}$ to access an entry of $S_{k}$. In Algorithm 1, lines 3 and 5 take $T_{k-1}$ time. For other lines including the call to Algorithm 2 it takes constant time. Therefore it holds $T_{k}=2T_{k-1}+{\rm O}(1)$ and we obtain $T_{k}={\rm O}(2^{k})$.

This completes the proof of Theorem 3.2.

We also obtain:

Theorem 3.17**.**

There exists a data structure of ${\rm O}\left(nm\left(\log\log\frac{n}{m}\right)^{2}\right)$ bits supporting an access to ${\it IMS2}(n,m)\ (n>m)$ in ${\rm O}\left(\log\log\frac{n}{m}\right)$ time.

Proof 3.18**.**

We obtain the claim by letting $k=\log\log\log\frac{n}{m}$ in Theorem 3.2.

By using this data structure for a two-dimensional array $C$ satisfying Property 1, we can compute the frequency $f$ of the modes of a query range $[l,r]$. From Lemma 2.2, a mode is obtained by computing $S[\min\{x\mid C[l][x]=f\}]$. To compute this, consider the following data structure.

Theorem 3.19**.**

There exists a data structure of ${\rm O}(nm)$ bits for given column number $r$ of $A\in{\it IMS2}(n,m)$ and a value $h$, to compute $\min\{x\mid A[r][x]\geq h\}$ in constant time.

Proof 3.20**.**

For two-dimensional array $A$, consider the boundaries of Definition 3.7. We can say that $\min\{x\mid A[r][x]\geq h\}$ is the minimum row number of elements in $r$-th column which are above the $h$-th boundary. Recall that boundaries are shortest paths in the grid graph from vertex $(0,n)$ to vertex $(n,0)$. Consider to encode the $m$ boundaries as follows.

Definition 3.21** (A bit-vector representation of a boundary).**

We encode a boundary by a bit-vector of $2n$ bits as follows. Initially the bit-vector is set empty. We traverse the graph from vertex $(0,n)$ to vertex $(n,0)$ along the boundary, and append [math] when we go down, and $1$ when we go right, to the end of the bit-vector.

The bit-vector for a boundary has $n$ zeros and $n$ ones. There are $m$ such bit-vectors and the space complexity is ${\rm O}(nm)$ bits in total. Let $B_{k}$ denote the bit-vector for the $k$-th boundary. From definition, it holds $\min\{x\mid A[r][x]\geq h\}=n-{\sf rank}_{0}({\sf select}_{1}(r,B_{k}),B_{k})$. This can be computed in constant time by using FID.

Theorem 3.22**.**

In addition to the string $S$, by using a data structure of ${\rm O}\left(4^{k}nm\left(\frac{n}{m}\right)^{\frac{1}{2^{2^{k}}}}\right)$ bits, we can solve the range mode problem in ${\rm O}\left(2^{k}\right)$ time.

Proof 3.23**.**

We can use Algorithm 4, where the two-dimensional array $C$ satisfies the following:

[TABLE]

By storing the rows or columns in reverse order and subtracting one from all values, $C$ belongs to ${\it IMS2}(n,m)$.

In Algorithm 4, the data structures of Theorems 3.2 and 3.19 are used. The space complexity includes ${\rm O}\left(4^{k}nm\left(\frac{n}{m}\right)^{\frac{1}{2^{2^{k}}}}\right)$ bits for Theorem 3.2 and ${\rm O}(nm)$ bits for Theorem 3.19, and therefore the total space complexity is ${\rm O}\left(4^{k}nm\left(\frac{n}{m}\right)^{\frac{1}{2^{2^{k}}}}\right)$ bits.

By letting $k=\log\log\log\frac{n}{m}$ in Theorem 3.22, we obtain:

Corollary 3.24**.**

In addition to the string $S$, using a data structure of ${\rm O}\left(nm\left(\log\log\frac{n}{m}\right)^{2}\right)$ bits, the range mode problem is solved in ${\rm O}\left(\log\log\frac{n}{m}\right)$ time.

This data structure is superior to the data structure of [3] with $\epsilon=0$, which has space complexity ${\rm O}(nm\log n)$ bits and query time complexity ${\rm O}(\log\log n)$, in terms of both time and space.

3.2. Efficient data structure for small $m$

Instead of using the two-dimensional array $C$ storing frequencies of all the ranges, we can compute the frequency of modes using only the bit-vector representation of the boundaries of Definition 3.21.

Theorem 3.25**.**

For a two-dimensional array $A\in{\it IMS2}(n,m)$, there exists a data structure of ${\rm O}(nm)$ bits that given $i,j,k$, to decide if $A[i][j]\geq k$ in constant time.

Proof 3.26**.**

We store all the bit-vectors $B_{0},\ldots,B_{m-1}$ representing the boundaries. It is enough to decide if the $k$-th boundary of $A$ is either in the $(0,0)$’s side or $(n,n)$’ size with respect to $(i,j)$. This is done by Algorithm 3, which runs in constant time.

From Theorem 3.25, we can compute $C[i][j]=\max\{k|C[i][j]\geq k\}$ in ${\rm O}(\log m)$ time by a binary search on $k$.

Theorem 3.27**.**

There exists a data structure of ${\rm O}(nm)$ bits that for a given $(r,c)$ of $A\in{\it IMS2}(n,m)$, computes the value $h$ such that $h-\log n<A[r][c]\leq h$ in $O(\log\log n)$ time.

Proof 3.28**.**

For every column $r$ of $A$, we take the set of (at most $m/\log n$) row indexes $c$ such that $A[r][c]>A[r][c-1]$ and $A[r][c]$ is a multiple of $\log n$, and store the set using a predecessor data structure [12]. The space usage for each column is $O((m/\log n)\log n)=O(m)$ bits, and hence overall $O(nm)$ bits to represent $A$. The query is supported by finding the predecessor of $c$ in the predecessor data structure corresponding to the column $r$.

Now using the structure of Theorem 3.25, we can compute $C[i][j]=\max\{k|C[i][j]\geq k\}$ in ${\rm O}(\log\log n)$ time by a binary search on $k$, after narrowing down the length of the range of $k$ to $O(\log n)$ using the structure of Theorem 3.27. Furthermore, from Theorem 3.19, we can compute an index for modes in constant time. Now we obtain the following theorem.

Theorem 3.29**.**

In addition to the input string $S$, by using a data structure of ${\rm O}(nm)$ bits, the range mode problem is solved in ${\rm O}(\min\{\log m,\log\log n\})$ time.

Table 1 summarizes the proposed and known data structures.

4. Range Mode Enumeration Problem

Below we consider range modes of a string $S$ with alphabet size $\sigma$ instead of a sequence $A$. We evaluate algorithms with their space complexity and query time complexity using the size of the output $|{\it output}|$ as a parameter.

4.1. Algorithms using existing data structures

Data structures for the range mode problem return only arbitrary one item among all range modes. Instead here we consider a data structure for the problem which returns the leftmost index and the frequency of range modes, where the leftmost index is defined as follows.

Definition 4.1**.**

For a string $S$ and query range $[l,r]$, the leftmost index of range modes is defined as $\min\{x\mid S[x]\mbox{ is an item with the largest frequency in the query range }[l,r]\}$.

Lemma 4.2**.**

Let $D$ be a data structure which returns the leftmost index of range modes for a query range $[l,r]$ in time $t$ using $s$ space, there exists a data structure which solves the range mode enumeration problem in time $(t+O(1))|{\it output}|$ using $s$ space.

Proof 4.3**.**

Algorithm 5 solves the problem using the data structure $D$. The algorithm narrows the query range gradually. Because the data structure $D$ returns the leftmost index $i$ of range modes, the number of range modes for the new query range $[i+1,r]$ is exactly one smaller than that of the current query range. Therefore the while loop at line 6 of the algorithm is executed $|{\it output}|+1$ times, and the total time complexity is $(t+{\rm O}(1))|{\it output}|$.

Lemma 4.4**.**

There exists a data structure for finding the leftmost index of range modes and their frequency in time ${\rm O}(n^{\epsilon})$ using a data structure with space complexity ${\rm O}(n^{2-2\epsilon})$ words in addition to the input string $S$.

Proof 4.5**.**

We slightly change the data structure of [3] described in Section 2.2. Instead of the two-dimensional array $D$ storing modes of block ranges, we create another two-dimensional array $D^{\prime}$ storing leftmost indices of block ranges. Then we can find the leftmost index of span in constant time. For items appearing in the prefix and the suffix, we can find the leftmost index and its frequency using the same algorithm. Algorithm 6 gives a pseudo code.

From Lemmas 4.2 and 4.4, we obtain the following.

Theorem 4.6**.**

There exists a data structure for the range mode enumeration problem solving a query in ${\rm O}(n^{\epsilon}|{\it output}|)$ time using ${\rm O}(n^{2-2\epsilon}\log n)$ bits.

4.2. More efficient data structures for enumeration

Definition 4.7**.**

The mode index set for a query range $[l,r]$ of the range mode enumeration problem is the set of the rightmost position of each mode in the query range. That is,

[TABLE]

Because the set of all range modes can be obtained from the mode index set, below we focus on finding the mode index set.

Define $n$ bit-vectors $B[0],\ldots,B[n-1]$ of length $n$ each as follows.

[TABLE]

Using these bit-vectors, we obtain:

Theorem 4.8**.**

The set of modes for a query range $[l,r]$ is $\{x\mid f(l,x)=f(l,r)\wedge B[l][x]=1\}$.

Proof 4.9**.**

From the definition of $B[l][x]$, $S[x]$ is a mode of range $[l,r]$. From Lemma 2.2, $S[x]$ is also a mode of range $[l,r]$. Conversely, for any index $x$ contained in the index set for range $[l,r]$, it holds $f(l,x)=f(l,r)$ and $B[l][x]=1$. Therefore these two sets coincide.

Therefore we can enumerate items in the mode index set by using Algorithm 10.

Consider complexities of the algorithm. For the data structure $B$, which consists of $n$ bit-vectors of length $n$, we use ${\rm O}(n^{2})$ bits. We also use ${\rm O}(n^{2})$ bits for the array $C$ storing frequencies using bit-vectors, which is used to obtain frequency of modes of a query range. Therefore the total space is ${\rm O}(n^{2})$ bits. As for the time complexity, the algorithm executes Line 7 for ${\rm O}(|{\it output}|)$ times. Lines 3 and 4 takes constant time if we use data structures for bit-vectors. Therefore the total time complexity is ${\rm O}(|{\it output}|)$. We obtain the following basic data structure.

Theorem 4.10**.**

There exists a data structure for the range mode enumeration problem which computes the mode index set in ${\rm O}(|{\it output}|)$ time using a data structure of ${\rm O}(n^{2})$ bit space in addition to the input string $S$.

Now we improve this using a parameter $m$, the frequency of modes of the entire range. The following lemma holds for the two-dimensional bit-array $B$.

Lemma 4.11**.**

There is the following relation between function $f$ and bit-array $B$.

[TABLE]

Proof 4.12**.**

Because $B[i+1][j]=1$, $S[j]$ is a mode of range $[i+1,j]$. Using Lemma 2.2, it holds $S[j]$ is also a mode of range $[i,j]$. From the definition of $B$, we obtain $B[i][j]=1$.

Using this property, we define $m$ integer sequences $H[1],\ldots,H[m]$ of length $n$ each.

Definition 4.13**.**

Define integer sequences $H[1],\ldots,H[m]$ as follows.

[TABLE]

The bit-array $B$ and the sequences $H$ have the following relation.

Lemma 4.14**.**

$B[i][j]=1\Leftrightarrow H[f(i,j)][j]\geq i$.

Example 4.15**.**

Figure 2 shows an example of bit-array $B$ and sequences $H$ for string $S=\mbox{``abcbfcdaacfbcgba''}$.

Algorithm 10 enumerates indices with bits being set in range $[b,r]$ of bit-vector $B[l]$. Here for any $t$ with $b\leq t\leq r$, the value of $f(l,t)$ is always $g$. Therefore this operation is identical to enumerate all indices in range $[b,r]$ of sequence $H[g]$ whose value is at least $l$. This problem can be regarded as the range maximum problem.

Definition 4.16** (Range Maximum Problem (RMQ)).**

Given a sequence $A$ and query range $[l,r]$, the range maximum problem asks an index of the maximum value in the sub-sequence $A[l,\ldots,r]$.

Theorem 4.17** ([5]).**

For the range maximum problem of size $n$, there exists a data structure with space complexity $2n+{\rm o}(n)$ bits and query time complexity ${\rm O}(1)$.

Theorem 4.18**.**

Consider the following problem: Given a sequence $A$, a query range $[l,r]$ and a threshold $t$, compute $\{l\leq k\leq r\mid A[k]\geq t\}$. If there exists an oracle to check if it holds $A[k]\geq t$ for some $k$ in constant time, there exists a data structure for the problem with ${\rm O}(n)$ bits and ${\rm O}(|{\it output}|)$ query time.

Consider a data structure to decide if $H[f(l,r)][k]\geq l$ or not for finding the index set. This can be done by using the arrays $A,B$ in Section 2.2 because it is equivalent that $H[f(l,r)=g][k]\geq l$ and the frequency of $S[k]$ in range $[l,r]$ is at least $g$.

From the observation above, it is enough to use the following data structures to enumerate the solutions.

**Two-dimensional array $A$ storing positions of occurrences of symbols: **

An array to store positions of occurrences in ascending order for each symbol of the alphabet

**Array $B$ to store ranks for strings: **

An array storing the rank for each index of $S$, that is, $B[i]$ stores the number of times that the symbol $S[i]$ appears in the substring $S[0,\ldots,i-1]$.

**Two-dimensional array $C$ storing frequencies of modes for all ranges: **

The $(i,j)$ entry of the array $C$ stores the frequency of the modes for range $[i,j]$.

$m$** bit-vectors $D$ storing boundaries of the array $C$: **

The array stores $m$ bit-vectors of Definition 3.21.

**Two-dimensional array $H$ storing $m$ RMQ data structures for arrays of length $n$ each: **

An array storing $m$ sequences of Definition 4.13 as RMQ data structures. The sequences themselves are not stored.

The space complexity of the two-dimensional array $C$ varies depending on which data structure is used. For example, we can use ones in Theorems 3.17 and 3.29. The space complexities of $A,B,D,H$ are ${\rm O}(n\log n)$ bits, ${\rm O}(n\log n)$ bits, ${\rm O}(nm)$ bits, ${\rm O}(nm)$ bits, respectively.

The pseudo code is given in Algorithm 9. Only Line 3 cannot be done in constant time. For other lines, the time complexity is proportional to the number of times the function ${\it range}$ is executed, and it is ${\rm O}(|{\it output}|)$.

To recap, the complexities of the algorithms become ${\rm O}(S+nm+n\log n)$ bit space and ${\rm O}(T+|{\it output}|)$ query time, where $S$ is the space complexity of the two-dimensional array $C$, and $T$ is the time complexity to access an entry of $C$. Using Theorems 3.17 and 3.29, we obtain the following.

Theorem 4.19**.**

There exists a data structure with space complexity ${\rm O}\left(nm\left(\log\log\frac{n}{m}\right)^{2}+n\log n\right)$ bits in addition to the input string $S$, which solves a query in time ${\rm O}\left(\log\log\frac{n}{m}+|{\it output}|\right)$.

Theorem 4.20**.**

There exists a data structure with space complexity ${\rm O}(nm+n\log n)$ bits in addition to the input string $S$, which solves a query in time ${\rm O}(\log m+|{\it output}|)$.

By combining the data structure of [3], we can further reduce the space complexity. Consider a string $S_{1}$ which stores symbols of $S$ whose frequencies are at least $n^{1-\epsilon}$, and a string $S_{2}$ which stores the rest of the symbols. The string $S_{1}$ stores at most $n^{\epsilon}$ distinct symbols. Using the data structures of [3] and Theorem  4.20 for $S_{1}$ and $S_{2}$ respectively, the following holds.

Theorem 4.21**.**

There exists a data structure with space complexity ${\rm O}(n^{1+\epsilon}\log n+n^{2-\epsilon})$ bits in addition to the input string $S$, which solves a query in time ${\rm O}(\log m+n^{1-\epsilon}+|{\it output}|)$.

The proposed data structures for the range mode enumeration problem are summarized in Table 2.

5. Concluding Remarks

In this paper, we have given more efficient algorithms for the indexing version of the range mode problem. Our algorithms are more space- and time- efficient for small maximum frequency case than existing ones. We have also considered a natural extension of the range mode problem: range mode enumeration problem and given fast algorithms.

There are other related problems like Boolean matrix multiplication problem. A future work, we will give efficient algorithms for these problems.

Appendix A Omitted Proofs

A.1. Proof of Lemma 2.1

Proof A.1**.**

We prove by contradiction. Let $x$ be a mode of $M$, and assume $x$ is not a mode of $M_{1}$ and $x\notin M_{2}$. Let $y\in M_{1}$ be a mode of $M_{1}$. From the definition the multiplicity of $y$ in $M_{1}$ is strictly larger than that of $x$ in $M_{1}$. Because $x\notin M_{2}$, the multiplicity of $x$ in $M$ is equal to that of $x$ in $M_{1}$, and it is smaller than that of $y$ in $M$. This contradicts that $x$ is a mode of $M$.

A.2. Proof of Lemma 2.2

Proof A.2**.**

Let $c$ be any mode in range $[l_{1},r_{1}]$ and $m$ be its frequency. Because range $[l_{2},r_{2}]$ contains range $[l_{1},r_{1}]$, the frequency of $c$ in range $[l_{2},r_{2}]$ is at least $m$. On the other hand, because $f(l_{1},r_{1})=f(l_{2},r_{2})=m$, the frequency of $c$ in range $[l_{2},r_{2}]$ is at most $m$. Therefore the frequency of $c$ in range $[l_{2},r_{2}]$ becomes $m$ and $c$ is also a mode in range $[l_{2},r_{2}]$.

A.3. Proof of Lemma 3.16

If $u>m$, the space complexity of the two-dimensional array $E$ is, from the assumption of $S_{k-1}(u,m)$,

[TABLE]

If $u\leq m$, it can be stored in $c^{1/3}u^{3/2}m^{1/2}$ bits by using the data structure $Z(u,m)$ for each row. Therefore for any case $E$ can be stored in at most $c4^{k-1}nm$ bits.

Next we consider the space complexity of storing differences inside non-flat blocks.

Lemma A.3**.**

For the summation of all $d_{i,j}$, it holds $\displaystyle\sum_{0\leq i<u\atop 0\leq j<u}d_{i,j}\leq\frac{2mn}{t}$.

Proof A.4**.**

From the column-wise and row-wise monotonicity, for each $l=-u+1,\ldots,u-1$, it holds $\displaystyle\sum_{i-j=l}d_{i,j}\leq m$. By summing this for all $l$, we obtain the claim.

Consider the space complexity of the data structure storing $F_{i,j}\in{\it IMS2}(t,d_{i,j})$ for non-flat blocks $B_{i,j}$. If $t>d_{i,j}$, by using $S_{k-1}(t,d_{i,j})$, the space becomes $c4^{k-1}td_{i,j}\left(\frac{t}{d_{i,j}}\right)^{\frac{1}{2^{(2^{k-1})}}}$ bits. If $t\leq d_{i,j}$, we store each row of the two-dimensional array in $t\cdot c^{1/3}\sqrt{td_{i,j}}$ bits by using $Z(t,d_{i,j})$ which support constant access. For both time and space, the former case has worse complexities. Therefore we analyze the space by assuming every block is stored in $c4^{k-1}td_{i,j}\left(\frac{t}{d_{i,j}}\right)^{\frac{1}{2^{(2^{k-1})}}}$ bits.

[TABLE]

We also need to store pointers to the data structures $F_{i,j}$ because their size varies depending on $(i,j)$. As a bijection between $\{0,\ldots,m-1\}\times\{0,\ldots,2u-2\}$ and $\{0,1,\ldots,m(2u-1)\}$, we define $(i,j)\mapsto i(2u-1)+j$. By using this, we can regard the pointers to the data structures as a monotone increasing sequence $P$ with $2um$ terms and range $2c\cdot 4^{k-1}nm\left(\frac{n}{m}\right)^{\frac{1}{2^{2^{k}}}}$. By representing $P$ by the data structure $Z(2um,2c\cdot 4^{k-1}nm\left(\frac{n}{m}\right)^{\frac{1}{2^{2^{k}}}})$, it holds

[TABLE]

Therefore the space is upper-bounded by $c^{5/6}2^{k}nm$ bits.

The total space of the data structures for $S_{k}$ is:

[TABLE]

By letting $c\geq 10^{6}$, for any positive integer $k$, it holds

[TABLE]

This proves there exists a data structure of $c4^{k}nm\left(\frac{n}{m}\right)^{\frac{1}{2^{2^{k}}}}$ bits for $S_{k}(n,m)$.

A.4. Proof of Theorem 3.15

Proof A.5**.**

We use a two-dimensional Boolean array $K$ of $2um$ bits storing for each member $(x,y)$ of $\{0,\ldots,m-1\}\times\{0,\ldots,2u-2\}$, True if $\Psi(x,y)\neq\bot$ and False if $\Psi(x,y)=\bot$. In addition to this, for each $x$ we create two integer sequences $I_{x},J_{x}$ of length $2u-1$ each, as follows. For each $y\in\{0,\ldots,2u-2\}$, we define $(I_{x}[y],J_{x}[y])=\Psi(x,y)$ if $\Psi(x,y)\neq\bot$. If $\Psi(x,y)=\bot$, we choose arbitrary values for $I_{x}[y]$ and $J_{x}[y]$ satisfying $I_{x}[y]\in{\it IMS}(2u-1,u),J_{x}[y]\in{\it DMS}(2u-1,u)$. From Lemma 3.14, such sequences $I_{x},J_{x}$ must exist. By using the data structure $Z(2u-1,u)$ we can store each sequence in at most $\sqrt{2}c^{1/3}u$ bits and access in constant time. The total space for these $2m$ sequences is at most $2um+2\sqrt{2}c^{1/3}um=(2\sqrt{2}c^{1/3}+2)\displaystyle\frac{nm}{t}$ bits.

A.5. Proof of Theorem 4.18

Proof A.6**.**

We recursively find range maximum values as in Algorithm 7. Consider the number of times that the function ${\it range}$ of Algorithm 8 is called. The number of times that an item is added to the set ${\it ans}$ in the function is at most $|{\it output}|$. On the other hand, if ${\it ans}=\{x_{1},\ldots,x_{|{\it output}|}\}$, the number of times that any item is not added to the set ${\it ans}$ is at most $|{\it output}|+1$, for ranges $[l,x_{1}-1],[x_{1}+1,x_{2}-1],\ldots,[x_{|{\it output}|-1}+1,x_{|{\it output}|}-1],[x_{|{\it output}|}+1,r]$. Therefore the total number of times that ${\it range}$ is called is at most $2|{\it output}|+1$. From the assumption of the oracle, Algorithm 7 runs in ${\rm O}(|{\it output}|)$ time. Because the algorithm uses no data structures other than RMQ, the space complexity is ${\rm O}(n)$ bits.

Appendix B Omitted Pseudo codes and Figures