Balancing Run-Length Straight-Line Programs*

TL;DR

This paper proves that balanced run-length straight-line programs (RLSLPs) can be constructed efficiently, enabling faster substring extraction and query operations like RMQ and fingerprinting with space proportional to the smallest RLSLP size.

Contribution

It extends the linear-time balancing result from SLPs to RLSLPs, simplifying algorithms and reducing space for substring queries and operations.

Findings

Balanced RLSLPs can be constructed in linear time.

Substring extraction from RLSLPs is simplified.

RMQ and fingerprinting can be performed in logarithmic time using minimal RLSLPs.

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.