Full-Fledged Real-Time Indexing for Constant Size Alphabets

Kucherov, Grégory; Nekrich, Yakov

doi:10.1007/s00453-016-0199-7

Cited by 1 publication

(2 citation statements)

References 18 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Another closely related problem is the online string indexing problem [1,2,3,4,10,15,16,17]. Here the goal is to process S one character at a time (in either left-to-right or right-to-left order), while incrementally building an index on the string read so far.…”

Section: Introductionmentioning

confidence: 99%

“…Here the goal is to process S one character at a time (in either left-to-right or right-to-left order), while incrementally building an index on the string read so far. The best of these solutions achieve either constant time per character for constant-sized alphabets [17] or O(log log n + log log |Σ|) time for general alphabets [15] for building the index. These solutions all heavily rely on processing the string in rightto-left order to avoid the inherent linear time suffix tree updates due to appending, as mentioned above.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Sliding Window String Indexing in Streams

Bille¹,

Fischer²,

Gørtz³

et al. 2023

Preprint

View full text Add to dashboard Cite

Given a string S over an alphabet Σ, the string indexing problem is to preprocess S to subsequently support efficient pattern matching queries, that is, given a pattern string P report all the occurrences of P in S. In this paper we study the streaming sliding window string indexing problem. Here the string S arrives as a stream, one character at a time, and the goal is to maintain an index of the last w characters, called the window, for a specified parameter w. At any point in time a pattern matching query for a pattern P may arrive, also streamed one character at a time, and all occurrences of P within the current window must be returned. The streaming sliding window string indexing problem naturally captures scenarios where we want to index the most recent data (i.e. the window) of a stream while supporting efficient pattern matching.Our main result is a simple O(w) space data structure that uses O(log w) time with high probability to process each character from both the input string S and the pattern string P . Reporting each occurrence from P uses additional constant time per reported occurrence. Compared to previous work in similar scenarios this result is the first to achieve an efficient worst-case time per character from the input stream with high probability. We also consider a delayed variant of the problem, where a query may be answered at any point within the next δ characters that arrive from either stream. We present an O(w + δ) space data structure for this problem that improves the above time bounds to O(log(w/δ)). In particular, for a delay of δ = w we obtain an O(w) space data structure with constant time processing per character. The key idea to achieve our result is a novel and simple hierarchical structure of suffix trees of independent interest, inspired by the classic log-structured merge trees.

show abstract