Faster String Matching with Super-Alphabets

Abstract

Given a text T [1... n] and a pattern P [1... m] over some alphabet Σ of size σ, finding the exact occurrences of P in T requires at least Ω (n log_σ m/m character comparisons on average, as shown in [19]. Consequently, it is believed that this lower bound implies also an Ω (n log_σ m/m lower bound for the execution time of an optimal algorithm. However, in this paper we show how to obtain an $\mathcal{O}(n/m)$ average time algorithm. This is achieved by slightly changing the model of computation, and with a modification of an existing algorithm. Our technique uses a super-alphabet for simulating suffix automaton. The space usage of the algorithm is $\mathcal{O}(\sigma m)$. The technique can be applied to many other string matching algorithms, including dictionary matching, which is also solved in expected time $\mathcal{O}(n/m)$, and approximate matching allowing k edit operations (mismatches, insertions or deletions of characters). This is solved in expected time $\mathcal{O}(nk/m)$ for $k \leqslant \mathcal{O}(m/\log _\sigma m)$. The known lower bound for this problem is Ω (n(k+log_σ m)/m), given in [6]. Finally we show how to adopt a similar technique to the shift-or algorithm, extending its bit-parallelism in another direction. This gives a speed-up by a factor s, where s is the number of characters processed simultaneously. Some of the algorithms are implemented, and we show that the methods work well in practice too. This is especially true for the shift-or algorithm, which in some cases works faster than predicted by the theory. The result is the fastest known algorithm for exact string matching for short patterns and small alphabets. All the methods and analyses assume the ram model of computation, and that each symbol is coded in b =⌈log₂ σ⌉ bits. They work for larger b too, but the speed-up is decreased