Fast Algorithms for the Shortest Unique Palindromic Substring Problem on Run-Length Encoded Strings

TL;DR

This paper introduces efficient algorithms for identifying shortest unique palindromic substrings in run-length encoded strings, enabling fast query responses with optimized preprocessing.

Contribution

It presents novel algorithms for SUPS queries on RLE strings, including variants with faster query times and efficient preprocessing methods.

Findings

Preprocessing time is linear in RLE size.

Query times are sub-logarithmic for SUPS retrieval.

Algorithms work on run-length encoded representations, reducing complexity.

Abstract

For a string $S$, a palindromic substring $S[i..j]$ is said to be a \emph{shortest unique palindromic substring} ($\mathit{SUPS}$) for an interval $[s, t]$ in $S$, if $S[i..j]$ occurs exactly once in $S$, the interval $[i, j]$ contains $[s, t]$, and every palindromic substring containing $[s, t]$ which is shorter than $S[i..j]$ occurs at least twice in $S$. In this paper, we study the problem of answering $\mathit{SUPS}$ queries on run-length encoded strings. We show how to preprocess a given run-length encoded string $\mathit{RLE}_{S}$ of size $m$ in $O(m)$ space and $O(m \log \sigma_{\mathit{RLE}_{S}} + m \sqrt{\log m / \log\log m})$ time so that all $\mathit{SUPSs}$ for any subsequent query interval can be answered in $O(\sqrt{\log m / \log\log m} + \alpha)$ time, where $\alpha$ is the number of outputs, and $\sigma_{\mathit{RLE}_{S}}$ is the number of distinct runs of $\mathit{RLE}_{S}$. Additionaly, we consider a variant of the SUPS problem where a query interval is also given in a run-length encoded form. For this variant of the problem, we present two alternative algorithms with faster queries. The first one answers queries in $O(\sqrt{\log\log m /\log\log\log m} + \alpha)$ time and can be built in $O(m \log \sigma_{\mathit{RLE}_{S}} + m \sqrt{\log m / \log\log m})$ time, and the second one answers queries in $O(\log \log m + \alpha)$ time and can be built in $O(m \log \sigma_{\mathit{RLE}_{S}})$ time. Both of these data structures require $O(m)$ space.

Equations

$${\mathsf{Pred}}_B(k)$$

$${\mathsf{Succ}}_B(k)$$

$$S[Rb[i-(s^{\prime }+(t^{\prime }-k)d^{\prime })]-\min \{e_{i-s^{\prime }-1},e_i\}..Re[i-1]+\min \{e_{i-s^{\prime }-1},e_i\}]=$$

$$S[Rb[i-(s^{\prime }+(t^{\prime }-(k-1))d^{\prime })]-\min \{e_{i-s^{\prime }-1},e_i\}..Re[i-d^{\prime }-1]+\min \{e_{i-s^{\prime }-1},e_i\}].$$

Full text

1 Introduction

The shortest unique substring (SUS) problem, which is formalized below, is a recent trend in the string processing community. Consider a string $S$ of length $n$. A substring $X=S[i..j]$ of $S$ is called a SUS for a position $p$ ($1\leq p\leq n$) iff the interval $[i..j]$ contains $p$, $X$ occurs in $S$ exactly once, and every substring containing $p$ which is shorter than $S[i..j]$ occurs at least twice in $S$. The SUS problem is to preprocess a given string $S$ so that SUSs for query positions $p$ can be answered quickly. The study on the SUS problem was initiated by Pei et al., and is motivated by an application to bioinformatics e.g., designing polymerase chain reaction (PCR) primer [13]. Pei et al. [13] showed an $\Theta(n^{2})$-time and space preprocessing scheme such that all $k$ SUSs for a query position can be answered in $O(k)$ time. Later, two independent groups, Tsuruta et al. [15] and Ileri et al. [8], showed algorithms that use $\Theta(n)$ time and space111Throughout this paper, we measure the space complexity of an algorithm with the number of words that the algorithm occupies in the word RAM model, unless otherwise stated. for preprocessing, and all SUSs can be answered in $O(k)$ time per query. To be able to handle huge text data where $n$ can be massively large, there have been further efforts to reduce the space usage. Hon et al. [6] proposed an “in-place” algorithm which works within space of the input string $S$ and two output arrays $A$ and $B$ of length $n$ each, namely, in $n\log_{2}\sigma$ bits plus $2n$ words of space. After the execution of their algorithm that takes $O(n)$ time, the beginning and ending positions of a SUS for each text position $i$ ($1\leq i\leq n$) are consequently stored in $A[i]$ and $B[i]$, respectively, and $S$ remains unchanged. Hon et al.’s algorithm can be extended to handle SUSs with approximate matches, with a penalty of $O(n^{2})$ preprocessing time. For a pre-determined parameter $\tau$, Ganguly et al. [5] proposed a time-space trade-off algorithm for the SUS problem that uses $O(n/\tau)$ additional working space (apart from the input string $S$) and answers each query in $O(n\tau^{2}\log\frac{n}{\tau})$ time. They also proposed a “succinct” data structure of $4n+o(n)$ bits of space that can be built in $O(n\log n)$ time and can answer a SUS for each given query position in $O(1)$ time. Another approach to reduce the space requirement for the SUS problem is to work on a “compressed” representation of the string $S$. Mieno et al. [12] developed a data structure of $\Theta(m)$ space (or $\Theta(m\log n)$ bits of space) that answers all $k$ SUSs for a given position in $O(\sqrt{\log m/\log\log m}+k)$ time, where $m$ is the size of the run length encoding (RLE) of the input string $S$. This data structure can be constructed in $O(m\log m)$ time with $O(m)$ words of working space if the input string $S$ is already compressed by RLE, or in $O(n+m\log m)$ time with $O(m)$ working space if the input string $S$ is given without being compressed.

A generalized version of the SUS problem, called the interval SUS problem, is to answer SUSs that contain a query interval $[s,t]$ with $1\leq s\leq t\leq n$. Hu et al. [7] proposed an optimal $\Theta(n)$ time and space algorithm to preprocess a given string $S$ so that all $k$ SUSs for a given query interval are reported in $O(k)$ time. Mieno et al.’s data structure [12] also can answer interval SUS queries with the same preprocessing time/space and query time as above.

Recently, a new variant of the SUS problem, called the shortest unique palindromic substring (SUPS) problem is considered [9]. A substring $P=S[i..j]$ is called a SUPS for an interval $[s,t]$ iff $P$ occurs exactly once in $S$, $[s,t]\subseteq[i,j]$, and every palindromic substring of $S$ which contains interval $[s,t]$ and is shorter than $P$ occurs at least twice in $S$. The study on the SUPS problem is motivated by an application in molecular biology. Inoue et al. [9] showed how to preprocess a given string $S$ of length $n$ in $\Theta(n)$ time and space so that all $\alpha$ SUPSs (if any) for a given interval can be answered in $O(\alpha+1)$ time222It is possible that $\alpha=0$ for some intervals.. While this solution is optimal in terms of the length $n$ of the input string, no space-economical solutions for the SUPS problem were known.

In this paper, we present the first space-economical solution to the SUPS problem based on RLE. The proposed algorithm computes a data structure of $\Theta(m)$ space that answers each SUPS query in $O(\sqrt{\log m/\log\log m}+\alpha)$ time. The most interesting part of our algorithm is how to preprocess a given RLE string of length $m$ in $O(m(\log\sigma_{RLE_{S}}+\sqrt{\log m/\log\log m}))$ time, where $\sigma_{RLE_{S}}$ is the number of distinct runs in the RLE of $S$. Note that $\sigma_{RLE}\leq m$ always holds. For this sake, we propose RLE versions of Manacher’s maximal palindrome algorithm [10] and Rubinchik and Shur’s eertree data structure [14], which may be of independent interest. We remark that our preprocessing scheme is quite different from Mieno et al.’s method [12] for the SUS problem on RLE strings and Inoue et al.’s method [9] for the SUPS problem on plain strings.

Additionaly, we consider a variant of the SUPS problem where a query interval is also given in a run-length encoded form. For this variant of the problem, we present two alternative algorithms with faster queries. The first one answers queries in $O(\sqrt{\log\log m/\log\log\log m}+\alpha)$ time and can be built $O(m\log\sigma_{\mathit{RLE}_{S}}+m\sqrt{\log m/\log\log m})$ time, and the second one answers queries in $O(\log\log m+\alpha)$ time and can be built in $O(m\log\sigma_{\mathit{RLE}_{S}})$ time. Both of these data structures require $O(m)$ space.

A part of the results presented here appeared in a preliminary version of this paper [16].

2 Preliminaries

2.1 Strings

Let $\Sigma$ be an ordered alphabet of size $\sigma$. An element of $\Sigma^{*}$ is called a string. The length of a string $S$ is denoted by $|S|$. The empty string $\varepsilon$ is a string of length 0. For a string $S=XYZ$, $X$, $Y$ and $Z$ are called a prefix, substring, and suffix of $S$, respectively. The $i$-th character of a string $S$ is denoted by $S[i]$, for $1\leq i\leq|S|$. Let $S[i..j]$ denote the substring of $S$ that begins at position $i$ and ends at position $j$, for $1\leq i\leq j\leq|S|$. For convenience, let $S[i..j]=\varepsilon$ for $i>j$.

For any string $S$, let ${S}^{\mathit{R}}=S[|S|]\cdots S[1]$ denote the reversed string of $S$. A string $P$ is called a palindrome iff $P={P}^{\mathit{R}}$. A substring $P=S[i..j]$ of a string $S$ is called a palindromic substring iff $P$ is a palindrome. For a palindromic substring $P=S[i..j]$, $\frac{i+j}{2}$ is called the center of $P$. A palindromic substring $P=S[i..j]$ is said to be a maximal palindrome of $S$, iff $S[i-1]\neq S[j+1]$, $i=1$ or $j=|S|$. A suffix of string $S$ that is a palindrome is called a suffix palindrome of $S$. Clearly any suffix palindrome of $S$ is a maximal palindrome of $S$.

We will use the following lemma in the analysis of our algorithm.

Lemma 1** ([4]).**

Any string of length $k$ can contain at most $k+1$ distinct palindromic substrings (including the empty string $\varepsilon$).

2.2 MUPSs and SUPSs

For any strings $X$ and $S$, let $\mathit{occ}_{S}(X)$ denote the number of occurrences of $X$ in $S$, i.e., $\mathit{occ}_{S}(X)=|\{i\mid S[i..i+|X|-1]=X\}|$. A string $X$ is called a unique substring of a string $S$ iff $\mathit{occ}_{S}(X)=1$. A substring $P=S[i..j]$ of string $S$ is called a minimal unique palindromic substring (MUPS) of a string $S$ iff (1) $P$ is a unique palindromic substring of $S$ and (2) either $|P|\geq 3$ and the palindrome $Q=S[i+1..j-1]$ satisfies $\mathit{occ}_{S}(Q)\geq 2$, or $1\leq|P|\leq 2$.

Lemma 2** ([9]).**

MUPSs do not nest, namely, for any pair of distinct MUPSs, one cannot contain the other.

Due to Lemma 2, both of the beginning positions and the ending positions of MUPSs are monotonically increasing. Let $\mathcal{M}_{S}$ denote the list of MUPSs in $S$ sorted in increasing order of their beginning positions (or equivalently the ending positions) in $S$.

Let $[s,t]$ be an integer interval over the positions in a string $S$, where $1\leq s\leq t\leq|S|$. A substring $P=S[i..j]$ of string $S$ is called a shortest unique palindromic substring (SUPS) for interval $[s,t]$ of $S$, iff (1) $P$ is a unique palindromic substring of $S$, (2) $[s,t]\subseteq[i,j]$, and (3) there is no unique palindromic substring $Q=S[i^{\prime}..j^{\prime}]$ such that $[s,t]\subseteq[i^{\prime},j^{\prime}]$ and $|Q|<|P|$. We give an example in Fig. 1.

2.3 Run length encoding (RLE)

The run-length encoding $\mathit{RLE}_{S}$ of string $S$ is a compact representation of $S$ such that each maximal run of the same characters in $S$ is represented by a pair of the character and the length of the run. More formally, let $\mathcal{N}$ denote the set of positive integers. For any non-empty string $S$, $\mathit{RLE}_{S}=(a_{1},e_{1}),\ldots,(a_{m},e_{m})$, where $a_{j}\in\Sigma$ and $e_{j}\in\mathcal{N}$ for any $1\leq j\leq m$, and $a_{j}\neq a_{j+1}$ for any $1\leq j<m$. E.g., if $S=\mathtt{aacccccccbbabbbb}$, then $\mathit{RLE}_{S}=(\mathtt{a},2),(\mathtt{c},7),(\mathtt{b},2),(\mathtt{a},1),(\mathtt{b},4)$. Each $(a,e)$ in $\mathit{RLE}_{S}$ is called a (character) run, and $e$ is called the exponent of this run. We also denote each run by $a^{e}$ when it seems more convenient and intuitive. For example, we would write as $(a,e)$ when it seems more convenient to treat it as a kind of character (called an RLE-character), and would write as $a^{e}$ when it seems more convenient to treat it as a string consisting of $e$ $a$’s.

The size of $\mathit{RLE}_{S}$ is the number $m$ of runs in $\mathit{RLE}_{S}$. Let $\mathit{Rb}[j]$ (resp. $\mathit{Re}[j]$) denote the beginning (resp. ending) position of the $j$th run in the string $S$, i.e., $\mathit{Rb}[j]=1+\sum_{i=0}^{j-1}e_{i}$ with $e_{0}=0$ and $\mathit{Re}[j]=\sum_{i=1}^{j}e_{i}$. The center of the $j$th run is $\frac{\mathit{Rb}[j]+\mathit{Re}[j]}{2}$.

For any two ordered pairs $(a,e),(a^{\prime},e^{\prime})\in\Sigma\times\mathcal{N}$ of a character and positive integer, we define the equality such that $(a,e)=(a^{\prime},e^{\prime})$ iff $a=a^{\prime}$ and $e=e^{\prime}$ both hold. We also define a total order of these pairs such that $(a,e)<(a^{\prime},e^{\prime})$ iff $a<a^{\prime}$, or $a=a^{\prime}$ and $e<e^{\prime}$.

An occurrence of a palindromic substring $P=S[i..i^{\prime}]$ of a string $S$ with $\mathit{RLE}_{S}$ of size $m$ is said to be RLE-bounded if $i=\mathit{Rb}[j]$ and $i^{\prime}=\mathit{Re}[j^{\prime}]$ for some $1\leq j\leq j^{\prime}\leq m$, namely, if both ends of the occurrence touch the boundaries of runs. An RLE-bounded occurrence $P=S[i..i^{\prime}]$ is said to be RLE-maximal if $(a_{j-1},e_{j-1})\neq(a_{j^{\prime}+1},e_{j^{\prime}+1})$, $j=1$ or $j^{\prime}=m$. Note that an RLE-maximal occurrence of a palindrome may not be maximal in the string $S$. E.g., consider string $S=\mathtt{caabbcccbbaaaac}$ with $\mathit{RLE}_{S}=\mathtt{c^{1}a^{2}b^{2}c^{3}b^{2}a^{4}c^{1}}$.

• •

The occurrence of palindrome $\mathtt{c^{3}}$ is RLE-bounded but is neither RLE-maximal nor maximal.

• •

The occurrence of palindrome $\mathtt{b^{2}c^{3}b^{2}}$ is RLE-maximal but is not maximal.

• •

The occurrence of palindrome $\mathtt{a^{2}b^{2}c^{3}b^{2}a^{2}}$ is not RLE-maximal but is maximal.

• •

The first (leftmost) occurrence of palindrome $\mathtt{a^{2}}$ is both RLE-maximal and maximal.

2.4 Problem

In what follows, we assume that our input strings are given as RLE strings. In this paper, we tackle the following problem.

Problem 1** ($\mathit{SUPS}$ problem on run-length encoded strings).**

Preprocess:

$\mathit{RLE}_{S}=(a_{1},e_{1}),\ldots,(a_{m},e_{m})$ of size $m$ representing a string $S$ of length $n$.

Query:

An integer interval $[s,t]$ $(1\leq s\leq t\leq n)$.

Return:

All SUPSs for interval $[s,t]$.

In case the string $S$ is given as a plain string of length $n$, then the time complexity of our algorithm will be increased by an additive factor of $n$ that is needed to compute $\mathit{RLE}_{S}$, while the space usage will stay the same since $\mathit{RLE}_{S}$ can be computed in constant space.

3 Computing MUPSs from RLE strings

The following known lemma suggests that it is helpful to compute the set $\mathcal{M}_{S}$ of MUPSs of $S$ as a preprocessing for the SUPS problem.

Lemma 3** ([9]).**

For any SUPS $S[i..j]$ for some interval, there exists exactly one MUPS that is contained in the interval $[i,j]$. Furthermore, the MUPS has the same center as the SUPS $S[i..j]$.

3.1 Properties of MUPSs on RLE strings

Now we present some useful properties of MUPSs on the run-length encoded string $\mathit{RLE}_{S}=(a_{1},e_{1}),\ldots,(a_{m},e_{m})$.

Lemma 4**.**

For any MUPS $S[i..j]$ in $S$, there exists a unique integer $k$ ($1\leq k\leq m$) such that $\frac{i+j}{2}=\frac{\mathit{Rb}[k]+\mathit{Re}[k]}{2}$.

Proof.

Suppose on the contrary that there is a MUPS $S[i..j]$ such that $\frac{i+j}{2}\neq\frac{\mathit{Rb}[k]+\mathit{Re}[k]}{2}$ for any $1\leq k\leq m$. Let $l$ be the integer that satisfies $\mathit{Rb}[l]\leq\frac{i+j}{2}\leq\mathit{Re}[l]$. By the assumption, the longest palindrome whose center is $\frac{i+j}{2}$ is $a_{l}^{\min\{i-\mathit{Rb}[l]+1,\mathit{Re}[l]-j+1\}}$. However, this palindrome $a_{l}^{\min\{i-\mathit{Rb}[l]+1,\mathit{Re}[l]-j+1\}}$ occurs at least twice in the $l$th run $a_{l}^{e_{l}}$. Hence MUPS $S[i..j]$ is not a unique palindromic substring, a contradiction. ∎

The following corollary is immediate from Lemma 4.

Corollary 1**.**

For any string $S$, $|\mathcal{M}_{S}|\leq m$.

It is easy to see that the above bound is tight: for instance, any string where each run has a distinct character (i.e., $m=\sigma_{\mathit{RLE}}$) contains exactly $m$ MUPSs. Our preprocessing and query algorithms which will follow are heavily dependent on this lemma and corollary.

3.2 RLE version of Manacher’s algorithm

Due to Corollary 1, we can restrict ourselves to computing palindromic substrings whose center coincides with the center of each run. These palindromic substrings are called run-centered palindromes. Run-centered palindromes will be candidates of MUPSs of the string $S$.

To compute run-centered palindromes from $\mathit{RLE}_{S}$, we utilize Manacher’s algorithm [10] that computes all maximal palindromes for a given (plain) string of length $n$ in $O(n)$ time and space. Manacher’s algorithm is based only on character equality comparisons, and hence it works with general alphabets.

Let us briefly recall how Manacher’s algorithm works. It processes a given string $S$ of length $n$ from left to right. It computes an array $\mathbf{MaxPal}$ of length $2n-1$ such that $\mathbf{MaxPal}{}[c]$ stores the length of the maximal palindrome with center $c$ for $c=1,1.5,2,\ldots,n-1,n-0.5,n$. Namely, Manacher’s algorithm processes a given string $S$ in an online manner from left to right. This algorithm is also able to compute, for each position $i=1,\ldots,n$, the longest palindromic suffix of $S[1..i]$ in an online manner.

Now we apply Manacher’s algorithm to our run-length encoded input string $\mathit{RLE}_{S}=(a_{1},e_{1}),\ldots,$ $(a_{m},e_{m})$. Then, what we obtain after the execution of Manacher’s algorithm over $\mathit{RLE}_{S}$ is all RLE-maximal palindromes of $S$. Note that by definition all RLE-maximal palindromes are run-centered. Since $\mathit{RLE}_{S}$ can be regarded as a string of length $m$ over an alphabet $\Sigma\times\mathcal{N}$, this takes $O(m)$ time and space.

Remark 1*.*

If wanted, we can compute all maximal palindromes of $S$ in $O(m)$ time after the execution of Manacher’s algorithm to $\mathit{RLE}_{S}$. First, we compute every run-centered maximal palindrome $P_{l}$ that has its center in each $l$th run in $\mathit{RLE}_{S}$. For each already computed run-centered RLE-maximal palindrome $Q_{l}=S[\mathit{Rb}[i]..\mathit{Re}[j]]$ with $1<i\leq j<m$, it is enough to first check whether $a_{i-1}=a_{j+1}$. If no, then $P_{l}=Q_{l}$, and if yes then we can further extend both ends of $Q_{l}$ with $(a_{i-1},\min\{e_{i-1},e_{j+1}\})$ and obtain $P_{l}$. As a side remark, we note that any other maximal palindromes of $S$ are not run-centered, which means that any of them consists only of the same characters and lie inside of one character run. Such maximal palindromes are trivial and need not be explicitly computed.

3.3 RLE version of eertree data structure

The eertree [14] of a string $S$, denoted $\mathsf{eertree}(S)$, is a pair of two rooted trees $\mathsf{T}_{\mathrm{odd}}$ and $\mathsf{T}_{\mathrm{even}}$ which represent all distinct palindromic substrings of $S$. The root of $\mathsf{T}_{\mathrm{odd}}$ represents the empty string $\varepsilon$ and each non-root node of $\mathsf{T}_{\mathrm{odd}}$ represents a non-empty palindromic substring of $S$ of odd length. Similarly, the root of $\mathsf{T}_{\mathrm{even}}$ represents the empty string $\varepsilon$ and each non-root node of $\mathsf{T}_{\mathrm{even}}$ represents a non-empty palindromic substring of $S$ of even length. From the root $r$ of $\mathsf{T}_{\mathrm{odd}}$, there is a labeled directed edge $(r,a,v)$ if $v$ represents a single character $a\in\Sigma$. For any non-root node $u$ of $\mathsf{T}_{\mathrm{odd}}$ or $\mathsf{T}_{\mathrm{even}}$, there is a labeled directed edge $(u,a,v)$ from $u$ to node $v$ with character label $a\in\Sigma$ if $aua=v$. For any node $u$, the labels of out-going edges of $u$ must be mutually distinct.

By Lemma 1, any string $S$ of length $n$ can contain at most $n+1$ distinct palindromic substrings (including the empty string $\varepsilon$). Thus, the size of $\mathsf{eertree}(S)$ is linear in the string length $n$. Rubinchik and Shur [14] showed how to construct $\mathsf{eertree}(S)$ in $O(n\log\sigma_{S})$ time and $O(n)$ space, where $\sigma_{S}$ is the number of distinct characters in $S$. They also showed how to compute the number of occurrences of each palindromic substring in $O(n\log\sigma_{S})$ time and $O(n)$ space, using $\mathsf{eertree}(S)$.

Now we introduce a new data structure named RLE-eertrees based on eertrees. Let $\mathit{RLE}_{S}=(a_{1},e_{1}),\ldots,(a_{m},e_{m})$, and let $\Sigma_{\mathit{RLE}}$ be the set of maximal runs of $S$, namely, $\Sigma_{\mathit{RLE}}=\{(a,e)\mid(a,e)=(a_{i},e_{i})\mbox{ for some }1\leq i\leq m\}$. Let $\sigma_{RLE}=|\Sigma_{\mathit{RLE}}|$. Note that $\sigma_{RLE}\leq m$ always holds. The RLE-eertree of string $S$, denoted by $\mathsf{e^{2}rtre^{2}}(S)$, is a single eertree $\mathsf{T}_{\mathtt{odd}}$ over the RLE alphabet $\sigma_{\mathit{RLE}}\subset\Sigma\times\mathcal{N}$, which represents distinct run-centered palindromes of $S$ which have an RLE-bounded occurrence $[i,i^{\prime}]$ such that $i=\mathit{Rb}[j]$ and $i^{\prime}=\mathit{Re}[j^{\prime}]$ for some $1\leq j\leq j^{\prime}\leq m$ (namely, the both ends of the occurrence touch the boundary of runs), or an occurrence as a maximal palindrome in $S$. We remark that the number of runs in each palindromes in $\mathsf{e^{2}rtre^{2}}(S)$ is odd, but their decompressed string length may be odd or even. In $\mathsf{e^{2}rtre^{2}}(S)$, there is a directed labeled edge $(u,a^{e},v)$ from node $u$ to node $v$ with label $a^{e}\in\Sigma_{RLE}$ if (1) $a^{e}ua^{e}=v$, or (2) $u=\varepsilon$ and $v=a^{e}\in\Sigma\times\mathcal{N}$. Note that if the in-coming edge of a node $u$ is labeled with $a^{e}$, then any out-going edge of $u$ cannot have a label $a^{f}$ with the same character $a$. Since $\mathsf{e^{2}rtre^{2}}{S}$ is an eertree over the alphabet $\Sigma_{RLE}$ of size $\sigma_{\mathit{RLE}}\leq m$, it is clear that the number of out-going edges of each node is bounded by $\sigma_{\mathit{RLE}}$. We give an example of $\mathsf{e^{2}rtre^{2}}(S)$ in Fig. 2.

Lemma 5**.**

Let $S$ be any string of which the size of $\mathit{RLE}_{S}$ is $m$. Then, the number of nodes in $\mathsf{e^{2}rtre^{2}}(S)$ is at most $2m+1$.

Proof.

First, we consider $\mathit{RLE}_{S}$ as a string of length $m$ over the alphabet $\Sigma_{RLE}$. It now follows from Lemma 1 that the number of non-empty distinct run-centered palindromic substrings of $S$ that have an RLE-bounded occurrence is at most $m$. Each of these palindromic substrings are represented by a node of $\mathsf{e^{2}rtre^{2}}(S)$, and let $\mathsf{e^{2}rtre^{2}}(S)^{\prime}$ denote the tree consisting only of these nodes (in the example of Fig. 2, $\mathsf{e^{2}rtre^{2}}(S)^{\prime}$ is the tree consisting only of the white nodes).

Now we count the number of nodes in $\mathsf{e^{2}rtre^{2}}(S)$ that do not belong to $\mathsf{e^{2}rtre^{2}}(S)^{\prime}$ (the gray nodes in the running example of Fig. 2). Since each palindrome represented by this type of node has a run-centered maximal occurrence in $S$, the number of such palindromes is bounded by the number $m$ of runs in $\mathit{RLE}_{S}$.

Hence, including the root that represent the empty string, there are at most $2m+1$ nodes in $\mathsf{e^{2}rtre^{2}}(S)$. ∎

Lemma 6**.**

Given $\mathit{RLE}_{S}$ of size $m$, $\mathsf{e^{2}rtre^{2}}(S)$ can be built in $O(m\log\sigma_{\mathit{RLE}})$ time and $O(m)$ space, where the out-going edges of each node are sorted according to the total order of their labels. Also, in the resulting $\mathsf{e^{2}rtre^{2}}(S)$, each non-root node $u$ stores the number of occurrences of $u$ in $S$ which are RLE-bounded or maximal.

Proof.

Our construction algorithm comprises three steps. We firstly construct $\mathsf{e^{2}rtre^{2}}(S)^{\prime}$, secondly compute an auxiliary array $\mathit{CPal}$ that will be used for the next step, and thirdly we add some nodes that represent run-centered maximal palindromes which are not in $\mathsf{e^{2}rtre^{2}}(S)^{\prime}$ so that the resulting tree forms the final structure $\mathsf{e^{2}rtre^{2}}(S)$.

Rubinchik and Shur [14] proposed an online algorithm which constructs $\mathsf{eertree}(T)$ of a string of length $k$ in $O(k\log\sigma_{T})$ time with $O(k)$ space, where $\sigma_{T}$ denotes the number of distinct characters in $T$. They also showed how to store, in each node, the number of occurrences of the corresponding palindromic substring in $T$. Thus, the Rubinchik and Shur algorithm applied to $\mathit{RLE}_{S}$ computes $\mathsf{e^{2}rtre^{2}}(S)^{\prime}$ in $O(m\log\sigma_{\mathit{RLE}})$ time with $O(m)$ space. Also, now each node $u$ of $\mathsf{e^{2}rtre^{2}}(S)^{\prime}$ stores the number of RLE-bounded occurrence of $u$ in $S$. This is the first step.

The second step is as follows: Let $\mathit{CPal}$ be an array of length $m$ such that, for each $1\leq i\leq m$, $\mathit{CPal}[i]$ stores a pointer to the node in $\mathsf{e^{2}rtre^{2}}(S)^{\prime}$ that represents the RLE-bounded palindrome centered at $i$. A simple application of the Rubinchik and Shur algorithm to $\mathit{RLE}_{S}$ only gives us the leftmost occurrence of each RLE-bounded palindrome in $\mathsf{e^{2}rtre^{2}}(S)^{\prime}$. Hence, we only know the values of $\mathit{CPal}$ in the positions that are the centers of the leftmost occurrences of RLE-bounded palindromes. To compute the other values in $\mathit{CPal}$, we run Manacher’s algorithm to $\mathit{RLE}_{S}$ as in Section 3.2. Since Manacher’s algorithm processes $\mathit{RLE}_{S}$ in an online manner from left to right, and since we already know the leftmost occurrences of all RLE-bounded palindromes in $\mathit{RLE}_{S}$, we can copy the pointers from previous occurrences. In case where an RLE-bounded palindrome extends with a newly read RLE-character $(a,e)$ after it is copied from a previous occurrence during the execution of Manacher’s algorithm, then we traverse the edge labeled $(a,e)$ from the current node of $\mathsf{e^{2}rtre^{2}}(S)^{\prime}$. By repeating this until the mismatch is found in extension of the current RLE-bounded palindrome, we can find the corresponding node for this RLE-bounded palindrome. This way we can compute $\mathit{CPal}[i]$ for all $1\leq i\leq m$ in $O(m\log\sigma_{\mathit{RLE}})$ total time with $O(m)$ total space.

In the third step, we add new nodes that represent run-centered maximal (but not RLE-bounded) palindromic substrings. For this sake, we again apply Manacher’s algorithm to $\mathit{RLE}_{S}$, but in this case it is done as in Remark 1 of Section 3.2. With the help of $\mathit{CPal}$ array, we can associate each run $(a_{l},e_{l})$ with the RLE-bounded palindromic substring that has the center in $(a_{l},e_{l})$. Let $Q_{l}=S[\mathit{Rb}[i]..\mathit{Re}[j]]$ denote this palindromic substring for $(a_{l},e_{l})$, where $1\leq i\leq l\leq j\leq m$, and $u_{l}$ the node that represents $Q_{l}$ in $\mathsf{e^{2}rtre^{2}}(S)^{\prime}$. We first check whether $a_{i-1}=a_{j+1}$. If no, then $Q_{l}$ does not extend from this run $(a_{l},e_{l})$, and if yes then we extend both ends of $Q_{l}$ with $(a_{i-1},\min\{e_{i-1},e_{j+1}\})$. Assume w.l.o.g. that $e_{i-1}=\min\{e_{i-1},e_{j+1}\}$. If there is no out-going edge of $u_{l}$ with label $(a_{i-1},e_{i-1})$, then we create a new child of $u_{l}$ with an edge labeled $(a_{i-1},e_{i-1})$. Otherwise, then let $v$ be the existing child of $u_{l}$ that represents $a_{i-1}^{e_{i-1}}u_{l}a_{i-1}^{e_{i-1}}$. We increase the number of occurrences of $v$ by 1. This way, we can add all new nodes and we obtain $\mathsf{e^{2}rtre^{2}}(S)$. Note that each node stores the number of RLE-bounded or maximal occurrence of the corresponding run-centered palindromic substring. It is easy to see that the second step takes a total of $O(m\log\sigma_{\mathit{RLE}})$ time and $O(m)$ space. ∎

It is clear that for any character $a\in\Sigma$, there can be only one MUPS of form $a^{e}$. Namely, $a^{e}$ is a MUPS iff $e$ is the largest exponent for all runs of $a$’s in $S$ and $\mathit{occ}_{S}(a^{e})=1$. Below, we consider other forms of MUPSs. Let $P$ be a non-empty palindromic substring of string $S$ that has a run-centered RLE-bounded occurrence. For any character $a\in\Sigma$, let $\mathsf{emax}$ and $\mathsf{esec}$ denote the largest and second largest positive integers such that $a^{\mathsf{emax}}Pa^{\mathsf{emax}}$ and $a^{\mathsf{esec}}Pa^{\mathsf{esec}}$ are palindromes that have run-centered RLE-bounded or maximal occurrences in $S$. If such integers do not exist, then let $\mathsf{emax}=\mathsf{nil}$ and $\mathsf{esec}=\mathsf{nil}$.

Observation 1**.**

There is at most one MUPS of form $a^{e}Pa^{e}$ in $S$. Namely,

1. (1)

The palindrome $a^{\mathsf{esec}+1}Pa^{\mathsf{esec}+1}$ is a MUPS of $S$ iff $\mathsf{emax}\neq\mathsf{nil}$, $\mathsf{esec}\neq\mathsf{nil}$, and $\mathit{occ}_{S}(a^{\mathsf{emax}}Pa^{\mathsf{emax}})$ $=1$. 2. (2)

The palindrome $a^{1}Pa^{1}$ is a MUPS of $S$ iff $\mathsf{emax}\neq\mathsf{nil}$, $\mathsf{esec}=\mathsf{nil}$, and $\mathit{occ}_{S}(a^{\mathsf{emax}}Pa^{\mathsf{emax}})=1$. 3. (3)

There is no MUPS of form $a^{e}Pa^{e}$ with any $e\geq 1$ iff either $\mathsf{emax}=\mathsf{nil}$, or $\mathsf{emax}\neq\mathsf{nil}$ and $\mathit{occ}_{S}(a^{\mathsf{emax}}Pa^{\mathsf{emax}})>1$.

Lemma 7**.**

$\mathcal{M}_{S}$* can be computed in $O(m\log\sigma_{\mathit{RLE}})$ time and $O(m)$ space.*

Proof.

For each node $u$ of $\mathsf{e^{2}rtre^{2}}(S)$, let $\Sigma_{u}$ be the set of characters $a$ such that there is an out-going edge of $u$ labeled by $(a,e)$ with some positive integer $e$. Due to Observation 1, for each character in $\Sigma_{u}$, it is enough to check the out-going edges which have the largest and second largest exponents with character $a$. Since the edges are sorted, we can find all children of $u$ that represent MUPSs in time linear in the number of children of $u$. Hence, given $\mathsf{e^{2}rtre^{2}}(S)$, it takes $O(m)$ total time to compute all MUPSs in $S$. $\mathsf{e^{2}rtre^{2}}(S)$ can be computed in $O(m\log\sigma_{\mathit{RLE}})$ time and $O(m)$ space by Lemma 6.

What remains is how to sort the MUPSs in increasing order of their beginning positions. We associate each MUPS with the run where its center lies. Since each MUPS occurs in $S$ exactly once and MUPSs do not nest (Lemma 2), each run cannot contain the centers of two or more MUPSs. We compute an array $A$ of size $m$ such that $A[j]$ contains the corresponding interval of the MUPS whose center lies in the $j$th run in $\mathit{RLE}_{S}$, if it exists. After computing $A$, we scan $A$ from left to right. Since again MUPSs do not nest, this gives as the sorted list $\mathcal{M}_{S}$ of MUPSs. It is clear that this takes a total of $O(m)$ time and space. ∎

4 SUPS queries on RLE strings

In this section, we present our algorithm for SUPS queries. Our algorithm is based on Inoue et al.’s algorithm [9] for SUPS queries on a plain string. The big difference is that the space that we are allowed for is limited to $O(m)$.

4.1 Data structures

As was discussed in Section 3, we can compute the list $\mathcal{M}_{S}$ of all MUPSs of string $S$ efficiently. We store $\mathcal{M}_{S}$ using the three following arrays:

• •

$\mathit{M_{beg}}[i]$ : the beginning position of the $i$th MUPS in $\mathcal{M}_{S}$.

• •

$\mathit{M_{end}}[i]$ : the ending position the $i$th MUPS in $\mathcal{M}_{S}$.

• •

$\mathit{M_{len}}[i]$ : the length of the $i$th MUPS in $\mathcal{M}_{S}$.

Since the number of MUPSs in $\mathcal{M}_{S}$ is at most $m$ (Corollary 1), the length of each array is at most $m$. In our algorithm, we use range minimum queries and predecessor/successor queries on integer arrays.

Let $A$ be an integer array of length $d$. A range minimum query $\mathsf{RmQ}_{A}(i,j)$ returns one of $\arg\min_{i\leq k\leq j}\{A[k]\}$ for a given interval $[i,j]$ in $A$.

Lemma 8** (e.g. [3]).**

We can construct an $O(d)$-space data structure in $O(d)$ time for an integer array $A$ of length $d$ which can answer $\mathsf{RmQ}_{A}(i,j)$ in constant time for any query $[i,j]$.

Let $B$ be an array of $d$ positive integers in $[1,N]$ in increasing order. The predecessor and successor queries on $B$ are defined for any $1\leq k\leq N$ as follows.

[TABLE]

Lemma 9** ([2]).**

We can construct, in $O(d\sqrt{\log d/\log\log d})$ time, an $O(d)$-space data structure for an array $B$ of $d$ positive integer in $[1,N]$ in increasing order which can answer $\mathsf{Pred}_{B}(k)$ and $\mathsf{Succ}_{B}(k)$ in $O(\sqrt{\log d/\log\log d})$ time for any query $k\in[1,N]$.

4.2 Query algorithm

Our algorithm simulates the query algorithm for a plain string [9] with $O(m)$-space data structures. We summarize our algorithm below.

Let $[s,t]$ be a query interval such that $1\leq s\leq t\leq n$. Firstly, we compute the number of MUPSs contained in $[s,t]$. This operation can be done in $O(\sqrt{\log m/\log\log m})$ by using $\mathsf{Succ}_{\mathit{M_{beg}}}(s)$ and $\mathsf{Pred}_{\mathit{M_{end}}}(t)$.

Let $\mathit{num}$ be the number of MUPSs contained in $[s,t]$. If $\mathit{num}\geq 2$, then there is no SUPS for this interval (Corollary 1 of [9]). Suppose that $\mathit{num}=1$. Let $S[i..j]$ be the MUPS contained in $[s,t]$. If $S[i-z..j+z]$ is a palindromic substring, then $S[i-z..j+z]$ is the only $\mathit{SUPS}$ for $[s,t]$ where $z=\max\{i-s,t-j\}$. Otherwise, there is no $\mathit{SUPS}$ for $[s,t]$ (Lemma 6 of [9]). Since this candidate has a run as the center, we can check whether $S[i-z..j+z]$ is a palindromic substring or not in constant time after computing all run-centered maximal palindromes. Suppose that $\mathit{num}=0$ (this case is based on Lemma 7 of [9]). Let $p=\mathsf{Pred}_{\mathit{M_{end}}}(t),q=\mathsf{Succ}_{\mathit{M_{beg}}}(s)$. We can check whether each of $S[\mathit{M_{beg}}[p]-t+\mathit{M_{end}}[p]..t]$ and $S[s..\mathit{M_{end}}[q]+\mathit{M_{beg}}[q]-s]$ is a palindrome or not. If so, the shorter one is a candidate of $\mathit{SUPS}\mbox{s}$. Let $\ell$ be the length of the candidates. Other candidates are the shortest $\mathit{MUPS}\mbox{s}$ which contain the query interval $[s,t]$. If the length of these candidates is less than or equal to $\ell$, we need to compute these candidates as $\mathit{SUPS}\mbox{s}$. We can compute these $\mathit{MUPS}\mbox{s}$ by using range minimum queries on $\mathit{M_{len}}[p+1,q-1]$. Thus, we can compute all $\mathit{SUPS}\mbox{s}$ in linear time w.r.t. the number of outputs (see [9] in more detail).

We conclude with the main theorem of this paper.

Theorem 1**.**

Given $\mathit{RLE}_{S}$ of size $m$ for a string $S$, we can compute a data structure of $O(m)$ space in $O(m(\log\sigma_{\mathit{RLE}}+\sqrt{\log m/\log\log m}))$ time so that subsequent SUPS queries can be answered in $O(\alpha+\sqrt{\log m/\log\log m})$ time, where $\sigma_{\mathit{RLE}}$ denotes the number of distinct RLE-characters in $\mathit{RLE}_{S}$ and $\alpha$ the number of SUPSs to report.

5 Faster algorithms for a variant of the SUPS problem

In this section, we consider a variant of Problem 1 where each query interval $[s,t]$ is given as a tuple representing the left-end run $s_{r}$ that contains $s$, the local position $s_{p}$ in the left-end run $s_{r}$ corresponding to $s$, the right-end run $t_{r}$ that contains $t$, and the local position $t_{p}$ in the right-end run $t_{r}$ corresponding to $t$. Intuitively, queries are also run-length encoded in this variant of the problem. Formally, this variant of the problem is defined as follows:

Problem 2** ($\mathit{SUPS}$ problem on run-length encoded strings with run-length encoded queries).**

Preprocess:

$\mathit{RLE}_{S}=(a_{1},e_{1}),\ldots,(a_{m},e_{m})$ of size $m$ representing a string $S$ of length $n$.

Query:

Tuple $(s_{r},s_{p},t_{r},t_{p})$ representing query interval $[s,t]$  $(1\leq s\leq t\leq n)$, such that $s=\mathit{Rb}[s_{r}]+s_{p}-1$, $t=\mathit{Rb}[t_{r}]+t_{p}-1$, $1\leq s_{r}\leq t_{r}\leq m$, $1\leq s_{p}\leq e_{s_{r}}$, and $1\leq t_{p}\leq e_{t_{r}}$.

Return:

All SUPSs for interval $[s,t]$.

In this section, we present two alternative algorithms for Problem 2.

5.1 Further combinatorial properties on MUPSs

The key to our algorithms is a combinatorial property of maximal palindromes in RLE strings. To show this property, we utilize the following result.

Lemma 10** ([1, 11]).**

Let $S$ be any string of length $n$. The set of suffix palindromes of $S$ can be partitioned into $O(\log n)$ disjoint groups, such that the suffix palindromes in the same group has the same shortest period. Namely, each group can be represented by a single arithmetic progression $\langle s,d,t\rangle$, such that $s$ is the length of the shortest suffix palindrome in the group, $t$ is the number of suffix palindromes in the group, and $d$ is the common difference (i.e. the shortest period).

When there is only one element in a group (i.e. $t=1$), then we set $d=0$.

By applying Lemma 10 to $\mathit{RLE}_{S}=(a_{1},e_{1})\cdots(a_{m},e_{m})$ where each RLE factor $(a_{i},e_{i})$ is regarded as a single character, we immediately obtain the following corollary:

Corollary 2**.**

Let $S$ be any string and let $m$ be the size of $\mathit{RLE}_{S}$. The set of RLE-bounded suffix palindromes of $\mathit{RLE}_{S}=(a_{1},e_{1})\cdots(a_{m},e_{m})$ can be partitioned into $O(\log m)$ disjoint groups, such that the RLE-bounded suffix palindromes in the same group has the same shortest period. Namely, each group can be represented by a single arithmetic progression $\langle s^{\prime},d^{\prime},t^{\prime}\rangle$, such that $s^{\prime}$ is the number of runs in the shortest RLE-bounded suffix palindrome in the group, $t^{\prime}$ is the number of RLE-bounded suffix palindromes in the group, and $d^{\prime}$ is the common difference (i.e. the shortest period).

In the sequel, we will store arithmetic progressions representing the RLE-bounded suffix palindromes of all RLE-bounded prefixes $\mathit{RLE}_{S}[1..i]=(a_{1},e_{1}),$ $\ldots,(a_{i},e_{i})$ of $\mathit{RLE}_{S}$. It may seem that it takes $O(m\log m)$ total space due to Corollary 2. However, since each RLE-bounded suffix palindrome of $\mathit{RLE}_{S}[1..i]$ is a maximal palindrome of string $\mathit{RLE}_{S}=(a_{1},e_{1}),\ldots,(a_{m},e_{m})$ where each run $(a_{i},e_{i})$ is regarded as a single character, and since there are only $2m-1$ such maximal palindromes in $\mathit{RLE}_{S}=(a_{1},e_{1}),\ldots,(a_{m},e_{m})$, the total space requirement for storing all arithmetic progressions is $O(m)$.

The next lemma is a key to our algorithms.

Lemma 11**.**

Let $S$ be any string and let $\mathit{RLE}_{S}=a_{1}^{e_{1}}\cdots a_{m}^{e_{m}}$. For any $1\leq i\leq m$, the number of MUPSs of $S$ that end in the $i$th run $a_{i}^{e_{i}}$ of $\mathit{RLE}_{S}$, namely in the position interval $[\mathit{Rb}[i],\mathit{Re}[i]]$ in $S$, is $O(\log m)$.

Proof.

It is possible that the $i$th run $a_{i}^{e_{i}}$ itself is a MUPS. To consider other MUPSs ending in the $i$th run, we consider MUPSs of $S$ that begin before the $i$th run $a_{i}^{e_{i}}$ and end in $a_{i}^{e_{i}}$, namely, those MUPSs that begin in position range $[1..\mathit{Re}[i-1]]$ and end in $[\mathit{Rb}[i]..\mathit{Re}[i]]$. We observe that any palindromic substring in $S$ that begins before the $i$th run $a_{i}^{e_{i}}$ and ends in the $i$th run $a_{i}^{e_{i}}$ can be obtained by extending some suffix palindrome of $S[1..\mathit{Re}[i-1]]$ to the left and to the right within $S$. We remark that the extension may not terminate at RLE boundaries and can terminate within runs.

For any $1<i\leq m$, let $\mathbf{RBSP}_{i-1}$ be the set of RLE-bounded suffix palindromes of $\mathit{RLE}_{S}[1..i-1]=(a_{1},e_{1}),\ldots,(a_{i-1},e_{i-1})$ whose beginning positions coincide with the beginning positions of some runs in $\mathit{RLE}_{S}[1..i-1]$. Now it follows from Corollary 2 that the lengths of the suffix palindromes in $\mathbf{RBSP}_{i-1}$ can be represented by $O(\log m)$ arithmetic progressions.

Let $\langle s^{\prime},d^{\prime},t^{\prime}\rangle$ be a single arithmetic progression representing a group of suffix palindromes in $\mathbf{RBSP}_{i-1}$. In what follows, we show that for each $\langle s^{\prime},d^{\prime},t^{\prime}\rangle$, the number of MUPSs ending in the $i$th run $a_{i}^{e_{i}}$ that can be obtained by extending elements of $\langle s^{\prime},d^{\prime},t^{\prime}\rangle$ is at most two. The case where $t^{\prime}\leq 2$ is trivial, and hence let us consider the case where $t^{\prime}\geq 3$. We consider the following sub-cases:

When $a_{i-(s^{\prime}+(t^{\prime}-1)d^{\prime})-1}=a_{i}$, then we can obtain a palindrome that ends in the $i$th run $a_{i}^{e_{i}}$ by extending the longest palindrome $P$ belonging to $\langle s^{\prime},d^{\prime},t^{\prime}\rangle$. This extended palindrome can be a MUPS of $S$ that ends in the $i$th run. We note that there is a unique positive integer $\ell$ such that $a_{i}^{\ell}Pa_{i}^{\ell}$ is a MUPS in $S$. 2. 2.

When $a_{i-s^{\prime}-1}=a_{i}$, then for any $2\leq j\leq t^{\prime}$, we concider the palindrome that ends in the $i$th run $a_{i}^{e_{i}}$ by maximally extending the $j$th longest palindrome $S[\mathit{Rb}[i-(s^{\prime}+(t^{\prime}-j)d^{\prime})]..\mathit{Re}[i-1]]$ belonging to $\langle s^{\prime},d^{\prime},t^{\prime}\rangle$. The length of this extension is $\min\{e_{i-s^{\prime}-1},e_{i}\}$ to either side. Now, for any $3\leq k\leq t^{\prime}$, we have that

[TABLE]

This implies that for any $3\leq k\leq t^{\prime}$ any palindrome that is obtained by extending the $k$th longest palindrome corresponding to $\langle s^{\prime},d^{\prime},t^{\prime}\rangle$ and ending in the $i$th run $a_{i}^{e_{i}}$, occurs at least twice in $S$. Thus, the elements of $\langle s^{\prime},d^{\prime},t^{\prime}\rangle$ except for the longest one and the second longest one do not yield MUPSs ending in the $i$th run $a_{i}^{e_{i}}$.

Consequently, for each single group $\langle s^{\prime},d^{\prime},t^{\prime}\rangle$, there are at most two MUPSs ending in the $i$th run $a_{i}^{e_{i}}$ that can be obtained by extending palindromes belonging to $\langle s^{\prime},d^{\prime},t^{\prime}\rangle$. It follows from Corollary 2 that there are $O(\log i)$ groups for each $i$. Thus, the number of MUPSs that end in the $i$th run is bounded by $O(\log m)$ for any $1\leq i\leq m$. ∎

See Fig. 3, 4, and 5 for concrete examples for the proof of Lemma 11.

5.2 Query algorithm

Here we present our algorithms for answering queries of Problem 2. While we inherit the basic concepts of our query algorithm for the original problem (Problem 1), we here use slightly different data structures.

5.2.1 Preprocessing

As was done in Section 4, we store the set $\mathcal{M}_{S}$ of MUPSs of $S$ in the three following arrays. We store $\mathcal{M}_{S}$ using the three following arrays:

• •

$\mathit{M_{beg}}[i]$ : the beginning position of the $i$th MUPS in $\mathcal{M}_{S}$.

• •

$\mathit{M_{end}}[i]$ : the ending position the $i$th MUPS in $\mathcal{M}_{S}$.

• •

$\mathit{M_{len}}[i]$ : the length of the $i$th MUPS in $\mathcal{M}_{S}$.

Since the number of MUPSs in $\mathcal{M}_{S}$ is at most $m$ (Corollary 1), the length of each array is at most $m$.

Additionally, we build the two following arrays of size exactly $m$ each, such that for each $1\leq i\leq m$:

• •

$\mathit{mrb}[i]$ stores a sorted list of the beginning positions of MUPSs that begin in the $i$th run (i.e. in the position interval $[\mathit{Rb}[i]..\mathit{Re}[i]]$), arranged in increasing order.

• •

$\mathit{mre}[i]$ stores a sorted list of the ending positions of MUPSs that end in the $i$th run (i.e. in the position interval $[\mathit{Rb}[i]..\mathit{Re}[i]]$), arranged in increasing order.

We can easily precompute $\mathit{mrb}$ (resp. $\mathit{mre}$) in $O(m)$ time by a simple scan over $\mathit{M_{beg}}$ (resp. $\mathit{M_{end}}$).

Given a query input $(s_{r},s_{p},t_{r},t_{p})$ for Problem 2, we can retrieve the corresponding query interval $[s,t]$ over the string $S$ by

• •

$s=\mathit{Rb}[s_{r}]+s_{p}-1$,

• •

$t=\mathit{Rb}[t_{r}]+t_{p}-1$.

Thus, provided that $\mathit{Rb}[i]$ are already computed for all $1\leq i\leq m$, we can retrieve the query interval $[s,t]$ in $O(1)$ time. We can easily compute $\mathit{Rb}[i]$ for all $1\leq i\leq m$ in $O(m)$ total time by scanning $\mathit{RLE}_{S}$.

5.2.2 SUPSs queries

Suppose that we have retrieved the query interval $[s,t]$ from the query input $(s_{r},s_{p},t_{r},t_{p})$ as above. The next task is to compute the number of MUPSs contained in $[s,t]$.

As was discussed previously, the number of MUPSs contained in $[s,t]$ can be computed from $\mathsf{Succ}_{\mathit{M_{beg}}}(s)$ and $\mathsf{Pred}_{\mathit{M_{end}}}(t)$. In our algorithm for Problem 1 (Section 4), we computed $\mathsf{Succ}_{\mathit{M_{beg}}}(s)$ and $\mathsf{Pred}_{\mathit{M_{end}}}(t)$ using the successor/predecessor data structures of Lemma 9 built on $\mathit{M_{beg}}$ and $\mathit{M_{end}}$. Here, we present two alternative approaches.

Our first solution is the following:

Theorem 2**.**

Given $\mathit{RLE}_{S}$ of size $m$ for a string $S$, we can compute a data structure of $O(m)$ space in $O(m(\log\sigma_{\mathit{RLE}}+\sqrt{\log m/\log\log m}))$ time so that subsequent run-length encoded SUPS queries of Problem 2 can be answered in $O(\sqrt{\log\log m/\log\log\log m}+\alpha)$ time, where $\sigma_{\mathit{RLE}}$ denotes the number of distinct RLE-characters in $\mathit{RLE}_{S}$ and $\alpha$ the number of SUPSs to report.

Proof.

For each $1\leq i\leq m$, we build the successor data structure of Lemma 9 on the elements stored in $\mathit{mrb}[i]$. Similarly, for each $1\leq i\leq m$, we build the predecessor data structure of Lemma 9 on the elements stored in $\mathit{mre}[i]$. Then, we compute $\mathsf{Succ}_{\mathit{M_{beg}}}(s)$ and $\mathsf{Pred}_{\mathit{M_{end}}}(t)$ from the successor/predecessor data structures for $\mathsf{Succ}_{\mathit{mrb}[s_{r}]}(s)$ and $\mathsf{Pred}_{\mathit{mre}[t_{r}]}(t)$, respectively. This approach covers the cases where $\mathsf{Succ}_{\mathit{M_{beg}}}(s)$ exists in $\mathit{mrb}[s_{r}]$ and $\mathsf{Pred}_{\mathit{M_{end}}}(t)$ exists in $\mathit{mre}[t_{r}]$. To deal with the case where $\mathsf{Succ}_{\mathit{M_{beg}}}(s)$ does not exist in $\mathit{mrb}[s_{r}]$, we precompute $\mathsf{Succ}_{\mathit{M_{beg}}}(\mathit{Re}[s_{r}])$. We can precompute $\mathsf{Succ}_{\mathit{M_{beg}}}(\mathit{Re}[i])$ for all $1\leq i\leq m$ in $O(m)$ time by a simple scan over $\mathit{M_{beg}}$. The case where $\mathsf{Pred}_{\mathit{M_{end}}}(t)$ does not exist in $\mathit{mre}[t_{r}]$ can be treated similarly.

For each $1\leq i\leq m$, let $c_{i}$ be the number of MUPSs stored in $\mathit{mrb}[i]$. The successor data structure of Lemma 9 for the list of MUPSs in $\mathit{mrb}[i]$ occupies $O(c_{i})$ space, can be built in $O(c_{i}\sqrt{\log c_{i}/\log\log c_{i}})$ time, and answers successor queries in $O(\sqrt{\log c_{i}/\log\log c_{i}})$ time. It follows from Lemma 11 and Corollary 1 that $c_{i}=O(\log m)$ for each $1\leq i\leq m$ and the total number of MUPSs stored in the data structures for all $1\leq i\leq m$ is $\sum_{i=1}^{m}c_{i}=O(m)$, Therefore, the successor data structures for $\mathit{mrb}[i]$ for all $1\leq i\leq m$ can be built in a total of $O(m\sqrt{\log m/\log\log m})$ time (due to Jensen’s inequality), can be stored in $O(m)$ total space, and answer successor queries in $O(\sqrt{\log\log m/\log\log\log m})$ time. The same argument holds for the predecessor data structures for $\mathit{mre}[i]$. Thus, we can count the number of MUPSs contained in the interval $[s,t]$ in $O(\sqrt{\log\log m/\log\log\log m})$ time. The rest of our query algorithm is the same as in Section 4.2. ∎

Our second solution is simpler and can be built faster than the first solution, but supports slightly slower queries.

Theorem 3**.**

Given $\mathit{RLE}_{S}$ of size $m$ for a string $S$, we can compute a data structure of $O(m)$ space in $O(m\log\sigma_{\mathit{RLE}})$ time so that subsequent run-length encoded SUPS queries of Problem 2 in $O(\log\log m+\alpha)$ time, where $\sigma_{\mathit{RLE}}$ denotes the number of distinct RLE-characters in $\mathit{RLE}_{S}$ and $\alpha$ the number of SUPSs to report.

Proof.

Given $s_{r}$ and $t_{r}$, we binary search $\mathit{mrb}[s_{r}]$ and $\mathit{mre}[t_{r}]$ for $\mathsf{Succ}_{\mathit{M_{beg}}}(s)$ and $\mathsf{Pred}_{\mathit{M_{end}}}(t)$, respectively. Since the numbers of elements stored in $\mathit{mrb}[s_{r}]$ and in $\mathit{mre}[t_{r}]$ are $O(\log m)$ each by Lemma 11, the binary searches terminate in $O(\log\log m)$ time. The cases where $\mathsf{Succ}_{\mathit{M_{beg}}}(s)$ does not exist in $\mathit{mrb}[s_{r}]$, and $\mathsf{Pred}_{\mathit{M_{end}}}(t)$ does not exist in $\mathit{mre}[t_{r}]$ can be treated similarly as in Theorem 2. The rest of our query algorithm follows our method in Section 4.2. Clearly, this data structure takes $O(m)$ total space. ∎

Acknowledgments

This work was supported by JSPS KAKENHI Grant Numbers JP18K18002 (YN), JP17H01697 (SI), JP16H02783 (HB), JP18H04098 (MT), and by JST PRESTO Grant Number JPMJPR1922 (SI).