Space-Efficient Algorithms for Computing Minimal/Shortest Unique Substrings

TL;DR

This paper introduces space-efficient data structures and algorithms for computing minimal and shortest unique substrings in a string, enabling fast, output-sensitive queries for both interval and point cases.

Contribution

It presents novel space-efficient data structures for interval and point SUS queries with optimal query time complexity.

Findings

Data structure uses 4n + o(n) bits for interval SUS queries.

Data structure uses approximately 1.585n bits for point SUS queries.

Algorithms efficiently compute minimal unique substrings in linear space.

Abstract

Given a string $T$ of length $n$, a substring $u = T[i..j]$ of $T$ is called a shortest unique substring (SUS) for an interval $[s,t]$ if (a) $u$ occurs exactly once in $T$, (b) $u$ contains the interval $[s,t]$ (i.e. $i \leq s \leq t \leq j$), and (c) every substring $v$ of $T$ with $|v| < |u|$ containing $[s,t]$ occurs at least twice in $T$. Given a query interval $[s, t] \subset [1, n]$, the interval SUS problem is to output all the SUSs for the interval $[s,t]$. In this article, we propose a $4n + o(n)$ bits data structure answering an interval SUS query in output-sensitive $O(\mathit{occ})$ time, where $\mathit{occ}$ is the number of returned SUSs. Additionally, we focus on the point SUS problem, which is the interval SUS problem for $s = t$. Here, we propose a $\lceil (\log_2{3} + 1)n \rceil + o(n)$ bits data structure answering a point SUS query in the same output-sensitive time. We also propose space-efficient algorithms for computing the minimal unique substrings of $T$.

Tables

Table 1. Table 1: Working space used during the construction of the data structure proposed in Theorem  2 . We can free up space of no longer needed data structures between several steps. See also Fig.  2 for the dependencies of the execution, and other possible ways to build the final data structure. However, these other ways need more maximum working space (at some step) than the way listed in this table.

No.	Process	Total working space in bits (excluding ${\mathrm{𝖬𝖡}}_T$ and ${\mathrm{𝖬𝖤}}_T$)
1	input ${\mathrm{𝖬𝖡}}_T$, ${\mathrm{𝖬𝖤}}_T$	-
2	construct $\mathrm{𝖱𝗆𝖰}$ on ${\mathrm{𝖬𝖴𝖲𝗅𝖾𝗇}}_T$	$2m+o\left(n\right)$	Lemma 6
3	construct ${\mathrm{𝖫𝖣}}_T$, ${𝖫}_T\left[1\right]$	$2n+2m+o\left(n\right)$	Lemma 11
4	free $\mathrm{𝖱𝗆𝖰}$ on ${\mathrm{𝖬𝖴𝖲𝗅𝖾𝗇}}_T$	$2n+o\left(n\right)$
5	construct Huffman-shaped	$2n+\lceil n{\log }_{2}3\rceil +o\left(n\right)$	Lemma 12
	Wavelet Tree for ${\mathrm{𝖫𝖣}}_T$
6	free ${\mathrm{𝖫𝖣}}_T$	$\lceil n{\log }_{2}3\rceil +o\left(n\right)$
7	construct $\mathrm{𝖱𝖬𝖰}$ on ${𝖫}_T$	$2n+\lceil n{\log }_{2}3\rceil +o\left(n\right)$	Lemma 13
8	construct ${𝖡}_T$	$3n+\lceil n{\log }_{2}3\rceil +o\left(n\right)$	Lemma 13

Table 2. Table 2: Efficient data structures with access to 𝖨𝖲𝖠 T ​ [ i ] subscript 𝖨𝖲𝖠 𝑇 delimited-[] 𝑖 \mathsf{ISA}_{T}[i] and 𝖫𝖢𝖯 T ​ [ i ] subscript 𝖫𝖢𝖯 𝑇 delimited-[] 𝑖 \mathsf{LCP}_{T}[i] . ϵ italic-ϵ \epsilon is a constant with 0 < ϵ ≤ 1 0 italic-ϵ 1 0<\epsilon\leq 1 . r 𝑟 r denotes the number of single character runs in the BWT.

		Time
data structure	Lemma	Access	Construction	Space in bits
		${\pi }_a\left(n\right)$	${\pi }_c\left(n\right)$	${\pi }_s\left(n\right)$
sparse suffix tree	15	$O\left({ϵ}^{-1}\right)$	$O\left({ϵ}^{-2}n\right)$	$\left(1+ϵ\right)n\log n+O\left(n\right)$
compressed suffix tree	16	$O\left({\log }_{\sigma }^{ϵ}n\right)$	$O\left(n{\log }_{\sigma }^{ϵ}n\right)$	$O\left({ϵ}^{-1}n\log \sigma \right)$
RLBWT	17	$O\left(\log r{\log }^{O\left(1\right)}n\right)$	$O\left(n\log r+r{\log }^{O\left(1\right)}n\right)$	$r{\log }^{O\left(1\right)}n+O\left(n\right)$

Equations

$${\mathsf{MMUS}}_T:=\{[i,j]\in {\mathsf{MUS}}_T\mid$$

$$\text{mbox}suchthatcover([i,j],p)\in {\mathsf{SUS}}_T(p)\}$$

$${\text{lmSUS}}_T^p=$$

$${\text{rmSUS}}_T^p=$$

$${\mathsf{L}}_T[i]$$

$${predneq}_{{\mathsf{L}}_T}(i)$$

$${succneq}_{{\mathsf{L}}_T}(i)$$

$$pred1{pos}_{{\mathsf{B}}_T}(i)$$

$$succ1{pos}_{{\mathsf{B}}_T}(i)$$

Full text

1 Introduction

A substring $u=T[i..j]$ of a string $T$ is called a shortest unique substring (SUS) for an interval $[s,t]$ if (a) $u$ occurs exactly once in $T$, (b) $u$ contains the interval $[s,t]$ (i.e., $i\leq s\leq t\leq j$), and (c) every substring $v$ of $T$ with $|v|<|u|$ containing $[s,t]$ occurs at least twice in $T$. Given a query interval $[s,t]\subset[1,n]$, the interval SUS problem is to output all the SUSs for $[s,t]$. When a query interval consists of a single position (i.e., $s=t$), the SUS problem becomes a so-called point SUS problem.

Point SUS Problem

The point SUS problem was introduced by Pei et al. [23]. This problem is motivated by applications in bioinformatics like genome comparisons [7] or PCR primer design [23]. Pei et al. tackled this problem with an $O(n)$ words data structure that can return one SUS for a given query position in constant time. They can compute this data structure in $O(n^{2})$ time with $O(n)$ space. Based on that result, Tsuruta et al. [25] provided an $O(n)$ words data structure answering the same query (returning one SUS) in constant time. Their data structure can be constructed in $O(n)$ time. İleri et al. [10] independently showed another data structure with the same time complexities. For the general point SUS problem, Tsuruta et al. [25] can also resort to their proposed data structure returning all SUSs for a query position in optimal $O(occ)$ time, where $occ$ is the number of returned SUSs.

The aforementioned data structures all take $\Theta(n)$ words. This space can become problematic for large $n$. This problem was perceived by Hon et al. [8], who proposed a data structure consisting of the input string $T$ and two integer arrays, each of length $n$. Both arrays store, respectively, the beginning and the ending position of a SUS for each position $i$ with $1\leq i\leq n$. Hon et al. provided an algorithm that can construct these two arrays in linear time with $O(\log n)$ bits of additional working space, given that both arrays are stored in $2n\log n$ bits and that $\sigma\leq n$. Instead of building a data structure, Ganguly et al. [4] proposed a time-space trade-off algorithm using $O(n/\tau)$ words of additional working space, answering a given query in $O(n\tau^{2}\log{\frac{n}{\tau}})$ time directly, for a trade-off parameter $\tau\geq 1$. They also proposed the first compact data structure of size $4n+o(n)$ bits that can answer a query in constant time. They can construct this data structure in $O(n\log n)$ time using $O(n\log\sigma)$ bits of additional working space.

Interval SUS Problem

Hu et al. [9] were the first to consider the interval SUS problem. They proposed a data structure answering a query returning all SUSs for the respective query interval in $O(occ)$ optimal time after $O(n)$ time preprocessing. In the compressed setting, Mieno et al. [18] considered the interval SUS problem when the input string $T$ is given run-length encoded (RLE), and proposed a data structure of size $O(r)$ words answering a query by returning all SUSs for the respective query interval in $O(\sqrt{\log r/\log\log r}+occ)$ time, where $r$ is the number of single character runs in $T$.

Our Contribution

In this paper, we propose the following two data structures:

• (A)

A data structure of size $2n+2m+o(n)$ bits answering an interval SUS query in $O(occ)$ time, where $m$ is the number of minimal unique substrings of the input string111We show later in Lemma 1 that the number of minimal unique substrings $m$ is at most $n$., and $occ$ is the number of SUSs of $T$ for the respective query interval (Theorem 1).

• (B)

A data structure of size $\lceil(\log_{2}{3}+1)n\rceil+o(n)$ bits answering a point SUS query in $O(occ)$ time, where $occ$ is the number of SUSs of $T$ for the respective query point (Theorem 2).

Instead of outputting the answer as a list of substrings of $T$, it is sometimes sufficient to output only the intervals corresponding to the respective substrings. In such a case, both data structures can answer a query without the need of the input string. The data structure (A) is the first data structure of size $O(n)$ bits for the interval SUS problem. Also, the data structure (B) is the first data structure of size $O(n)$ bits for the point SUS problem, returning all SUSs for a given query position. Notice that the data structure of Ganguly et al. [4] uses $4n+o(n)$ bits of space, but returns only one SUS for a point SUS query.

Note that parts of this work have already been presented at 26th International Symposium of String Processing and Information Retrieval (SPIRE 2019) [19].

2 Preliminaries

Our model of computation is the word RAM with machine word size $\Omega(\log n)$.

2.1 Strings

Let $\Sigma$ be an alphabet. An element of $\Sigma^{*}$ is called a string. For $|\Sigma|=2$, we call a string also a bit array. The length of a string $T$ is denoted by $|T|$. The empty string $\varepsilon$ is the string of length 0. Given a string $T$, the $i$-th character of $T$ is denoted by $T[i]$, for an integer $i$ with $1\leq i\leq|T|$. For two integers $i$ and $j$ with $1\leq i\leq j\leq|T|$, a substring of $T$ starting at position $i$ and ending at position $j$ is denoted by $T[i..j]$. Namely, $T[i..j]=T[i]T[i+1]\cdots T[j]$. For two strings $T$ and $w$, the number of occurrences of $w$ in $T$ is denoted by $\#T(w):=|\{i\mid T[i..i+|w|-1]=w\}|$. For two intervals $[i,j]$ and $[x,y]$, let $\mathit{cover}([i,j],[x,y]):=[\min\{i,x\},\max\{j,y\}]$ denote the shortest interval that contains the text positions $i,j,x,$ and $y$. If the interval $[x,y]$ consists of a single point, i.e., $x=y$, $\mathit{cover}([i,j],[x,y])$ is denoted by $\mathit{cover}([i,j],x)$ when we want to emphasize on the fact that $x=y$.

In what follows, we fix a string $T$ of length $n\geq 1$ whose characters are drawn from an integer alphabet $\Sigma$ of size $\sigma=n^{O(1)}$.

2.2 MUSs and SUSs

Let $u$ be a non-empty substring of $T$. $u$ is called a repeating substring of $T$ if $\#T(u)\geq 2$, and $u$ is called a unique substring of $T$ if $\#T(u)=1$. Since every unique substring $u=T[i..j]$ of $T$ occurs exactly once in $T$, we identify $u$ with its corresponding interval $[i,j]$. We also say that the interval $[i,j]$ is unique iff the corresponding substring $T[i..j]$ is a unique substring of $T$.

A unique substring $u=T[i..j]$ of $T$ is said to be a minimal unique substring (MUS) of $T$ iff every proper substring of $u$ is a repeating substring, i.e., $\#T(T[i^{\prime}..j^{\prime}])\geq 2$ for every integer $i^{\prime}$ and every integer $j^{\prime}$ with $[i^{\prime},j^{\prime}]\subset[i,j]$ and $j^{\prime}-i^{\prime}<j-i$. Let \mathsf{MUS}_{T}:=\{[i,j]\mid\mbox{T[i..j]$is a MUS of$T}\} be the set of all intervals corresponding to the MUSs of $T$. From the definition of MUSs, the next lemma follows:

Lemma 1** ([25, Lemma 2]).**

No element of $\mathsf{MUS}_{T}$ is nested in another element of $\mathsf{MUS}_{T}$, i.e., two different MUSs $[i,j],[k,l]\in\mathsf{MUS}_{T}$ satisfy $[i,j]\not\subset[k,l]$ and $[k,l]\not\subset[i,j]$. Therefore, $0<|\mathsf{MUS}_{T}|\leq|T|$.

We use the following two sets containing interval and point SUSs, which were defined at the beginning of the introduction: Given an interval $[s,t]\subset[1,n]$, $\mathsf{SUS}_{T}([s,t])$ denotes the set of the interval SUSs of $T$ for the interval $[s,t]$. Given a text position $p\in[1,n]$, $\mathsf{SUS}_{T}(p)$ denotes the set of the point SUSs of $T$ for the point $p$.

Given a query position $p\in[1,n]$ (resp. a query interval $[s,t]\subset[1,n]$), the point (resp. interval) SUS problem is to compute $\mathsf{SUS}_{T}(p)$ (resp. $\mathsf{SUS}_{T}([s,t])$). See Fig. 1 for an example depicting MUSs and SUSs.

3 Tools

In this section, we introduce the data structures needed for our approach to solve both SUS problems.

3.1 Rank and Select

Given a string $X$ of length $n$ over the alphabet $[1,\sigma]$. For an integer $i$ with $1\leq i\leq n$ and a character $c\in[1,\sigma]$, the rank query $\mathit{rank}_{X}(c,i)$ returns the number of the character $c$ in the prefix $X[1..i]$ of $X$. Also, the select query $\mathit{select}_{X}(c,i)$ returns the position of $X$ containing the $i$-th occurrence of the character $c$ (or returns the invalid symbol $\mathit{nil}$ if such a position does not exist). For $\sigma=2$ (i.e., $X$ is a bit array), we can make use of the following lemma:

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

We can endow a bit array $X$ of length $n$ with a data structure answering $\mathit{rank}_{X}$ and $\mathit{select}_{X}$ in constant time. This data structure takes $o(n)$ bits of space, and can be built on $X$ in $O(n)$ time with $O(\log n)$ bits of additional working space.

3.2 Predecessor and Successor

Let $Y$ be an array of length $k$ whose entries are positive integers in strictly increasing order. Further suppose that these integers are less than or equal to $n$. Given an integer $d$ with $1\leq d\leq n$, the predecessor and the successor query on $Y$ with $d$ are defined as $\mathsf{Pred}_{Y}(d):=\max\{i\mid Y[i]\leq d\}$ and $\mathsf{Succ}_{Y}(d):=\min\{i\mid Y[i]\geq d\}$, where we stipulate that $\min\{\}=\max\{\}=\mathit{nil}$.

Let $BIT_{Y}$ be a bit array of length $n$ marking all integers present in $Y$, i.e., $BIT_{Y}[i]=\mathtt{1}$ iff there is an integer $j$ with $1\leq j\leq k$ and $Y[j]=i$, for every $i$ with $1\leq i\leq n$. By endowing $BIT_{Y}$ with a rank/select data structure, we yield an $n+o(n)$ bits data structure answering $\mathsf{Pred}_{Y}(d)=\mathit{select}_{BIT_{Y}}(\mathtt{1},\mathit{rank}_{BIT_{Y}}(\mathtt{1},d))$ and $\mathsf{Succ}_{Y}(d)$222$\mathsf{Succ}_{Y}(d)$ can be computed similarly by considering the case whether $BIT_{Y}[d]=\mathtt{1}$. in constant time for each $d$ with $1\leq d\leq n$.

3.3 RmQ and RMQ

Given an integer array $Z$ of length $n$ and an interval $[i,j]\subset[1,n]$, the range minimum query $\mathsf{RmQ}_{Z}(i,j)$ (resp. the range maximum query $\mathsf{RMQ}_{Z}(i,j)$) asks for the index $p$ of a minimum element (resp. a maximum element) of the subarray $Z[i..j]$, i.e., $p\in\arg\min_{i\leq k\leq j}Z[k]$, or respectively $p\in\arg\max_{i\leq k\leq j}Z[k]$. We use the following well-known data structure to handle these kind of queries:

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

Given an integer array $Z$ of length $n$, there is an $\mathsf{RmQ}$ (resp. $\mathsf{RMQ}$) data structure taking $2n+o(n)$ bits of space that can answer an $\mathsf{RmQ}$ (resp. $\mathsf{RMQ}$) query on $Z$ in constant time. This data structure can be constructed in $O(n)$ time with $o(n)$ bits of additional working space.

3.4 Suffix Array and some Related Arrays

We define six integer arrays $\mathsf{SA}_{T}[1..n]$, $\mathsf{ISA}_{T}[1..n]$, $\mathsf{LCP}_{T}[1..n+1]$, $\mathsf{PLCP}_{T}[1..n]$, $\mathsf{RankPred}_{T}[1..n]$ and $\mathsf{RankSucc}_{T}[1..n]$. The suffix array $\mathsf{SA}_{T}$ of $T$ is the array with the property that $T[\mathsf{SA}_{T}[i]..n]$ is lexicographically smaller than $T[\mathsf{SA}_{T}[i+1]..n]$ for every $i$ with $1\leq i\leq n-1$ [17]. The inverse suffix array $\mathsf{ISA}_{T}$ of $T$ is the inverse of $\mathsf{SA}_{T}$, i.e., $\mathsf{SA}_{T}[\mathsf{ISA}_{T}[i]]=i$ for every $i$ with $1\leq i\leq n$. The longest common prefix array $\mathsf{LCP}_{T}$ of $T$ is the array with the property that $\mathsf{LCP}_{T}[1]=\mathsf{LCP}_{T}[n+1]=0$ and $\mathsf{LCP}_{T}[i]=lcp(T[\mathsf{SA}_{T}[i]..n],T[\mathsf{SA}_{T}[i-1]..n])$ for every $i$ with $2\leq i\leq n$, where $lcp(P,Q)$ denotes the length of the longest common prefix of $P$ and $Q$ for two given strings $P$ and $Q$. The permuted LCP array $\mathsf{PLCP}_{T}$ of $T$ is the array storing the values of $\mathsf{LCP}_{T}$ in text position order (instead of suffix array order), i.e., $\mathsf{PLCP}_{T}[i]=\mathsf{LCP}_{T}[\mathsf{ISA}_{T}[i]]$ for every $i$ with $1\leq i\leq n$. The rank predecessor array $\mathsf{RankPred}_{T}$ of $T$ is the array with the property that $\mathsf{RankPred}_{T}[\mathsf{SA}_{T}[1]]=\mathit{nil}$ and $\mathsf{RankPred}_{T}[\mathsf{SA}_{T}[i]]=\mathsf{SA}_{T}[i-1]$ for every $i$ with $2\leq i\leq n$. This array is also known as the $\Phi$ array in literature (e.g., [12, 5]). The rank successor array $\mathsf{RankSucc}_{T}$ of $T$ is the array with the property that $\mathsf{RankSucc}_{T}[SA[n]]=\mathit{nil}$ and $\mathsf{RankSucc}_{T}[SA_{T}[i]]=SA_{T}[i+1]$ for every $i$ with $1\leq i\leq n-1$.

4 Computing MUSs in Compact Space

For computing SUSs efficiently, it is advantageous to have a data structure available that can retrieve MUSs starting or ending at specific positions, as the following lemma gives a crucial connection between MUSs and SUSs:

Lemma 4** ([25, Lemma 2]).**

Every point SUS contains exactly one MUS.

Fig. 2 gives an overview of our introduced data structure and shows the connections between this section and the following sections that focus on our two SUS problems. For our data structure retrieving MUSs, we propose a compact representation and an algorithm to compute this representation space-efficiently. Our data structure is based on the following two bit arrays $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$ of length $n$ with the properties that

• •

$\mathsf{MB}_{T}[i]=\mathtt{1}$ iff $i$ is the beginning position of a MUS, and

• •

$\mathsf{ME}_{T}[i]=\mathtt{1}$ iff $i$ is the ending position of a MUS.

For the rest of this paper, let $m$ be the number of MUSs in $T$. We rank the MUSs by their starting positions in the text, such that the $j$-th MUS starts before the $(j+1)$-th MUS, for every integer $j$ with $1\leq j\leq m-1$.

Since MUSs are not nested (see Lemma 1), the number of $\mathtt{1}$’s in $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$ is exactly $m$. Hence, the starting position, the ending position, and the length of the $j$-th MUS can be computed with rank/select queries for every integer $j$ with $1\leq j\leq m$. How $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$ can be computed is shown in the following lemma:

Lemma 5**.**

Let $\mathcal{D}_{T}$ be a data structure that can access $\mathsf{ISA}_{T}[i]$ and $\mathsf{LCP}_{T}[i]$ in $\pi_{a}(n)$ time for every position $i$ with $1\leq i\leq n$. Suppose that we can construct it in $\pi_{c}(n)$ time with $\pi_{s}(n)$ bits of working space including the space for $\mathcal{D}_{T}$. Then $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$ can be computed in $O(\pi_{c}(n)+n\cdot\pi_{a}(n))$ total time while using $2n+\pi_{s}(n)$ bits of total working space including the space for $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$.

Proof.

Given a text position $i$ with $1\leq i\leq n$, $T[i..i+\ell_{i}-1]$ with $\ell_{i}=\max\{\mathsf{LCP}_{T}[\mathsf{ISA}_{T}[i]],\mathsf{LCP}_{T}[\mathsf{ISA}_{T}[i]+1]\}$ is the longest repeating substring starting at $i$. If we extend this substring by the character to its right, it becomes unique. Thus, $T[i..i+\ell_{i}]$ is the shortest unique substring starting at $i$, except for the case that $i+\ell_{i}-1=n$ as we cannot extend it to the right (hence, there is no unique substring starting at $i$ in this case). Additionally, the substring $T[i..i+\ell_{i}]$ is a MUS iff $T[i+1..i+\ell_{i}]$ is not unique (we already checked that $T[i..i+\ell_{i}-1]$ is not unique). $T[i+1..i+\ell_{i}]$ is not unique iff $\ell_{i}\leq\ell_{i+1}$ since $T[i+1..i+1+\ell_{i+1}]$ is the shortest unique substring starting at $i+1$. Since each $\ell_{i}$ can be computed in $O(\pi_{a}(n))$ time for every $1\leq i\leq n$, the starting and ending positions of all MUSs (and hence, $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$) can be computed in $O(n\cdot\pi_{a}(n))$ time by a linear scan of the text. Therefore, the total computing time is $O(\pi_{c}(n)+n\cdot\pi_{a}(n))$ and the total working space is $2n+\pi_{s}(n)$ bits including the space for $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$. ∎

5 Compact Data Structure for the Interval SUS Problem

In this section, we propose a compact data structure for the interval SUS problem. It is based on the data structure of Mieno et al. [18], which we review in the following. We subsequently provide a compact representation of this data structure.

Data structures

The data structure proposed by Mieno et al. [18] consists of three arrays, each of length $m$: $\mathsf{X}_{T}$, $\mathsf{Y}_{T}$, and $\mathsf{MUSlen}_{T}$. The arrays $\mathsf{X}_{T}$ and $\mathsf{Y}_{T}$ store, respectively, the beginning positions and ending positions of all MUSs sorted by their beginning positions such that the interval $[\mathsf{X}_{T}[i],\mathsf{Y}_{T}[i]]$ is the $i$-th MUS, for every integer $i$ with $1\leq i\leq m$. Further, $\mathsf{MUSlen}_{T}[i]=\mathsf{Y}_{T}[i]-\mathsf{X}_{T}[i]+1$ stores the length of $i$-th MUS. During a preprocessing phase, $\mathsf{X}_{T}$ and $\mathsf{Y}_{T}$ are endowed with a successor and a predecessor data structure, respectively. Further, $\mathsf{MUSlen}_{T}$ is endowed with an $\mathsf{RmQ}$ data structure.

Answering queries

Given a query interval $[s,t]$, let $\ell=\mathsf{Pred}_{Y_{T}}(t)$ be the index in $Y_{T}$ of the largest ending position of a MUS that is at most $t$, and $r=\mathsf{Succ}_{X_{T}}(s)$ be the index in $X_{T}$ of the smallest starting position of a MUS that is at least $s$. Then, $\mathsf{SUS}_{T}([s,t])\subset\{\mathit{cover}([s,t],[X_{T}[i],Y_{T}[i]])\mid\ell\leq i\leq r\}$. That is because the shortest intervals in $\{\mathit{cover}([s,t],[X_{T}[i],Y_{T}[i]])\mid\ell\leq i\leq r\}$ correspond to the shortest unique substrings (SUSs) among all substrings covering the interval $[s,t]$. Thus, one of the SUSs for $[s,t]$ can be detected by considering $\mathit{cover}([s,t],[X_{T}[\ell],Y_{T}[\ell]])$ (as a candidate for the leftmost SUS), $\mathit{cover}([s,t],[X_{T}[r],Y_{T}[r]])$ (as a candidate for the rightmost SUS), and $\mathsf{RmQ}_{\mathsf{MUSlen}_{T}}(\ell+1,r-1)$. To output all SUSs, it is sufficient to answer $\mathsf{RmQ}$ queries on subintervals of $\mathsf{MUSlen}_{T}[\ell+1..r-1]$ recursively. In detail, suppose that there is a MUS in $\mathsf{MUSlen}_{T}[\ell+1..r-1]$ that is a SUS for $[s,t]$. Further suppose that this is the $j$-th MUS having length $k$. Then we query $\mathsf{MUSlen}_{T}[\ell+1..j-1]$ and $\mathsf{MUSlen}_{T}[j+1..r-1]$ for all other MUSs of minimal length $k$.

Compact Representation

Having the two bit arrays $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$ of Section 4, we can simulate the three arrays $\mathsf{X}_{T}$, $\mathsf{Y}_{T}$, and $\mathsf{MUSlen}_{T}$. By endowing these two bit arrays with rank/select data structures of Lemma 2, we can compute rank/select in constant time, which allows us to compute the value of $\mathsf{X}_{T}[p]$, $\mathsf{Y}_{T}[p]$, $\mathsf{MUSlen}_{T}[p]$, $\mathsf{Pred}_{Y_{T}}(q)$ and $\mathsf{Succ}_{X_{T}}(q)$ for every index $p$ with $1\leq p\leq m$ and every text position $q$ with $1\leq q\leq n$ in constant time while using only $2n+o(n)$ bits of total space. By endowing $\mathsf{MUSlen}_{T}$ with the $\mathsf{RmQ}$ data structure of Lemma 3, we can answer an $\mathsf{RmQ}$ query on $\mathsf{MUSlen}_{T}$ in constant time. This data structure takes $2m+o(m)$ bits of space. Altogether, with these data structures we yield the following theorem:

Theorem 1**.**

For the interval SUS problem, there exists a data structure of size $2n+2m+o(n)$ bits that can answer an interval SUS query in $O(occ)$ time, where $occ$ is the number of SUSs of $T$ for the respective query interval.

Also, the data structure can be constructed space-efficiently:

Lemma 6**.**

Given $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$, the data structure proposed in Theorem 1 can be constructed in $O(n)$ time using $2m+o(n)$ bits of total working space, which includes the space for this data structure.

Proof.

The data structure proposed in Theorem 1 consists of the two bit arrays $\mathsf{MB}_{T}$, $\mathsf{ME}_{T}$, and an $\mathsf{RmQ}$ data structure on $\mathsf{MUSlen}_{T}$, which is simulated by rank/select data structures on $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$. Since $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$ are already given, it is left to endow $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$ with rank/select data structures (using Lemma 2), and to compute the $\mathsf{RmQ}$ data structure on $\mathsf{MUSlen}_{T}$ (using Lemma 3). ∎

6 Compact Data Structure for the Point SUS Problem

Before solving the point SUS problem, we borrow some additional notations from Tsuruta et al. [25] to deal with point SUS queries. This is necessary since some of the MUSs never take part in finding a SUS such that there is no meaning to compute and store them. Since we want to provide an output-sensitive algorithm answering a query in optimal time, we only want to store MUSs that are candidates for being a SUS.

We say that the interval $[x,y]\in\mathsf{MUS}_{T}$ is a meaningful MUS if $T[x..y]$ is a substring of (or equal to) a point SUS, i.e., $\mathit{cover}([x,y],p)\in\mathsf{SUS}_{T}(p)$ for a position $p$. Also, we say that the interval $[x,y]\in\mathsf{MUS}_{T}$ is a meaningless MUS if $[x,y]$ is not a meaningful MUS. Let

[TABLE]

denote the set of all meaningful MUSs of $T$.

Let ${{\textrm{{lmSUS}}}}_{T}^{p}$ denote the interval in $\mathsf{SUS}_{T}(p)$ with the leftmost starting position, and let ${{\textrm{{lmMUS}}}}_{T}^{p}$ denote the MUS contained in ${{\textrm{{lmSUS}}}}_{T}^{p}$. We say that ${{\textrm{{lmSUS}}}}_{T}^{p}$ is the leftmost SUS for $p$, and ${{\textrm{{lmMUS}}}}_{T}^{p}$ is the leftmost MUS for $p$. Similarly, we define the rightmost SUS ${{\textrm{{rmSUS}}}}_{T}^{p}$ and the rightmost MUS ${{\textrm{{rmMUS}}}}_{T}^{p}$ for $p$ by symmetry. See Fig. 1 for an example for the leftmost/rightmost SUS and MUS.

Let $\mathsf{L}_{T}$ be an array of length $n$ such that $\mathsf{L}_{T}[i]$ is the length of a SUS333Although there can be multiple SUSs containing $i$, their lengths are all equal. of $T$ containing $i$ for each position $i$ with $1\leq i\leq n$. Let $\mathsf{B}_{T}$ be a bit array of length $n$ such that $\mathsf{B}_{T}[i]=\mathsf{1}$ iff $i$ is the beginning position of a meaningful MUS of $T$.

From the definition of $\mathsf{L}_{T}$, we yield the following observation:

Observation 1**.**

For every position $p$ with $1\leq p\leq n$ and every interval $[x,y]\in\mathsf{SUS}_{T}(p)$, $p-\mathsf{L}_{T}[p]+1\leq x\leq p\leq y\leq p+\mathsf{L}_{T}[p]-1$.

Next, we define the following four functions related to $\mathsf{L}_{T}$ and $\mathsf{B}_{T}$. For a position $q$ with $1\leq q\leq n$ let

• •

$\mathit{pred}\mathsf{1}\mathit{pos}_{\mathsf{B}_{T}}(q):=\max\{i\mid i\leq q\mbox{~{}and~{}}\mathsf{B}_{T}[i]=\mathsf{1}\}$,

• •

$\mathit{succ}\mathsf{1}\mathit{pos}_{\mathsf{B}_{T}}(q):=\min\{i\mid i\geq q\mbox{~{}and~{}}\mathsf{B}_{T}[i]=\mathsf{1}\}$,

• •

$\mathit{predneq}_{\mathsf{L}_{T}}(q):=\max\{i\mid i<q\mbox{~{}and~{}}\mathsf{L}_{T}[i]\neq\mathsf{L}_{T}[q]\}$, and

• •

$\mathit{succneq}_{\mathsf{L}_{T}}(q):=\min\{i\mid i>q\mbox{~{}and~{}}\mathsf{L}_{T}[i]\neq\mathsf{L}_{T}[q]\}$.

For all four functions, we stipulate that $\min\{\}=\max\{\}=\mathit{nil}$. See Fig. 3 for an example of the arrays and functions defined above.

6.1 Finding SUSs with $\mathsf{L}$ and $\mathsf{B}$

Our idea is to answer point SUS queries with $\mathsf{L}_{T}$ and $\mathsf{B}_{T}$. For that, we first think about how to find the leftmost and rightmost SUS for a given query (Observation 1 gives us the range in which to search). Having this leftmost and the rightmost SUS, we can find all other SUSs with $\mathsf{B}_{T}$ marking the beginning positions of the meaningful MUSs that correspond to the SUSs we want to output. Before that, we need some properties of $\mathsf{L}_{T}$ that help us to prove the following lemmas in this section: Lemma 7 gives us a hint on the shape of $\mathsf{L}_{T}$, while Lemma 8 shows us how to find SUSs based on two consecutive values of $\mathsf{L}_{T}$ with a connection to MUSs.

Lemma 7**.**

$|\mathsf{L}_{T}[p]-\mathsf{L}_{T}[p+1]|\leq 1$* for every position $p$ with $1\leq p\leq n-1$.*

Proof.

Let $\ell=\mathsf{L}_{T}[p]$ and $\ell^{\prime}=\mathsf{L}_{T}[p+1]$. From the definition of $\mathsf{L}_{T}$, there exists a unique substring of length $\ell$ containing the position $p$. If $\ell<\ell^{\prime}$, there is no unique substring of length $\ell$ containing $p+1$. Thus, $T[p-\ell+1..p]$ is unique, and consequently $T[p-\ell+1..p+1]$ is also unique. Hence, $\ell^{\prime}=\ell+1$. Similarly, in the case of $\ell>\ell^{\prime}$, it can be proven that $\ell^{\prime}=\ell-1$. ∎

Lemma 8**.**

Let $p$ be a position with $1\leq p\leq|T|-1$, and let $\ell:=\mathsf{L}_{T}[p]$. If $\mathsf{L}_{T}[p+1]=\ell+1$, then

• •

$T[p-\ell+1..p]\in\mathsf{SUS}_{T}(p)$,

• •

$T[p-\ell+1..p+1]\in\mathsf{SUS}_{T}(p+1)$, and

• •

$p-\ell+1$* is the starting position of a MUS of $T$.*

If $\mathsf{L}[p+1]=\ell-1$ then

• •

$T[p..p+\ell-1]\in\mathsf{SUS}_{T}(p)$,

• •

$T[p+1..p+\ell-1]\in\mathsf{SUS}_{T}(p+1)$, and

• •

$p+\ell-1$* is the ending position of a MUS of $T$.*

Proof.

First, we consider the case that $\mathsf{L}_{T}[p+1]=\ell+1$. From the proof of Lemma 7, $T[p-\ell+1..p]$ and $T[p-\ell+1..p+1]$ are unique substrings in $T$. Thus, $T[p-\ell+1..p]\in\mathsf{SUS}_{T}(p)$ and $T[p-\ell+1..p+1]\in\mathsf{SUS}_{T}(p+1)$. Since every point SUS contains exactly one MUS (cf. Lemma 4), there exists a MUS $[b,e]\subset[p-\ell+1,p]$. Assume that $b>p-\ell+1$, then $T[b..p]$ is the shortest unique substring among all substrings containing the text position $p$. Its length is $p-b+1<\ell$. This contradicts that $T[p-\ell+1..p]\in SUS_{T}(p)$, and therefore $b=p-\ell+1$ must hold. The remaining case $\mathsf{L}_{T}[p+1]=\ell-1$ can be proven analogously by symmetry. ∎

In the following two lemmas (Lemmas 9 and 10), we focus on finding the leftmost SUS and the rightmost SUS for a given query point. That is because the leftmost SUS and the rightmost SUS give us an interval containing the starting positions of the remaining SUSs we want to report444The actual reporting of those SUSs is done in Lemma 14.

Lemma 9**.**

Let $p$ be a position with $1\leq p\leq n$, and let $\ell=\mathsf{L}_{T}[p]$, $b=\mathit{succ}\mathsf{1}\mathit{pos}_{\mathsf{B}_{T}}(\max\{1,p-\ell+1\})$, and $q=\mathit{predneq}_{\mathsf{L}_{T}}(p)$. Then, $b\leq\min\{p+\ell-1,n\}$ and

[TABLE]

Proof.

If $\ell=1$, it is clear that the interval $[p,p]$ of length 1 is a MUS of $T$, thus $b=p$ and ${{\textrm{{lmSUS}}}}_{T}^{p}=[p,p]$. For the rest of the proof, we focus on the case that $\ell\geq 2$. Since $\mathsf{L}_{T}[p]=\ell$, there exists a unique substring of length $\ell$ containing the position $p$, and there exists at least one MUS that is a subinterval of $[p-\ell+1,p+\ell-1]$. Thus, $b\leq\min\{p+\ell-1,n\}$. See Fig. 4 for an illustration of each of the above cases we consider in the following:

1. (1a)

Assume that there exists a unique substring $T[p^{\prime}..p^{\prime}+\ell-1]$ containing the position $p$ with $p^{\prime}<p$. Since $b\geq p>p^{\prime}$, $T[p^{\prime}+1..p^{\prime}+\ell-1]$ is also unique and contains position $p$. It contradicts $\mathsf{L}_{T}[p]=\ell$; therefore, ${{\textrm{{lmSUS}}}}_{T}^{p}=[p,p+\ell-1]$. 2. (1b)

From the definition of $q$ and Lemma 7, $\mathsf{L}_{T}[q]=\ell+1$ and $\mathsf{L}_{T}[q+1]=\ell$. From Lemma 8, $[q+1,q+\ell]$ is unique. Also, $[q+1,q+\ell]\in\mathsf{SUS}_{T}(p)$ because $p\in[q+1,q+\ell]$. Since $\mathsf{L}_{T}[q]=\ell+1$, there is no unique substring that contains the position $q$ and is shorter than $\ell+1$. Therefore, ${{\textrm{{lmSUS}}}}_{T}^{p}=[q+1,q+\ell]$. 3. (1c)

We divide this case into two subcases:

• (1c-1)

$b<p$ and $q\geq p-\ell+1$ and $\mathsf{L}_{T}[q]<\ell$, or

• (1c-2)

$b<p$ and $q<p-\ell+1$.

In Subcase (1c-1), from the definition of $q$ and Lemma 7, $\mathsf{L}_{T}[q]=\ell-1$ and $\mathsf{L}_{T}[i]=\ell$ for all $i\in[q+1,p]$. From Lemma 8, the interval $[q-\ell+2,q]$ of length $\ell-1$ is unique. Since $[p-\ell+1,q]\subset[q-\ell+2,q]$, $\mathsf{L}_{T}[i]\leq\ell-1$ for all $i\in[p-\ell+1,q]$. In Subcase (1c-2), it is clear that $\mathsf{L}_{T}[i]=\ell$ for all $i\in[p-\ell+1,p]$. Therefore, $\mathsf{L}_{T}[i]\leq\ell$ for all $i\in[p-\ell+1,p]$ in both subcases.

Let $e$ be the ending position of the meaningful MUS $[b,e]$ starting at the position $b$, and $\ell^{\prime}=e-b+1$ be the length of this MUS. We assume $\ell^{\prime}>\ell$ for the sake of contradiction (and thus $[b,e]$ cannot be ${{\textrm{{lmMUS}}}}_{T}^{p}$ whose length is at most $\ell$). Since $b\geq p-\ell+1$ and $\ell^{\prime}>\ell$, $e>p$ must hold. Let $[b^{\prime},e^{\prime}]={{\textrm{{lmMUS}}}}_{T}^{p}$. Since (a) there is no interval $[x,y]\in\mathsf{SUS}_{T}(p)$ such that $x<\min\{b,p\}$, and (b) MUSs cannot be nested, it follows that $b^{\prime}>b$ and $e^{\prime}>e$. Thus, ${{\textrm{{lmSUS}}}}_{T}^{p}=\mathit{cover}([b^{\prime},e^{\prime}],p)=[e^{\prime}-\ell+1,e^{\prime}]$ and $\mathsf{L}_{T}[i]\leq\ell$ for all $p\leq i\leq e^{\prime}$. Since $[b,e]\subset[p-\ell+1,e^{\prime}]$, $\mathsf{L}_{T}[i]\leq\ell$ for all $b\leq i\leq e$. This contradicts that the MUS $[b,e]$ of length $\ell^{\prime}>\ell$ is a meaningful MUS. Therefore, $\ell^{\prime}\leq\ell$ and ${{\textrm{{lmSUS}}}}_{T}^{p}=\mathit{cover}([b,e],p)=[b,b+\ell-1]$.

∎

From Lemma 9 we yield the following corollary:

Corollary 1**.**

If we can compute $\mathsf{L}_{T}[i]$, $\mathit{predneq}_{\mathsf{L}_{T}}(i)$ and $\mathit{succ}\mathsf{1}\mathit{pos}_{\mathsf{B}_{T}}(i)$ in constant time for each $i$ with $1\leq i\leq n$, we can compute ${{\textrm{{lmSUS}}}}_{T}^{p}$ in constant time for each position $p$ with $1\leq p\leq n$.

Lemma 10**.**

Let $p$ be a position with $1\leq p\leq n$, and let $\ell=\mathsf{L}_{T}[p]$, $q=\mathit{succneq}_{\mathsf{L}_{T}}(p)$, and $b=\mathit{pred}\mathsf{1}\mathit{pos}_{\mathsf{B}_{T}}(p)$. Then,

[TABLE]

Proof.

If $\ell=1$, it is clear that the interval $[p,p]$ of length 1 is a MUS of $T$, thus $b=p$ and ${{\textrm{{rmSUS}}}}_{T}^{p}=[p,p]$. We consider the condition of $\ell\geq 2$. See Fig. 5 for an illustration of each of the above cases we consider in the following:

1. (2a)

From Lemma 8, $[p,p+\ell-1]$ is a SUS for $p$, which is by definition the rightmost one. 2. (2b)

In this case, $\mathsf{L}_{T}[q]=\ell+1$ and $\mathsf{L}_{T}[q-1]=\ell$. From Lemma 8, $[q-\ell,q-1]$ is unique. Since $p\in[q-\ell,q+1]$, $[q-\ell,q-1]$ is a SUS for $p$. Additionally, there is no unique interval $[x,y]\in\mathsf{SUS}_{T}(p)$ such that $y\geq q$ because $\mathsf{L}_{T}[q]=\ell+1$. Thus, ${{\textrm{{rmSUS}}}}_{T}^{p}=[q-\ell,q-1]$. 3. (2c)

We divide this case into two subcases:

• (2c-1)

$p+1<q\leq p+\ell-1$ and $\mathsf{L}_{T}[q]<\ell$, or

• (2c-2)

$q>p+\ell-1$.

In Subcase (2c-1), $\mathsf{L}_{T}[p+1]=\ell$ and $\mathsf{L}_{T}[q]=\ell-1$ and $\mathsf{L}_{T}[i]=\ell$ for all $p+2\leq i\leq q-1$. From Lemma 8, $[q,q+\ell-2]$ (of length $\ell-1$) is unique. Since $[q,p+\ell-1]\subset[q,q+\ell-2]$, $\mathsf{L}_{T}[i]\leq\ell-1$ for all $q\leq i\leq p+\ell-1$. In Subcase (2c-2), from the definition of $q$, $\mathsf{L}_{T}[i]=\ell$ for all $p\leq i\leq p+\ell-1$. Therefore, $\mathsf{L}_{T}[p+1]=\ell$ and $\mathsf{L}_{T}[i]\leq\ell$ for all integers $i$ with $p+2\leq i\leq p+\ell-1$ in both subcases.

For the sake of contradiction, assume that there is a MUS $[b^{\prime},e^{\prime}]$ such that $b^{\prime}>p$ and $\mathit{cover}([b^{\prime},e^{\prime}],p)=[p,e^{\prime}]\in\mathsf{SUS}_{T}(p)$. Since $\mathsf{L}_{T}[p]=\ell$, $[p,e^{\prime}]$ is a unique substring of length $\ell$. Hence, $\mathit{cover}([b^{\prime},e^{\prime}],p+1)=[p+1,e^{\prime}]$ is a unique substring of length $\ell-1$. It contradicts $\mathsf{L}_{T}[p+1]=\ell$; therefore, the beginning position of the rightmost MUS for $p$ is at most $p$. Next, we show that the MUS starting at $b$ is the rightmost meaningful MUS for $p$. Let $e$ be its ending position, and $\ell^{\prime}=e-b+1$ be its length. We assume that $\ell^{\prime}>\ell$ for the sake of contradiction (and thus, $[b,e]$ is not ${{\textrm{{rmMUS}}}}_{T}^{p}$ whose length is at most $\ell$). Since $\mathsf{L}_{T}[p]=\ell$, $b\geq p-\ell+1$ and $e>p$. Let $[b^{\prime\prime},e^{\prime\prime}]={{\textrm{{rmMUS}}}}_{T}^{p}$. Since MUSs cannot be nested, $b^{\prime\prime}<b$. Since $e^{\prime\prime}-b^{\prime\prime}+1\leq\ell$, $\mathsf{L}_{T}[i]\leq\ell$ for all $i$ with $b^{\prime\prime}\leq i\leq p+\ell-1$. We consider two cases to obtain a contradiction:

• •

If $e\leq p+\ell-1$ then it is clear that $\mathsf{L}_{T}[i]\leq\ell$ for all $i$ with $b\leq i\leq e$. This contradicts that the MUS $[b,e]$ of length $\ell^{\prime}$ is a meaningful MUS.

• •

If $e>p+\ell-1$, it is clear that $|\mathit{cover}([b,e],p+\ell-1)|=|[b,e]|=\ell^{\prime}$. Since $\mathsf{L}_{T}[p+\ell-1]\leq\ell$, there exists a unique substring $[s,t]$ such that $s\leq p+\ell-1\leq t$ and $t-s+1\leq\ell$. Hence, $\mathsf{L}_{T}[i]\leq\ell$ for all $i$ with $s\leq i\leq t$. Since $[b,e]$ is a MUS and $p\leq s$, $b<s<e<t$. Consequently, $\mathsf{L}_{T}[i]\leq\ell$ for all $i$ with $b\leq i\leq e$ and this contradicts that the MUS $[b,e]$ of length $\ell^{\prime}$ is a meaningful MUS.

Therefore, $\ell^{\prime}\leq\ell$ and ${{\textrm{{rmSUS}}}}_{T}^{p}=\mathit{cover}([b,e],p)=[b,b+\ell-1]$.

∎

Corollary 2**.**

If we can compute $\mathsf{L}_{T}[i]$, $\mathit{succneq}_{\mathsf{L}_{T}}(i)$ and $\mathit{pred}\mathsf{1}\mathit{pos}_{\mathsf{B}_{T}}(i)$ in constant time for each $i$ with $1\leq i\leq n$, we can compute ${{\textrm{{rmSUS}}}}_{T}^{p}$ in constant time for each position $p$ with $1\leq p\leq n$.

6.2 Compact Representations of $\mathsf{L}$

We now propose a succinct representation of the array $\mathsf{L}_{T}$ consisting of the integer array $\mathsf{LD}_{T}$ of length $n$ defined as $\mathsf{LD}_{T}[1]=0$ and $\mathsf{LD}_{T}[i]=\mathsf{L}_{T}[i]-\mathsf{L}_{T}[i-1]\in\{\mathtt{-1},\mathtt{0},\mathtt{1}\}$ for every $i$ with $2\leq i\leq n$.

Lemma 11**.**

The data structure of Theorem 1 can compute $\mathsf{L}_{T}[p]$ in constant time with $O(\log n)$ bits of additional working space for each $p$ with $1\leq p\leq n$.

Proof.

Suppose that we have the data structure $D$ of Theorem 1 and want to know $\mathsf{L}_{T}[p]$. We query $D$ with the interval $[p,p]$ to retrieve one SUS for the query interval $[p,p]$ in constant time. This can be achieved by stopping the retrieval after the first SUS $[i,j]\in\mathsf{SUS}_{T}([p,p])$ has been reported. Since all SUSs for $[p,p]$ have the same length, $\mathsf{L}_{T}[p]=j-i+1$. The additional working space is $O(\log n)$ bits. ∎

Lemma 11 allows us to compute $\mathsf{LD}_{T}$ in $O(n)$ time, which we represent as an integer array with bit width two, thus using $2n$ bits of space. In the following, we build a compressed rank/select data structure on $\mathsf{LD}_{T}$. This data structure is a self-index such that we no longer need to keep $\mathsf{LD}_{T}$ in memory. With $\mathsf{LD}_{T}$ we can access $\mathsf{L}_{T}$, as can be seen by the following lemma:

Lemma 12**.**

There exists a data structure of size $\lceil n\log_{2}{3}\rceil+o(n)$ bits that can access $\mathsf{L}_{T}[i]$, and can compute $\mathit{predneq}_{\mathsf{L}_{T}}(i)$ and $\mathit{succneq}_{\mathsf{L}_{T}}(i)$ in constant time for each position $i$ with $1\leq i\leq n$. Given $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$, the data structure can be constructed in $O(n)$ time using $2n+\max\{\lceil n\log_{2}{3}\rceil,2m\}+o(n)$ bits of total working space, which includes the space for this data structure.

Proof.

The following equations hold for every text position $i$ with $1\leq i\leq n$:

[TABLE]

We can compute the value of $\mathsf{L}_{T}[1]$ and $\mathsf{LD}_{T}$ with Lemma 11. With a rank/select data structure on $\mathsf{LD}_{T}$ we can compute the above functions. Such a data structure is the Huffman-shaped wavelet tree [16]. This data structure can be constructed in linear time and takes $\lceil n\log_{2}{3}\rceil+o(n)$ bits of space, since the possible number of different values in $\mathsf{LD}_{T}$ is three. Therefore, it can also provide answers to rank/select queries in constant time. ∎

Finally, we show how to compute $\mathsf{B}_{T}$:

Lemma 13**.**

There exists a data structure of size $n+o(n)$ bits that can compute $\mathit{succ}\mathsf{1}\mathit{pos}_{\mathsf{B}_{T}}(i)$ and $\mathit{pred}\mathsf{1}\mathit{pos}_{\mathsf{B}_{T}}(i)$ in constant time for each position $1\leq i\leq n$. Given $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$, this data structure can be constructed in $O(n)$ time using $3n+\lceil n\log_{2}{3}\rceil+o(n)$ bits of total working space including the space for this data structure.

Proof.

Our idea is to compute $\mathsf{B}_{T}$ since the following equations hold for every text position $i$ with $1\leq i\leq n$ (cf. $BIT_{Y}$ in Section 3.2):

[TABLE]

In the following we show how to compute $\mathsf{B}_{T}$ from $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$ in linear time with linear number of bits of working space. Let $b_{i}=\mathit{select}_{\mathsf{MB}_{T}}(\mathtt{1},i)$ and $e_{i}=\mathit{select}_{\mathsf{ME}_{T}}(\mathtt{1},i)$ be the starting position and the ending position of the $i$-th MUS respectively, for each $1\leq i\leq m$. Given $x_{i}=\mathsf{RMQ}_{\mathsf{L}_{T}}(b_{i},e_{i})$, $\mathsf{L}_{T}[x_{i}]\leq e_{i}-b_{i}+1$ since $b_{i}\leq x_{i}\leq e_{i}$ and $[b_{i},e_{i}]$ is unique. If $\mathsf{L}_{T}[x_{i}]<e_{i}-b_{i}+1$, there is no position $p$ with $\mathit{cover}([b_{i},e_{i}],p)\in\mathsf{SUS}_{T}(p)$, i.e., $[b_{i},e_{i}]$ is a meaningless MUS. Otherwise ($\mathsf{L}_{T}[x_{i}]=e_{i}-b_{i}+1$), $\mathit{cover}([b_{i},e_{i}],x_{i})=[b_{i},e_{i}]\in\mathsf{SUS}_{T}(x_{i})$, i.e., $[b_{i},e_{i}]$ is a meaningful MUS. Hence, it can be detected in constant time whether a MUS is meaningful by an $\mathsf{RMQ}$ query on $\mathsf{L}_{T}$. We can compute the compact representation of $\mathsf{L}_{T}$ described in Lemma 12. The data structure takes $\lceil n\log_{2}{3}\rceil+o(n)$ bits and can be constructed with $2n+\max\{\lceil n\log_{2}{3}\rceil,2m\}+o(n)$ bits of total working space. Subsequently, we endow it with the $\mathsf{RMQ}$ data structure of Lemma 3 in $O(n)$ time using $2n+o(n)$ bits of space. Therefore, the computing time of $\mathsf{B}_{T}$ is $O(n)$ and the working space is, aside from the space for $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$, $3n+\lceil n\log_{2}{3}\rceil+o(n)$ bits, including the space for $\mathsf{B}_{T}$. Finally, we can endow $\mathsf{B}_{T}$ with rank/select data structures, which allows us to compute each of the above two functions $\mathit{pred}\mathsf{1}\mathit{pos}_{\mathsf{B}_{T}}$ and $\mathit{succ}\mathsf{1}\mathit{pos}_{\mathsf{B}_{T}}$ in constant time. ∎

Actually, having $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$ available, we can simulate an access to $\mathsf{L}_{T}[i]$ in constant time with Lemma 11 by using the $\mathsf{RmQ}$ data structure on $\mathsf{MUSlen}_{T}$. This allows us to compute the $\mathsf{RMQ}$ data structure on $\mathsf{L}_{T}$ directly without the need for computing $\mathsf{B}_{T}$ in the first place, i.e., we can replace the working space of Lemma 13 with $2n+2m+o(n)$ additional bits of working space. However, since our final data structure needs $\mathsf{LD}_{T}$, computing $\mathsf{B}_{T}$ before $\mathsf{LD}_{T}$ would require more working space in the end than the other way around, since we no longer need the $\mathsf{RmQ}$ data structure on $\mathsf{MUSlen}_{T}$ after having built the rank/select data structure of Lemma 12.

Before stating our final theorem, we need a property for meaningful MUSs:

Lemma 14**.**

On the one hand, $\mathit{cover}([s_{i},e_{i}],p)\in\mathsf{SUS}_{T}(p)$ for every meaningful MUS $[s_{i},e_{i}]$ starting with or after the leftmost MUS for $p$ and starting before or with the rightmost MUS for $p$. On the other hand, each element (i.e., an interval) of $\mathsf{SUS}_{T}(p)$ starting with or after the leftmost MUS for $p$ and starting before or with the rightmost MUS for $p$ contains exactly one distinct MUS.

Proof.

The first part is shown by Tsuruta et al. [25, Lemma 3]. The second part is due to Lemma 4. ∎

Theorem 2**.**

For the point SUS problem, there exists a data structure of size $n+\lceil n\log_{2}{3}\rceil+o(n)$ bits that can answer a point SUS query in $O(occ)$ time, where $occ$ is the number of SUSs of $T$ for the respective query point. Given $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$, the data structure can be constructed in $O(n)$ time using $3n+\lceil n\log_{2}{3}\rceil+o(n)$ bits of total working space, which includes the space for this data structure.

Proof.

Let $p$ be a query position, and suppose that the number of SUSs for $p$ is $occ$. Like the MUSs in Section 4, we rank the SUSs for $p$ by their starting positions. Let $[s_{j},e_{j}]$ be the $j$-th SUS for $p$ with $1\leq j\leq occ$ such that $[s_{1},e_{1}]$ and $[s_{occ},e_{occ}]$ are the leftmost SUS and the rightmost SUS for $p$, respectively. If $s_{1}=p$ then $[s_{1},e_{1}]=[s_{occ},e_{occ}]$, and thus the output consists of this single interval. Otherwise ($s_{1}\neq p$), we can compute $s_{i}$ iteratively from $s_{i-1}$ by $s_{i}=\mathit{select}_{\mathsf{B}_{T}}(\mathtt{1},\mathit{rank}_{\mathsf{B}_{T}}(\mathtt{1},s_{i-1})+1)$ in constant time for each $i$ with $2\leq i\leq occ-1$, allowing us to answer the query in time linear to the number of SUSs. As $occ$ is not known in advance, we stop the iteration whenever we computed an $s_{i}$ that is larger than the starting position of the rightmost SUS for $p$. A detailed analysis of the claimed working space is given in Table 1. ∎

Corollary 3**.**

The data structure of Theorem 2 can compute the number of SUSs for a query position in constant time.

Proof.

Let $[s_{l},e_{l}]$ and $[s_{r},e_{r}]$ be the leftmost and the rightmost SUS for a given query position, respectively. All MUSs starting between $s_{l}$ and $s_{r}$ (excluding $s_{l}$ and $s_{r}$) are SUSs for this query position. Let $occ^{\prime}$ be their number. Therefore, the number we want to output is $occ=occ^{\prime}+2$. With Lemmas 9 and 10, we can find $[s_{l},e_{l}]$ and $[s_{r},e_{r}]$ in constant time. Further, we can compute $occ^{\prime}$ in constant time since $occ^{\prime}=\mathit{rank}_{\mathsf{B}_{T}}(\mathtt{1},s_{r}-1)-\mathit{rank}_{\mathsf{B}_{T}}(\mathtt{1},s_{l})$. ∎

7 Auxiliary Data Structure

In the following, we present three different representations of the data structure required by Lemma 5. See Table 2 for a juxtaposition of their characteristics. Also, we present an algorithm for computing MUSs by using $\mathsf{RankSucc}_{T}$ and a succinct representation of $\mathsf{PLCP}_{T}$.

Lemma 15** ([3, Sect. 2.2.3]).**

Given a constant $\epsilon$ with $0<\epsilon\leq 1$, there is a data structure that can access $\mathsf{ISA}_{T}[i]$ and $\mathsf{LCP}_{T}[i]$ in $\pi_{a}(n)=O(\epsilon^{-1})$ time using $\pi_{s}(n)=(1+\epsilon)n\log n+O(n)$ bits of working space. It can be constructed within this working space in $\pi_{c}(n)=O(\epsilon^{-2}n)$ time.

Lemma 16**.**

Given a constant $\epsilon$ with $0<\epsilon\leq 1$, there is a data structure that can access $\mathsf{ISA}_{T}[i]$ and $\mathsf{LCP}_{T}[i]$ in $\pi_{a}(n)=O(\log_{\sigma}^{\epsilon}n)$ time using $\pi_{s}(n)=O(\epsilon^{-1}n\log\sigma)$ bits of working space. It can be constructed within this working space in $\pi_{c}(n)=O(n\log_{\sigma}^{\epsilon}n)$ time.

Proof.

We use the compressed suffix tree presented in [20]. While the succinct suffix tree naturally supports the required access queries, the compressed suffix tree needs to be enhanced with a sampling data structure to support access to $\mathsf{ISA}_{T}[i]$ and $\mathsf{LCP}_{T}[i]$. In detail, it provides access to the PLCP array $\mathsf{PLCP}_{T}$. Our idea is to provide access to $\mathsf{SA}_{T}$ and $\mathsf{ISA}_{T}$ in $O(\log^{\epsilon}n)$ time. For the former, we use a sampling of $\mathsf{SA}_{T}$ with $O(\epsilon^{-1}n\log\sigma)$ bits to obtain access to $\mathsf{SA}_{T}$ with $O(\log^{\epsilon}_{\sigma}n)$ time [6, Sect. 3.2]. For the latter, having this $\mathsf{SA}_{T}$ representation, we create a representation of $\mathsf{ISA}_{T}$ using $O(\epsilon^{-1}n\log\sigma)$ space in $O(n\log^{\epsilon}_{\sigma}n)$ time [21]. This representation can access $\mathsf{ISA}_{T}[i]$ in $O(\log^{\epsilon}n)$ time. ∎

Lemma 17**.**

There is a data structure that can access $\mathsf{ISA}_{T}[i]$ and $\mathsf{LCP}_{T}[i]$ in $\pi_{a}(n)=O(\log r\log^{O(1)}n)$ time using $\pi_{s}(n)=r\log^{O(1)}n+O(n)$ bits of working space. It can be constructed within this working space in $\pi_{c}(n)=O(n+r\log^{O(1)}n)$ time.

Proof.

Like in the proof of Lemma 16, we provide access to $\mathsf{LCP}_{T}$ by $\mathsf{PLCP}_{T}$ and $\mathsf{SA}_{T}$: First, we compute the run-length encoded BWT in $O(n\log r)$ time stored in $O(r\log n)$ bits of space [22]. Next, we build a data structure answering $\mathsf{SA}_{T}[i]$ and $\mathsf{ISA}_{T}[i]$ in $O(\log^{O(1)}n\log r)$ time while using $O(r\log n+n)$ bits of space [13, Thm 5.1]. It can be constructed in $O(n+r\log^{O(1)}n)$ time with $O(n+r\log^{O(1)}n)$ bits of working space.

∎

Lemma 18**.**

We can compute $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$ in $O(n)$ time using $n\log n+O(\sigma\log n)+4n+o(n)$ bits of total working space including the space for $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$.

Proof.

First, we construct $\mathsf{RankPred}_{T}$ from $T$ using additional $O(\sigma\lg n)$ bits of working space [5]. Our second target is the succinct representation of the PLCP array $\mathit{succPLCP}_{T}$ of Sadakane [24] using $2n+o(n)$ bits of space while allowing constant time random access to each PLCP value. We can compute it from $\mathsf{RankPred}_{T}$ [12]. After computing $\mathit{succPLCP}_{T}$, we delete $\mathsf{RankPred}_{T}$. Subsequently, we construct $\mathsf{RankSucc}_{T}$ from $T$ similarly to Goto et al. [5]555They proposed a construction algorithm only for $\mathsf{RankPred}_{T}$. However, we can modify the algorithm to construct $\mathsf{RankSucc}_{T}$. Their algorithm simulates a suffix array construction algorithm, but uses $O(\sigma\lg n)$ pointers to positions in $\mathsf{RankPred}_{T}$ at which new values are inserted. By these pointers, they represent $\mathsf{RankPred}_{T}$ as $2\sigma$ linked lists. In [5, Step 4 in Sect. 4.2.2], they show how to invert these lists. Consequently, we can use this step to invert all lists after all elements have been inserted. . Finally, we obtain $\mathit{succPLCP}_{T}$ and $\mathsf{RankSucc}_{T}$. All the steps can be executed in $O(n)$ time.

In the following, we describe an algorithm for computing all MUSs of $T$ by using $\mathsf{PLCP}_{T}$ (in the succinct representation $\mathit{succPLCP}_{T}$) and $\mathsf{RankSucc}_{T}$. As described in the proof of Lemma 5, if we can compute $\ell_{i}=\max\{\mathsf{LCP}_{T}[\mathsf{ISA}_{T}[i]],$ $\mathsf{LCP}_{T}[\mathsf{ISA}_{T}[i]+1]\}$ in $\pi^{\prime}_{a}(n)$ time for each text position $i$ with $1\leq i\leq n$, then we can compute $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$ in $O(n\cdot\pi^{\prime}_{a}(n))$ time. Actually, we can achieve that $\pi^{\prime}_{a}(n)=O(1)$ by using the fact that $\ell_{i}=\max\{\mathsf{PLCP}_{T}[i],\mathsf{PLCP}_{T}[\mathsf{RankSucc}_{T}[i]]\}$. Therefore, we can compute $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$ in $O(n)$ time. Also, the total working space for the above procedure is $n\log n+O(\sigma\lg n)+4n+o(n)$ bits including the space for $\mathsf{MB}_{T}$ and $\mathsf{ME}_{T}$. ∎

8 Conclusions

In this paper, we proposed compact data structures for the interval SUS problem and the point SUS problem. Our data structure is the first data structure of size $O(n)$ bits for the interval SUS problem (resp. the point SUS problem). On the one hand, for the interval SUS problem, we proposed a data structure of size $2n+2m+o(n)$ bits answering a query in output-sensitive $O(occ)$ time, where $n$ is the length of the input string, $m$ is the number of MUSs in the input string, and $occ$ is the number of returned SUSs. On the other hand, for the point SUS problem, we proposed a data structure of size $\lceil(\log_{2}{3}+1)n\rceil+o(n)$ bits answering a query in the same output-sensitive time. The construction time and the working space of each data structures depends on the complexity of simulating the inverse suffix array and the LCP array of the input string. For example, by using the succinct suffix tree [3], we can achieve $O(n)$ time and $2n\log n+O(n)$ bits of working space to construct our data structures.

8.1 Open Problems

We are unaware of an algorithm computing $\mathsf{RankPred}_{T}$ or $\mathsf{RankSucc}_{T}$ from the text $T$ in-place for integer alphabets. Since it is possible to store $\mathsf{RankPred}_{T}$ in unary with the same representation as the succinct PLCP representation [24] in $O(r)$ space [14], where $r$ is the number of runs in the BWT, we wonder whether we can compute $\mathsf{RankPred}_{T}$ in compressed space. A possibility seems to adapt the in-place suffix array construction algorithm of Li et al. [15].

As future work, we want to extend our algorithm to compute SUSs with $k$ edits (or $k$ mismatches). A SUS with $k$ edits is a substring that is unique even when changing $k$ arbitrary characters (allowing deletions, insertions and character exchanges). Similarly, a SUS with $k$ mismatches is unique even when exchanging $k$ arbitrary characters. It is known that SUSs with $k$ edits (resp. mismatches) contain SUSs with $k-1$ edits (resp. mismatches), where SUSs with no edits (resp. no mismatches) are the ordinary SUSs.

Acknowledgments

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