Computing DAWGs and Minimal Absent Words in Linear Time for Integer Alphabets

“…Let us recall that a non-empty string R that does not occur in a string S is called absent from S, and it is called minimal absent if furthermore all proper substrings of R do occur at least once in S. Minimal absent words (MAWs) are used in many applications [Silva et al 2015;Pratas and Silva 2020;Fici et al 2006;Garcia et al 2011;Chairungsee and Crochemore 2012;Ota and Morita 2010;Crochemore et al 2000] and their theory is well developed [Mignosi et al 2002;Fici and Gawrychowski 2019;, also from an algorithmic and data structure point of view [Ayad et al 2019;Barton et al 2014Barton et al , 2015Charalampopoulos et al 2018a, b;Crochemore et al 1998Crochemore et al , 2020Fujishige et al 2016;Mieno et al 2020]. For example, it is well known that, given two strings S and S , one has S = S if and only if S and S have the same set of MAWs [Mignosi et al 2002].…”

Section: A Z-rsds For Decision Queriesmentioning

confidence: 99%

Reverse-Safe Text Indexing

Bernardini

Chen

Fici

et al. 2021

ACM J. Exp. Algorithmics

View full text Add to dashboard Cite

We introduce the notion of reverse-safe data structures. These are data structures that prevent the reconstruction of the data they encode (i.e., they cannot be easily reversed). A data structure D is called z - reverse-safe when there exist at least z datasets with the same set of answers as the ones stored by D . The main challenge is to ensure that D stores as many answers to useful queries as possible, is constructed efficiently, and has size close to the size of the original dataset it encodes. Given a text of length n and an integer z , we propose an algorithm that constructs a z -reverse-safe data structure ( z -RSDS) that has size O(n) and answers decision and counting pattern matching queries of length at most d optimally, where d is maximal for any such z -RSDS. The construction algorithm takes O(nɷ log d) time, where ɷ is the matrix multiplication exponent. We show that, despite the nɷ factor, our engineered implementation takes only a few minutes to finish for million-letter texts. We also show that plugging our method in data analysis applications gives insignificant or no data utility loss. Furthermore, we show how our technique can be extended to support applications under realistic adversary models. Finally, we show a z -RSDS for decision pattern matching queries, whose size can be sublinear in n . A preliminary version of this article appeared in ALENEX 2020.

show abstract

“…By suitably modifying suffix tries, we can obtain linear O(n)-size string data structures such as suffix trees [29], suffix arrays [25], directed acyclic word graphs (DAWGs) [4], compact DAWGs (CDAWGs) [5], position heaps [10], and so on. In the case of the integer alphabet of size polynomial in n, all these data structures can be constructed in O(n) time and space in an offline manner [8,9,11,13,19,22,26]. In the case of a general ordered alphabet of size σ, there are left-to-right online construction algorithms for suffix trees [28], DAWGs [4], CDAWGs [21], and position heaps [23].…”

Section: Introductionmentioning

confidence: 99%

Linear Time Online Algorithms for Constructing Linear-size Suffix Trie

Hendrian¹,

Takagi²,

Inenaga³

et al. 2023

Preprint

View full text Add to dashboard Cite

The suffix trees are fundamental data structures for various kinds of string processing. The suffix tree of a text 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 string 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 an input text string T of length n occupies O(n) total space, and supports pattern matching and other tasks with the same efficiency as the suffix tree without the need to store the input text string T . Crochemore et al. proposed an offline algorithm which transforms the suffix tree of T into the LST of T in O(n log σ) time and O(n) space, where σ 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 the previously read symbols. Both of the right-to-left construction algorithm and the left-to-right construction algorithm work in O(n log σ) time and O(n) space. The main feature of our algorithms is that the input text string does not need to be stored.

show abstract

Computing DAWGs and Minimal Absent Words in Linear Time for Integer Alphabets

Cited by 11 publications

References 0 publications

Linear-time computation of DAWGs, symmetric indexing structures, and MAWs for integer alphabets

Linear-time computation of DAWGs, symmetric indexing structures, and MAWs for integer alphabets

Reverse-Safe Text Indexing

Linear Time Online Algorithms for Constructing Linear-size Suffix Trie

Contact Info

Product

Resources

About