Sparse Suffix Tree Construction in Optimal Time and Space

Abstract

Suffix tree (and the closely related suffix array) are fundamental structures capturing all substrings of a given text essentially by storing all its suffixes in the lexicographical order. In some applications, such as sparse text indexing, we work with a subset of b interesting suffixes, which are stored in the so-called sparse suffix tree. Because the size of this structure is Θ(b), it is natural to seek a construction algorithm using only O(b) words of space assuming read-only random access to the text. We design a linear-time Monte Carlo algorithm for this problem, hence resolving an open question explicitly stated by Bille et al. [TALG 2016]. The best previously known algorithm by I et al. [STACS 2014] works in O(n log b) time. As opposed to previous solutions, which were based on the divide-and-conquer paradigm, our solution proceeds in n/b rounds. In the r-th round, we consider all suffixes starting at positions congruent to r modulo n/b. By maintaining rolling hashes, we can lexicographically sort all interesting suffixes starting at such positions, and then we can merge them with the already considered suffixes. For efficient merging, we also need to answer LCE queries efficiently (and in small space). By plugging in the structure of Bille et al. [CPM 2015] we obtain O(n + b log b) time complexity. We improve this structure by a recursive application of the so-called difference covers, which then implies a linear-time sparse suffix tree construction algorithm.We complement our Monte Carlo algorithm with a deterministic verification procedure. The verification takes O(n √ log b) time, which improves upon the bound of O(n log b) obtained by I et al. [STACS 2014]. This is obtained by first observing that the pruning done inside the previous solution has a rather clean description using the notion of graph spanners with small multiplicative stretch. Then, we are able to decrease the verification time by applying difference covers twice. Combined with the Monte Carlo algorithm, this gives us an O(n √ log b)-time and O(b)-space Las Vegas algorithm.

Locally Consistent Parsing for Text Indexing in Small Space

“…Sparse Suffix Tree Construction. For the SST construction problem we introduce an optimal randomized Las-Vegas algorithm, which improves upon the previous algorithm of Gawrychowski and Kociumaka [19] which developed an optimal Monte-Carlo algorithm and a Las-Vegas algorithm with additional log |B| factor. In addition, we introduce the first almost-linear deterministic SST construction algorithm.…”

“…However, we design a new way to combine Karp-Rabin fingerprints together with approximately min-wise hash functions, in order to use this method using only small amount of space. In previous results for the LCE problem [3,4,19,37], a set of positions of size O( n τ ) was also considered by the data structures. In contrast to these algorithms, where the selected positions were dependent only on the length of the text, we introduce the first algorithm that exploit the actual text using local properties in order to decide which positions to select.…”

“…In order to compute this length, we create a new string S ′ by converting each block into a unique letter. To detect repeated occurrences of the same block, and give them the same letter, we sort the blocks in linear time using a technique of [19]. The result string is of length O( n τ ) and this is also the alphabet size, so we build a suffix tree of this string in O( n τ ) time and space.…”

“…We consider the trade-off version, where there is a parameter 1 ≤ τ ≤ n and the goal is to construct a data structure using only O( n τ ) words of space, while achieving fast construction and query time. The trade-off LCE problem is closely tied to the SST problem, and in several papers the LCE was used as the main tool for constructing the SST efficiently [19,3].…”

“…Tanimura et al [37] introduced a deterministic data structure with O(nτ ) construction time algorithm, and with a slightly increasing of the query time to O(τ min{log τ, log n τ }). Gawrychowski et al [19] have shown a linear time Monte-Carlo construction of an LCE data structure with O(τ ) query time. In a close model of encoding data structures, Tanimura et al [38] introduce a data structure that encode the string, and then can delete the original string.…”