Balancing Run-Length Straight-Line Programs

Abstract

It was recently proved that any SLP generating a given string w can be transformed in linear time into an equivalent balanced SLP of the same asymptotic size. We show that this result also holds for RLSLPs, which are SLPs extended with run-length rules of the form $A \rightarrow B^t$ for $t>2$, deriving $\texttt {exp}(A) = \texttt {exp}(B)^t$. An immediate consequence is the simplification of the algorithm for extracting substrings of an RLSLP-compressed string. We also show that several problems like answering RMQs and computing Karp-Rabin fingerprints on substrings can be solved in $\mathcal {O}(g_{rl})$ space and $\mathcal {O}(\log n)$ time, $g_{rl}$ being the size of the smallest RLSLP generating the string, of length n. We extend the result to solving more general operations on string ranges, in $\mathcal {O}(g_{rl})$ space and $\mathcal {O}(\log n)$ applications of the operation. In general, the smallest RLSLP can be asymptotically smaller than the smallest SLP by up to an $\mathcal {O}(\log n)$ factor, so our results can make a difference in terms of the space needed for computing these operations efficiently for some string families.

Funded in part by Basal Funds FB0001, Fondecyt Grant 1-200038, and two Conicyt Doctoral Scholarships, ANID, Chile.

A PSV and NSV Queries

Other relevant queries are previous smaller value (PSV) and next smaller value (NSV) [6, 9], defined as follows:

• $\texttt {psv}(i)= \texttt {max}(\{j \,|\, j< i, w[j] < w[i]\}\cup \{0\})$

• $\texttt {nsv}(i) = \texttt {min}(\{j \,|\, j > i, w[j] < w[i]\}\cup \{n+1\})$

• $\texttt {psv}'(i, d)= \texttt {max}(\{j \,|\, j< i, w[j] < d\}\cup \{0\})$

• $\texttt {nsv}'(i, d) = \texttt {min}(\{j \,|\, j > i, w[j] < d\}\cup \{n+1\})$

Note that the first two queries can be computed by accessing w[i] in $\mathcal {O}(\log n)$ time, and then calling one of the latter two queries, respectively. We show that the latter queries can be answered in $\mathcal {O}(g_{rl})$ space and $\mathcal {O}(\log n)$ time.

Theorem 5

It is possible to construct an index of size $\mathcal {O}(g_{rl})$ supporting PSV and NSV queries in $\mathcal {O}(\log n)$ time.

Proof

Let G be a balanced RLSLP of size $\mathcal {O}(g_{rl})$ constructed as in Theorem 1. Store the values $L[A] = |\texttt {exp}(A)|$ and $M[A] = \texttt {min}(\{\texttt {exp}(A)[i]\,|\, i \in [1.. L[A]]\})$, for every variable A, as arrays. These arrays add only $\mathcal {O}(g_{rl})$ extra space. To compute $\texttt {psv}'(A, i, d)$, do as follows:

• 1. If $i=1$ or $M[A] \ge d$, return 0.

• 2. If $A \rightarrow a$, return 1.

• 3. If $A \rightarrow BC$, then:

  • (a) If $i \le L[B]+1$, return $\texttt {psv}'(B, i, d)$.

  • (b) If $L[B]+1 < i$, let $k = \texttt {psv}'(C, i - L[B], d)$. If $k > 0$, return $L[B] + k$, otherwise, return $\texttt {psv}'(B, i, d)$.

• 4. If $A \rightarrow B^t$ for $t > 2$, then:

  • (a) If $i \le L[B]+1$, return $\texttt {psv}'(B, i, d)$.

  • (b) If $i \in [t'L[B] +1..(t'+1)L[B]]$, let $k = \texttt {psv}'(B, i - t'L[B], d)$. If $k > 0$, return $t'L[B] + k$. Otherwise, return $(t'-1)L[B] + \texttt {psv}'(B,i,d)$.

  • (c) If $L[A]<i$, return $(t-1)L[B]+\texttt {psv}'(B,i,d)$.

The guard in point 1 guarantees that, in the simple case where i is beyond $|\texttt {exp}(A)|$, at most one recursive call needs more than $\mathcal {O}(1)$ time. In general, we can make two calls in case 3(b), but then the second call (inside B) is of the simple type from there on. The case of run-length rules is similar. Thus, we obtain $\mathcal {O}(\log n)$ time. The query $\texttt {nsv}'$ is handled similarly.    $\square$