Compressed Suffix Arrays and Suffix Trees with Applications to Text Indexing and String Matching Read More: http://epubs.siam.org/doi/abs/10.1137/S0097539702402354

The proliferation of online text, such as found on the World Wide Web and in online databases, motivates the need for space-efficient text indexing methods that support fast string searching. We model this scenario as follows: Consider a text T consisting of n symbols drawn from a fixed alphabet. The text T can be represented in n || bits by encoding each symbol with || bits. The goal is to support fast online queries for searching any string pattern P of m symbols, with T being fully scanned only once, namely, when the index is created at preprocessing time. The text indexing schemes published in the literature are greedy in terms of space usage: they require (n n) additional bits of space in the worst case. For example, in the standard unit cost RAM, suffix trees and suffix arrays need (n) memory words, each of (n) bits. These indexes are larger than the text itself by a multiplicative factor of (|| ₍), which is significant when is of constant size, such as in ascii or unicode. On the other hand, these indexes support fast searching, either in O (m ||) time or in O (m + n) time, plus an output-sensitive cost O (occ) for listing the occ pattern occurrences. We present a new text index that is based upon compressed representations of suffix arrays and suffix trees. It achieves a fast O (m /|| ₍ + _||^ n) search time in the worst case, for any constant 0 < 1, using at most (^-1 + O (1) ) \, n || bits of storage. Our result thus presents for the first time an efficient index whose size is provably linear in the size of the text in the worst case, and for many scenarios, the space is actually sublinear in practice. As a concrete example, the compressed suffix array for a typical 100 MB ascii file can require 30--40 MB or less, while the raw suffix array requires 500 MB. Our theoretical bounds improve both time and space of previous indexing schemes. Listing the pattern occurrences introduces a sublogarithmic slowdown factor in the output-sensitive cost, giving O (occ \, ||^ ₍) time as a result. When the patterns are sufficiently long, we can use auxiliary data structures in O (n ||) bits to obtain a total search bound of O (m /|| n + occ) time, which is optimal.