# Online Algorithms for Constructing Linear-size Suffix Trie

## TL;DR

This paper introduces two efficient online algorithms for constructing linear-size suffix tries directly from text, eliminating the need to store the entire input or build suffix trees first.

## Contribution

The authors present novel online algorithms for directly constructing linear-size suffix tries from either end of the input string, improving efficiency and storage requirements.

## Key findings

- Both algorithms run in linear or near-linear time.
- They do not require storing the entire input text.
- Construct the suffix trie incrementally without suffix tree intermediates.

## Abstract

The suffix trees are fundamental data structures for various kinds of string processing. The suffix tree of a string $T$ of length $n$ has $O(n)$ nodes and edges, and the string label of each edge is encoded by a pair of positions in $T$. Thus, even after the tree is built, the input text $T$ needs to be kept stored and random access to $T$ is still needed. The linear-size suffix tries (LSTs), proposed by Crochemore et al. [Linear-size suffix tries, TCS 638:171-178, 2016], are a `stand-alone' alternative to the suffix trees. Namely, the LST of a string $T$ of length $n$ occupies $O(n)$ total space, and supports pattern matching and other tasks in the same efficiency as the suffix tree without the need to store the input text $T$. Crochemore et al. proposed an offline algorithm which transforms the suffix tree of $T$ into the LST of $T$ in $O(n \log \sigma)$ time and $O(n)$ space, where $\sigma$ is the alphabet size. In this paper, we present two types of online algorithms which `directly' construct the LST, from right to left, and from left to right, without constructing the suffix tree as an intermediate structure. Both algorithms construct the LST incrementally when a new symbol is read, and do not access to the previously read symbols. The right-to-left construction algorithm works in $O(n \log \sigma)$ time and $O(n)$ space and the left-to-right construction algorithm works in $O(n (\log \sigma + \log n / \log \log n))$ time and $O(n)$ space. The main feature of our algorithms is that the input text does not need to be stored.