Faster STR-IC-LCS computation via RLE

TL;DR

This paper introduces a faster algorithm for the STR-IC-LCS problem that leverages run-length encoding to improve efficiency on compressible strings, outperforming previous methods in such cases.

Contribution

The authors develop an $O(mN + nM)$-time algorithm for STR-IC-LCS using RLE, which is faster for compressible strings compared to the previous $O(MN)$ approach.

Findings

Algorithm is faster on RLE-compressible strings.

Runs in $O(mN + nM)$ time, improving efficiency.

Always as fast as previous algorithms, faster on certain inputs.

Abstract

The constrained LCS problem asks one to find a longest common subsequence of two input strings $A$ and $B$ with some constraints. The STR-IC-LCS problem is a variant of the constrained LCS problem, where the solution must include a given constraint string $C$ as a substring. Given two strings $A$ and $B$ of respective lengths $M$ and $N$, and a constraint string $C$ of length at most $\min\{M, N\}$, the best known algorithm for the STR-IC-LCS problem, proposed by Deorowicz~({\em Inf. Process. Lett.}, 11:423--426, 2012), runs in $O(MN)$ time. In this work, we present an $O(mN + nM)$-time solution to the STR-IC-LCS problem, where $m$ and $n$ denote the sizes of the run-length encodings of $A$ and $B$, respectively. Since $m \leq M$ and $n \leq N$ always hold, our algorithm is always as fast as Deorowicz's algorithm, and is faster when input strings are compressible via RLE.

Tables

Table 1. Table 1: Time complexities of best known solutions to various constrained LCS problems.

Problem	DP solution	DP solution using RLE
SEQ-IC-LCS	$O\left(MNK\right)$ [6]	$O\left(M+N+K\min \{mN,nM\}\right)$ [12]
SEQ-EC-LCS	$O\left(MNK\right)$ [5]	-
STR-IC-LCS	$O\left(MN\right)$ [7]	$O\left(mN+nM\right)$ [this work]
STR-EC-LCS	$O\left(MNK\right)$ [17]	-

Equations

$$[s_x,f_x]\equiv [s_y,f_y]⟺M_{\mathrm{1..}p-1}<s_x,s_y\le M_{\mathrm{1..}p}\text{mbox}and{M}_{\mathrm{1..}q-1}<f_x,f_y\le M_{\mathrm{1..}q},$$

$$L^{pref}(s-1,s^{\prime }-1)+L^{suf}(f+1,f^{\prime }+1)=L^{pref}(s+d-1,s^{\prime }+d-1)+L^{suf}(f+d+1,f^{\prime }+d+1).$$

Full text

1 Introduction

Longest common subsequence (LCS) is one of the most basic measures of similarity between strings, and there is a vast amount of literature concerning its efficient computation. An LCS of two strings $A$ and $B$ of lengths $M$ and $N$, respectively, is a longest string that is a subsequence of both $A$ and $B$. There is a well known $O(MN)$ time and space dynamic programming (DP) algorithm [15] to compute an LCS between two strings. LCS has applications in bioinformatics [10, 16], file comparisons [9, 8], pattern recognition [13], etc.

Recently, several variants of the problem which try to find a longest common subsequence that satisfy some constraints have been considered. In 2003, Tsai [14] proposed the constrained LCS (CLCS) problem, where, given strings $A,B$ with respective lengths $M,N$, and a constraint string $C$ of length $K$, the problem is to find a longest string that contains $C$ as a subsequence and is also a common subsequence of $A$ and $B$. Tsai gave an $O(M^{2}N^{2}K)$ time solution, which was improved in 2004 by Chin et al. to $O(MNK)$ time [6]. Variants of the constrained LCS problem called SEQ-IC-LCS, SEQ-EC-LCS, STR-IC-LCS, and STR-EC-LCS, were considered by Chen and Chao in 2011 [5]. Each problem considers as input, three strings $A,B$ and $C$, and the problem is to find a longest string that includes (IC) or excludes (EC) $C$ as a subsequence (SEQ) or substring (STR) and is a common subsequence of $A$ and $B$ (i.e., CLCS is equivalent to the SEQ-IC-LCS problem). The best solution for each of the problems is shown in Table 1.

In order to speed up the LCS computation, one direction of research that has received much attention is to apply compression, namely, run-length encoding (RLE) of strings. Bunke and Csirik [4] were one of the first to consider such a scenario, and proposed an $O(mN+nM)$ time algorithm. Here, $m,n$ are the sizes of the RLE of the input strings of lengths $M$ and $N$, respectively. Notice that since RLE can be computed in linear time, and $m\leq M$ and $n\leq N$, the algorithm is always asymptotically faster than the standard $O(NM)$ time dynamic programming algorithm, especially when the strings are compressible by RLE. Furthermore, Ahsan et al. proposed an algorithm which runs in $O((m+n)+R\log\log(mn)+R\log\log(M+N))$ time [1], where $R$ is the total number of pairs of runs of the same character in the two RLE strings, i.e. $R\in O(mn)$, and the algorithm can be much faster when the strings are compressible by RLE.

For the constrained LCS problems, RLE based solutions for only the SEQ-IC-LCS problem have been proposed. In 2012, an $O(K(mN+nM))$ time algorithm was proposed by Ann et al. [2]. Later, in 2015, Liu et al. proposed a faster $O(M+N+K\min\{mN,nM\})$ time algorithm [12].

In this paper, we present the first RLE based solution for the STR-IC-LCS problem that runs in $O(mN+nM)$ time. Again, since RLE can be computed in linear time, and $m\leq M$ and $n\leq N$, the proposed algorithm is always asymptotically faster than the best known solution for the STR-IC-LCS problem by Deorowicz [7], which runs in $O(MN)$ time.

A common criticism against RLE based solutions is a claim that, although they are theoretically interesting, since most strings “in the real world” are not compressible by RLE, their applicability is limited and they are only useful in extreme artificial cases. We believe that this is not entirely true. There can be cases where RLE is a natural encoding of the data, for example, in music, a melody can be expressed as a string of pitches and their duration. Furthermore, in the data mining community, there exist popular preprocessing schemes for analyzing various types of time series data, which convert the time series to strings over a fairly small alphabet as an approximation of the original data, after which various analyses are conducted (e.g. SAX (Symbolic Aggregate approXimation) [11], clipped bit representation [3], etc.). These conversions are likely to produce strings which are compressible by RLE (and in fact, shown to be effective in [3]), indicating that RLE based solutions may have a wider range of application than commonly perceived.

2 Preliminaries

Let $\Sigma$ be the finite set of characters, and $\Sigma^{\ast}$ be the set of strings. For any string $A$, let $|A|$ be the length of $A$. For any $1\leq i\leq i^{\prime}\leq|A|$, let $A[i]$ be the $i$th character of $A$ and let $A[i..i^{\prime}]=A[i]\cdots A[i^{\prime}]$ denote a substring of $A$. Especially, $A[1..i^{\prime}]$ denotes a prefix of $A$, and $A[i..|A|]$ denotes a suffix of $A$. A string $Z$ is a subsequence of $A$ if $Z$ can be obtained from $A$ by removing zero or more characters. For two string $A$ and $B$, a string $Z$ is a longest common subsequence (LCS) of $A,B$, if $Z$ is a longest string that is a subsequence of both $A$ and $B$. For any $1\leq i\leq|A|$ and $1\leq j\leq|B|$, let $L^{pref}(i,j)$ denote the length of an LCS of $A[1..i]$, $B[1..j]$, and let $L^{suf}(i,j)$ denote the length of an LCS of $A[i..|A|]$, $B[j..|B|]$. The LCS problem is to compute the length of an LCS of given two strings $A$ and $B$. A well known solution is dynamic programming, which computes in $O(MN)$ time, a table (which we will call DP table) of size $O(MN)$ that stores values of $L^{pref}(i,j)$ for all $1\leq i\leq M$, $1\leq j\leq N$. The DP table for $L^{suf}(i,j)$ can be computed similarly.

For two strings $A,B$ and a constraint string $C$, a string $Z$ is an STR-IC-LCS of $A,B,C$, if $Z$ is a longest string that includes $C$ as a substring and also is a subsequence of both $A$ and $B$. The STR-IC-LCS problem is to compute the length of an STR-IC-LCS of any given three strings $A$, $B$ and $C$. For example, if $A=\mathtt{abacab}$, $B=\mathtt{babcaba}$, $C=\mathtt{bb}$, then $\mathtt{abcab}$ and $\mathtt{bacab}$ are LCSs of $A,B$, and $\mathtt{abb}$ is an STR-IC-LCS of $A,B,C$.

The run-length encoding (RLE) of a string $A$ is a kind of compressed representation of $A$ where each maximal run of the same character is represented by a pair of the character and the length of the run. Let $\mathit{RLE}(A)$ denote the RLE of a string $A$. The size of $\mathit{RLE}(A)$ is the number of the runs in $A$, and is denoted by $|\mathit{RLE}(A)|$. By definition, $|\mathit{RLE}(A)|$ is always less than or equal to $|A|$.

In the next section, we consider the STR-IC-LCS problem of strings $A$, $B$ and constraint string $C$. Let $|A|=M$, $|B|=N$, $|C|=K$, $|\mathit{RLE}(A)|=m$ and $|\mathit{RLE}(B)|=n$. We assume that $K\leq\min(M,N)$ and $|\mathit{RLE}(C)|\leq\min(m,n)$, since in such case there can be no solution. We also assume that $K>0$, because in that case the problem becomes the normal LCS problem of $A,B$.

3 Algorithm

In this section, we will first introduce a slightly modified version of Deorowicz’s $O(MN)$-time algorithm for the STR-IC-LCS problem [7], and then propose our $O(mN+nM)$-time algorithm which is based on his dynamic programming approach but uses RLE.

3.1 Deorowicz’s $O(MN)$ Algorithm

We first define the notion of minimal $C$-intervals of a string.

Definition 1**.**

For any strings $A$ and $C$, an interval $[s,f]$ is a minimal $C$-interval of $A$ if

• •

$C$* is a subsequence of $A[s..f]$, and*

• •

$C$* is not a subsequence of $A[s+1..f]$ or $A[s..f-1]$.*

Deorowicz’s algorithm is based on Lemma 2, which is used implicitly in [7].

Lemma 2** (implicit in [7]).**

If $Z$ is an STR-IC-LCS of $A,B,C$, then there exist minimal $C$-intervals $[s,f],[s^{\prime},f^{\prime}]$ $(1\leq s\leq f\leq M$, $1\leq s^{\prime}\leq f^{\prime}\leq N)$ respectively of $A$ and $B$, such that $Z=XCY$, where $X$ is an LCS of $A[1..s-1]$ and $B[1..s^{\prime}-1]$ and $Y$ is an LCS of $A[f+1..M]$ and $B[f^{\prime}+1..N]$.

Proof.

From the definition of STR-IC-LCS, $C$ is a substring of $Z$, and therefore, there exist (possibly empty) strings $X,Y$ such that $Z=XCY$. Also, since $Z$ is a common subsequence of $A$ and $B$, there exist monotonically increasing sequences $i_{1},\ldots,i_{|Z|}$ and $j_{1},\ldots,j_{|Z|}$ such that $Z=A[i_{1}]\cdots A[i_{|Z|}]$ $=B[j_{1}]\cdots B[j_{|Z|}]$, and $C=A[i_{|X|+1}]\cdots A[i_{|X|+K}]$ $=B[j_{|X|+1}]\cdots B[j_{|X|+K}]$.

Now, since $C$ is a subsequence of $A[i_{|X|+1}..i_{|X|+K}]$ and $B[j_{|X|+1}..j_{|X|+K}]$ there exist minimal $C$-intervals $[s,f]$, $[s^{\prime},f^{\prime}]$ respectively of $A$ and $B$ that satisfy $i_{|X|+1}\leq s\leq f\leq i_{|X|+K}$ and $j_{|X|+1}\leq s^{\prime}\leq f^{\prime}\leq j_{|X|+K}$. Let $X^{\prime}$ be an LCS of $A[1..s-1]$ and $B[1..s^{\prime}-1]$, and $Y^{\prime}$ an LCS of $A[f+1..M]$ and $B[f^{\prime}+1..N]$. Since $X$ must be a common subsequence of $A[1..s-1]$ and $B[1..s^{\prime}-1]$, and $Y$ a common subsequence of $A[f+1..M]$ and $B[f^{\prime}+1..N]$, we have $|X^{\prime}|\geq|X|$ and $|Y^{\prime}|\geq|Y|$. However, we cannot have that $|X^{\prime}|>|X|$ or $|Y^{\prime}|>|Y|$ since otherwise, $X^{\prime}CY^{\prime}$ would be a string longer than $Z$ that contains $C$ as a substring, and is a common subsequence of $A,B$, contradicting that $Z$ is an STR-IC-LCS of $A,B,C$. Thus, $|X|=|X^{\prime}|$ and $|Y|=|Y^{\prime}|$ implying that $X$ is also an LCS of $A[1..s-1],B[1..s^{\prime}-1]$, and $Y$ is also an LCS of $A[f+1..M],B[f^{\prime}+1..N]$, proving the lemma. ∎

The algorithm consists of the following two steps, whose correctness follows from Lemma 2.

Step 1

Compute all minimal $C$-intervals of $A$ and $B$.

Step 2

For all pairs of a minimal $C$-interval $[s,f]$ of $A$ and a minimal $C$-interval $[s^{\prime},f^{\prime}]$ of $B$, compute the length of an LCS of the corresponding prefixes of $A$ and $B$ (i.e., $L^{pref}(s-1,s^{\prime}-1)$) and that of the corresponding suffixes of $A$ and $B$ (i.e., $L^{suf}(f+1,f^{\prime}+1)$). The largest sum of LCS lengths plus $|C|$ (i.e., $L^{pref}(s-1,s^{\prime}-1)+L^{suf}(f+1,f^{\prime}+1)+|C|$) is the length of an STR-IC-LCS.

The steps can be executed in the following running times. For Step 1, there are respectively at most $M$ and $N$ minimal $C$-intervals of $A$ and $B$, which can be enumerated in $O(MK)$ and $O(NK)$ time. For Step 2, we precompute, in $O(MN)$ time, two dynamic programming tables which respectively contain the values of $L^{pref}(i,j)$ and $L^{suf}(i,j)$ for each $1\leq i\leq M$ and $1\leq j\leq N$. Using these tables, the value $L^{pref}(s-1,s^{\prime}-1)+L^{suf}(f+1,f^{\prime}+1)+|C|$ can be computed in constant time for any $[s,f]$ and $[s^{\prime},f^{\prime}]$. There are $O(MN)$ possible pairs of minimal $C$-intervals, so Step 2 can be done in $O(MN)$ time. In total, since $K\leq M,K\leq N$, the STR-IC-LCS problem can be solved in $O(MN)$ time.

We note that in the original presentation of Deorowicz’s algorithm, right-minimal $C$-intervals, that is, intervals $[s,f]$ where $C$ is a subsequence of $A[s..f]$ but not of $A[s..f-1]$ are computed, instead of minimal $C$-intervals as defined in Definition 1. Although the number of considered intervals changes, this does not influence the asymptotic complexities in the non-RLE case. However, as we will see in Lemma 4 of Section 3.2, this is an essential difference for the RLE case, since, when $|\mathit{RLE}(C)|>1$, the number of minimal $C$-intervals of $A$ and $B$ can be bounded by $O(m)$ and $O(n)$, but the number of right-minimal $C$-intervals of $A$ and $B$ cannot, and are only bounded by $O(M)$ and $O(N)$.

3.2 Our Algorithm via RLE

In this subsection, we propose an efficient algorithm based on Deorowicz’s algorithm explained in Subsection 3.1, extended to strings expressed in RLE. There are two main cases to consider: when $|\mathit{RLE}(C)|=1$, i.e., when $C$ consists of only one type of character, and when $|\mathit{RLE}(C)|>1$, i.e., when $C$ contains at least two different characters.

3.2.1 Case $|\mathit{RLE}(C)|>1$

Theorem 3**.**

Let $A,B,C$ be any strings and let $|A|=M$, $|B|=N$, $|\mathit{RLE}(A)|=m$ and $|\mathit{RLE}(B)|=n$. If $|\mathit{RLE}(C)|>1$, we can compute the length of an STR-IC-LCS of $A,B,C$ in $O(mN+nM)$ time.

For Step 1, we execute the following procedure to enumerate all minimal $C$-intervals of $A$ and $B$. Let $s_{0}=0$. First, find the right minimal $C$-interval starting at $s_{0}+1$, i.e., the smallest position $f_{1}$ such that $C$ is a subsequence of $A[s_{0}+1..f_{1}]$. Next, starting from position $f_{1}$ of $A$, search backwards to find the left minimal $C$-interval ending at $f_{1}$, i.e., the largest position $s_{1}$ such that $C$ is a subsequence of $A[s_{1}..f_{1}]$. The process is then repeated, i.e., find the smallest position $f_{2}$ such that $C$ is a subsequence of $A[s_{1}+1..f_{2}]$, and then search backwards to find the largest position $s_{2}$ such that $C$ is a subsequence of $A[s_{2}..f_{2}]$, and so on. It is easy to see that the intervals $[s_{1},f_{1}],[s_{2},f_{2}],\ldots$ obtained by repeating this procedure until reaching the end of $A$ are all the minimal $C$-intervals of $A$, since each interval that is found is distinct, and there cannot exist another minimal $C$-interval between those found by the procedure. The same is done for $B$. For non-RLE strings, this takes $O((M+N)K)$ time. The Lemma below shows that the procedure can be implemented more efficiently using RLE.

Lemma 4**.**

Let $A$ and $C$ be strings where $|A|=M$, $|\mathit{RLE}(A)|=m$ and $|C|=K$. If $|\mathit{RLE}(C)|>1$, the number of minimal $C$-intervals of $A$ is $O(m)$ and can be enumerated in $O(M+mK)$ time.

Proof.

Because $|\mathit{RLE}(C)|>1$, it is easy to see from the backward search in the procedure described above, that for any minimal $C$-interval of $A$, there is a unique run of $A$ such that the last character of the first run of $C$ corresponds to the last character of that run. Therefore, the number of minimal $C$-intervals of $A$ is $O(m)$.

We can compute $\mathit{RLE}(A)=a_{1}^{M_{1}}\cdots a_{m}^{M_{m}}$ and $\mathit{RLE}(C)=c_{1}^{K_{1}}\cdots c_{k}^{K_{k}}$ in $O(M+K)$ time. What remains is to show that the forward/backward search procedure described above to compute all minimal $C$-intervals of $A$ can be implemented in $O(mK)$ time. The pseudo-code of the algorithm described is shown in Algorithm 1.

In the forward search, we scan $\mathit{RLE}(A)$ to find a right minimal $C$-interval by greedily matching the runs of $\mathit{RLE}(C)$ to $\mathit{RLE}(A)$. We maintain the character $c_{q}$ and exponent $\mathit{rest}$ of the first run $c_{q}^{\mathit{rest}}$ of $\mathit{RLE}(C^{\prime})$, where $C^{\prime}$ is the suffix of $C$ that is not yet matched. When comparing a run $a_{p}^{M_{p}}$ of $\mathit{RLE}(A)$ and $c_{q}^{\mathit{rest}}$, if the characters are different (i.e., $a_{p}\neq c_{q}$), we know that the entire run $a_{p}^{M_{p}}$ will not match and thus we can consider the next run of $A$. Suppose the characters are the same. Then, if $M_{p}<\mathit{rest}$, the entire run $a_{p}^{M_{p}}$ of $A$ is matched, and we can consider the next run $a_{p+1}^{M_{p+1}}$ of $A$. Also, $\mathit{rest}$ can be updated accordingly in constant time by simple arithmetic. Furthermore, since $c_{q}=a_{p}\neq a_{p+1}$, we can in fact skip to the next run $a_{p+2}^{M_{p+2}}$. If $M_{p}\geq\mathit{rest}$, the entire run $c_{q}^{\mathit{rest}}$ is matched, and we consider the next run $c_{q+1}^{K_{q+1}}$ in $C$. Also, since $a_{p}=c_{q}\neq c_{q+1}$, we can skip the rest of $a_{p}^{M_{p}}$ and consider the next run $a_{p+1}^{M_{p+1}}$ of $A$. Thus, we spend only constant time for each run of $A$ that is scanned in the forward search. The same holds for the backward search.

To finish the proof, we show that the total number of times that each run of $A$ is scanned in the procedure is bounded by $O(K)$, i.e., the number of minimal $C$-intervals of $A$ that intersects with a given run $a_{p}^{M_{p}}$ of $A$ is $O(K)$. Since $|\mathit{RLE}(C)|>1$, a minimal $C$-interval cannot be contained in $a_{p}^{M_{p}}$. Thus, for a minimal $C$-interval to intersect with the run $a_{p}^{M_{p}}$, it must cross either the left boundary of the run, or the right boundary of the run. For a minimal $C$-interval to cross the left boundary of the run, it must be that for some non-empty strings $u,v$ such that $C=uv$, $u$ occurs as a subsequence in $a_{1}^{M_{1}}\cdots a_{p-1}^{M_{p-1}}$ and $v$ occurs as a subsequence in $a_{p}^{M_{p}}\cdots a_{m}^{M_{m}}$. The minimal $C$-interval corresponds to the union of the left minimal $u$-interval ending at the left boundary of the run and the right minimal $v$-interval starting at the left boundary of the run and is thus unique for $u,v$. Similar arguments also hold for minimal $C$-intervals that cross the right boundary of $a_{p}^{M_{p}}$. Since there are only $K-1$ choices for $u,v$, the claim holds, thus proving the Lemma. ∎

In Deorowicz’s algorithm, two DP tables were computed for Step 2, which took $O(MN)$ time. For our algorithm, we use a compressed representation of the DP table for $A$ and $B$, proposed by Bunke and Csirik [4], instead of the normal DP table. We note that Bunke and Csirik actually solved the edit distance problem when the cost is $1$ for insertion and deletion, and $2$ for substitution, but this easily translates to LCS: $L^{pref}(i,j)=(i+j-\mathit{ED}^{pref}(i,j))/2$, where $\mathit{ED}^{pref}(i,j)$ denotes the edit distance with such costs, between $A[1..i]$ and $B[1..j]$.

Definition 5** ([4]).**

Let $A$, $B$ be strings of length $M$, $N$ respectively, where $\mathit{RLE}(A)=a_{1}^{M_{1}}\cdots a_{m}^{M_{m}}$ and $\mathit{RLE}(B)=b_{1}^{N_{1}}\cdots b_{n}^{N_{n}}$. The compressed DP table (cDP table) of $A,B$ is an $O(mN+nM)$-space compressed representation of the DP table of $A,B$ which holds only the values of the DP table for $(M_{1..p},j)$ and $(i,N_{1..q})$, where, $1\leq i\leq M$, $1\leq j\leq N$, $1\leq p\leq m$, $1\leq q\leq n$, $M_{1..p}=M_{1}+\cdots+M_{p}$, $N_{1..q}=N_{1}+\cdots+N_{q}$.

Figure 1 illustrates the values stored in the cDP table for strings $A=\mathtt{bbbaaaa}$, $B=\mathtt{aaaabbbaa}$. Note that although the figure depicts a sparsely filled table of size $M\times N$, the values are actually stored in two (completely filled) tables: one of size $m\times N$, holding the values of $(M_{1..p},j)$, and another of size $M\times n$, holding the values of $(i,N_{1..q})$, for a total of $O(mN+nM)$ space. Below are results adapted from [4] we will use.

Lemma 6** ([4, Theorem 7]).**

Let $A$ and $B$ be any strings where $|A|=M$, $|B|=N$, $|\mathit{RLE}(A)|=m$ and $|\mathit{RLE}(B)|=n$. The compressed DP table of $A$ and $B$ can be computed in $O(mN+nM)$ time and space.

Lemma 7** ([4, Lemma 3]).**

Let $\alpha\in\Sigma$ and let $A$ and $B$ be any strings where $|A|=M$ and $|B|=N$. For any integer $d\geq 1$, if $A[M-d+1..M]=B[N-d+1..N]=\alpha^{d}$, then $L^{pref}(M,N)=L^{pref}(M-d,N-d)+d$.

Lemma 8** ([4, Lemma 5]).**

Let $\alpha,\beta\in\Sigma$, $\alpha\neq\beta$ and let $A$ and $B$ be any strings where $|A|=M$ and $|B|=N$. For any integers $d\geq 1$ and $d^{\prime}\geq 1$, if $A[M-d+1..M]=\alpha^{d}$ and $B[N-d^{\prime}+1..N]=\beta^{d^{\prime}}$ then $L^{pref}(M,N)=\max\{L^{pref}(M-d,N),L^{pref}(M,N-d^{\prime})\}$.

From Lemmas 7 and 8, we easily obtain the following Lemma 9.

Lemma 9**.**

Let $A$ and $B$ be any strings. Any entry of the DP table of $A$ and $B$ can be retrieved in $O(1)$ time by using the compressed DP table of $A$ and $B$.

From Lemma 6, we can compute in $O(mN+nM)$ time, two cDP tables of $A,B$ which respectively hold the values of $L^{pref}(M_{1..p},j)$, $L^{pref}(i,N_{1..q})$ and $L^{suf}(M_{1..p},j)$, $L^{suf}(i,N_{1..q})$, each of them taking $O(mN+nM)$ space. From Lemma 9, we can obtain $L^{pref}(i,j)$, $L^{suf}(i,j)$ for any $i$ and $j$ in $O(1)$ time. Actually, to make Lemma 9 work, we also need to be able to convert the indexes between DP and cDP in constant time, i.e., for any $1\leq p\leq m$, $1\leq q\leq n$, the values $M_{1..p}$ and $N_{1..q}$, and for any $1\leq i\leq M$, $1\leq j\leq N$, the largest $p,q$ such that $M_{1..p}\leq i$, $N_{1..q}\leq j$. This is easy to do by preparing some arrays in $O(M+N)$ time and space.

Now we are ready to show the running time of our algorithm for the case $|\mathit{RLE}(C)|>1$. We can compute $\mathit{RLE}(A)$,$\mathit{RLE}(B)$,$\mathit{RLE}(C)$ from $A,B,C$ in $O(M+N+K)$ time. In Step 1, we have from Lemma 4, that the number of all minimal $C$-intervals of $A,B$ are respectively $O(m)$ and $O(n)$, and can be computed in $O(M+N+mK+nK)$ time. For the preprocessing of Step 2, we build the cDP tables holding the values of $L^{pref}(i,j)$, $L^{suf}(i,j)$ for $1\leq i\leq M$, $1\leq j\leq N$, which can be computed in $O(mN+nM)$ time and space from Lemma 6. With these tables, we can obtain for any $i,j$, the values $L^{pref}(i,j)$, $L^{suf}(i,j)$ in constant time from Lemma 9. Since there are $O(mn)$ pairs of a minimal $C$-interval of $A$ and a minimal $C$-interval of $B$, the total time for Step 2, i.e. computing $L^{pref}$ and $L^{suf}$ for each of the pairs, is $O(mn)$. Since $n\leq N,m\leq M$, and we can assume that $K\leq M,N$, the total time is $O(mN+nM)$. Thus Theorem 3 holds.

3.2.2 Case $|\mathit{RLE}(C)|=1$

Next, we consider the case where $|\mathit{RLE}(C)|=1$, and $C$ consists of only one run.

Theorem 10**.**

Let $A,B,C$ be any strings and let $|A|=M$, $|B|=N$, $|\mathit{RLE}(A)|=m$ and $|\mathit{RLE}(B)|=n$. If $|\mathit{RLE}(C)|=1$, we can compute the length of an STR-IC-LCS of $A,B,C$ in $O(mN+nM)$ time.

For Step 1, we compute all minimal $C$-intervals of $A$ and $B$ by Lemma 11. Note the difference from Lemma 4 in the case of $|\mathit{RLE}(C)|>1$.

Lemma 11**.**

If $|\mathit{RLE}(C)|=1$, the number of minimal $C$-intervals of $A$ and $B$ are $O(M)$ and $O(N)$, respectively, and these can be enumerated in $O(M)$ and $O(N)$ time, respectively.

Proof.

Let $\alpha\in\Sigma$, $C=\alpha^{K}$, and let $M_{\alpha}$ be the number of times that $\alpha$ occurs in $A$. Then the number of minimal $C$-intervals of $A$ is $M_{\alpha}-K+1\in O(M)$. The minimal $C$-intervals can be enumerated in $O(M)$ time by checking all positions of $\alpha$ in $A$. The same applies to $B$. ∎

From Lemma 11, we can see that the number of pairs of minimal $C$-intervals of $A$ and $B$ can be $\Theta(MN)$, and we cannot afford to consider all of those pairs for Step 2. We overcome this problem as follows. Let $U=\{[s_{1},f_{1}],\ldots,[s_{l},f_{l}]\}$ be the set of all minimal $C$-intervals of $A$. Consider the partition $G(1),\ldots,G(g)$ of $U$ which are the equivalence classes induced by the following equivalence relation on $U$: For any $1\leq p\leq q\leq m$ and $[s_{x},f_{x}],[s_{y},f_{y}]\in U$,

[TABLE]

where, $M_{1..0}=0$. In other words, $[s_{x},f_{x}]$ and $[s_{y},f_{y}]$ are in the same equivalence class if they start in the same run, and end in the same run. Noticing that minimal $C$-intervals cannot be completely contained in another, we can assume that for $1\leq h<h^{\prime}\leq g$, $[s_{x},f_{x}]\in G(h)$ and $[s_{y},f_{y}]\in G(h^{\prime})$, we have $s_{x}<s_{y}$ and $f_{x}<f_{y}$.

Lemma 12**.**

Let $G(1),\ldots,G(g)$ be the partition of the set $U$ of all minimal $C$-intervals of $A$ induced by the equivalence relation (1). Then, $g\in O(m)$.

Proof.

Let $1\leq x<y\leq l$ and $2\leq h\leq g$. For any $[s_{x},f_{x}]\in G(h-1)$ and $[s_{y},f_{y}]\in G(h)$, let $1\leq p\leq q\leq m$ satisfy $M_{1..p-1}<s_{x}\leq M_{1..p}$, $M_{1..q-1}<f_{x}\leq M_{1..q}$. Since the intervals are not equivalent, either $M_{1..p}<s_{y}$ or $M_{1..q}<f_{y}$ must hold. Thus, $g\in O(m)$. ∎

Equivalently for $B$, we consider the set $U^{\prime}=\{[s^{\prime}_{1},f^{\prime}_{1}],\ldots,[s^{\prime}_{l^{\prime}},f^{\prime}_{l^{\prime}}]\}$ of all minimal $C$-intervals of $B$, and the partition $G^{\prime}(1),\ldots,G^{\prime}(g^{\prime})$ of $U^{\prime}$ based on the analogous equivalence relation, where $g^{\prime}\in O(n)$.

For some $h$, let $[s_{x},f_{x}]$, $[s_{y},f_{y}]$ be the minimal $C$-intervals in $G(h)$ with the smallest and largest start positions. Since by definition, $A[s_{x}]=\cdots=A[s_{y}]=A[f_{x}]=\cdots=A[f_{y}]$, we have $G(h)=\{[s_{x}+i,f_{x}+i],[s_{x}+1,f_{x}+1],\ldots,[s_{y},f_{y}]\}$. The same can be said for $G^{\prime}(h^{\prime})$ of $B$. From this observation, we can show the following Lemma 13.

Lemma 13**.**

For any $1\leq h\leq g$ and $1\leq h^{\prime}\leq g^{\prime}$, let $[s,f]$, $[s+d,f+d]\in G(h)$ and $[s^{\prime},f^{\prime}]$, $[s^{\prime}+d,f^{\prime}+d]\in G^{\prime}(h^{\prime})$, for some positive integer $d$. Then,

[TABLE]

Proof.

Since $A[s..s+d]=A[f..f+d]=B[s^{\prime}..s^{\prime}+d]=B[f^{\prime}..f^{\prime}+d]=C[1]^{d}$, we have from Lemma 7, $L^{pref}(s+d-1,s^{\prime}+d-1)=L^{pref}(s-1,s^{\prime}-1)+d$, and $L^{suf}(f+1,f^{\prime}+1)=L^{suf}(f+d+1,f^{\prime}+d+1)+d$. ∎

From Lemma 13, we can see that for any $G(h),G^{\prime}(h^{\prime})$ $(1\leq h\leq g$, $1\leq h^{\prime}\leq g^{\prime})$, we do not need to compute $L^{pref}(s-1,s^{\prime}-1)+L^{suf}(f+1,f^{\prime}+1)$ for all pairs of $[s,f]\in G(h)$ and $[s^{\prime},f^{\prime}]\in G^{\prime}(h^{\prime})$. Let $G_{\min}(h)$ and $G_{\min}^{\prime}(h^{\prime})$ be the minimal $C$-intervals respectively in $G(h)$ and $G^{\prime}(h^{\prime})$ with the smallest starting position. Then, we only need to consider the combination of $G_{\min}(h)$ with each of $[s^{\prime},f^{\prime}]\in G^{\prime}(h^{\prime})$, and the combination of each of $[s,f]\in G(h)$ with $G_{\min}^{\prime}(h^{\prime})$. Therefore, of all combinations of minimal $C$-intervals in $U$ and $U^{\prime}$, we only need to consider for all $1\leq h\leq g$ and $1\leq h^{\prime}\leq g^{\prime}$, the combination of $G_{\min}(h)$ with each of $U^{\prime}$, and each of $U$ with $G_{\min}^{\prime}(h^{\prime})$. The number of such combinations is clearly $O(mN+nM)$.

For example, consider $\mathit{RLE}(A)=\mathtt{a}^{5}\mathtt{b}^{3}\mathtt{a}^{4}\mathtt{b}^{2}\mathtt{a}^{1}$, $\mathit{RLE}(B)=\mathtt{a}^{1}\mathtt{b}^{3}\mathtt{a}^{7}\mathtt{b}^{3}$, $\mathit{RLE}(C)=\mathtt{a}^{5}$. For the minimal $C$-intervals of $A$, we have $G(1)=\{[1,5]\}$, $G(2)=\{[2,9],[3,10],[4,11],[5,12]\}$, $G(3)=\{[9,15]\}$. For the minimal $C$-intervals of $B$, we have $G^{\prime}(1)=\{[1,8]\}$, $G^{\prime}(2)=\{[5,9],[6,10],[7,11]\}$. Also, $G_{\min}(2)=[2,9]$, $G_{\min}^{\prime}(2)=[5,9]$. Figure 2 shows the lengths of the LCS of prefixes and suffixes for each combination between minimal $C$-intervals in $G(2)$ and $G^{\prime}(2)$. The gray part is the values that are referred to. The values denoted inside parentheses are not stored in the cDP table, but each of them can be computed in $O(1)$ time from Lemma 9. Figure 3 shows the sum of the LCS of prefixes and suffixes corresponding to the gray part. Due to Lemma 13, the values along the diagonal are equal. Thus, for the combinations of minimal $C$-intervals in $G(2)$, $G^{\prime}(2)$, we only need to consider the six combinations: $([2,9],[5,9])$,$([2,9],[6,10])$,$([2,9],[7,11])$,$([3,10],[5,9])$,$([4,11],[5,9])$,$([5,12],[5,9])$.

Now, we are ready to show the running time of our algorithm for the case $|\mathit{RLE}(C)|=1$. We can compute $\mathit{RLE}(A)$, $\mathit{RLE}(B)$, $\mathit{RLE}(C)$ from $A,B,C$ in $O(M+N+K)$ time. There are respectively $O(M)$ and $O(N)$ minimal $C$-intervals of $A$ and $B$, and each of them can be assigned to one of the $O(m)$ and $O(n)$ equivalence classes $G,G^{\prime}$, in total of $O(M+N)$ time. The preprocessing for the cDP table is the same as for the case of $|\mathit{RLE}(C)|>1$, which can be done in $O(mN+nM)$ time. By Lemma 13, we can reduce the number of combinations of minimal $C$-intervals to consider to $O(mN+nM)$. Finally, from Lemma 9, the LCS lengths for each combination can be computed in $O(1)$ using the cDP table. Therefore, the total running time is $O(mN+nM)$, proving Theorem 10.

From Theorems 3 and 10, the following Theorem 14 holds. The pseudo-code for our proposed algorithm is shown in Algorithm 2 (written in Appendix).

Theorem 14**.**

Let $A,B,C$ be any strings and let $|A|=M$, $|B|=N$, $|\mathit{RLE}(A)|=m$ and $|\mathit{RLE}(B)|=n$. We can compute the length of an STR-IC-LCS of $A,B,C$ in $O(mN+nM)$ time.

Although we only showed how to compute the length of an STR-IC-LCS, we note that the algorithm can be modified so as to obtain a RLE of an STR-IC-LCS in $O(m+n)$ time, provided that $\mathit{RLE}(C)$ is precomputed, simply by storing the minimal $C$-intervals $[s,f]$, $[s^{\prime},f^{\prime}]$, respectively of $A$ and $B$, that maximizes $L^{pref}(s-1,s^{\prime}-1)+L^{suf}(f+1,f^{\prime}+1)+|C|$. From Lemmas 7 and 8, we can simulate a standard back-tracking of the DP table for obtaining LCSs with the cDP table to obtain RLE of the LCSs in $O(m+n)$ time. Finally an RLE of STR-IC-LCS can be obtained by combining the three RLE strings (the two LCSs with $\mathit{RLE}(C)$ in the middle), appropriately merging the boundary runs if necessary.

4 Conclusion

In this work, we proposed a new algorithm to solve the STR-IC-LCS problem using RLE representation. We can compute the length of an STR-IC-LCS of strings $A,B,C$ in $O(mN+nM)$ time and space using this algorithm, where $|A|=M$, $|B|=N$, $|RLE(A)|=m$ and $|RLE(B)|=n$. This result is better than Deorowicz’s $O(MN)$ time and space [7], which doesn’t use RLE. If we want to know not only the length but also an STR-IC-LCS of $A,B,C$, we can retrieve it in $O(m+n)$ time.

Appendix A Appendix

Here, we show the pseudo-code for our proposed algorithm.