Editors: Roberto Grossi and Moshe Lewenstein

ArXiv, 2015

Given a pattern string P of length n consisting of δ distinct characters and a query string T of length m, where the characters of P and T are drawn from an alphabet Σ of size ∆, the exact string matching problem consists of finding all occurrences of P in T . For this problem, we present a randomized heuristic that in O(nδ) time preprocesses P to identify sparse(P ), a rarely occurring substring of P , and then use it to find all occurrences of P in T efficiently. This heuristic has an expected search time of O( m min(|sparse(P )|,∆) ), where |sparse(P )| is at least δ. We also show that for a pattern string P whose characters are chosen uniformly at random from an alphabet of size ∆, E[|sparse(P )|] is Ω(∆log( 2∆ 2∆−δ )).

Information Processing Letters, 1994

The classical pattern matching paradigm is that of seeking occurrences of one string in another, where both strings are drawn from an alphabet set Σ. A recently introduced model is that of parameterized pattern matching; the main motivation for this scheme lies in software maintenance where programs are considered "identical" even if variables names are different. Besides the fixed symbols from Σ, strings, under this model, have additional symbols from a variable set Π and occurrences of one string in the other are sought, where renaming of the variables from Π is allowed in a match. In this paper we show that finding the occurrences of a m-length string in a n-length string under the parameterized pattern matching paradigm can be done in time O(n log π), where π = min(m, |Π|), that is, independent of |Σ|. Additionally, we show that in general this dependence on |Π| is inherent to any algorithm for this problem in the comparison model-that is, our algorithm is optimal.

Lecture Notes in Computer Science, 2003

In this paper we give the first, to our knowledge, structures and corresponding algorithms for approximate indexing, by considering the Hamming distance, having the following properties. i) Their size is linear times a polylog of the size of the text on average. ii) For each pattern x, the time spent by our algorithms for finding the list occ(x) of all occurrences of a pattern x in the text, up to a certain distance, is proportional on average to |x| + |occ(x)|, under an additional but realistic hypothesis.

Algorithms, 2015

In this paper, we consider several variants of the pattern matching with mismatches problem. In particular, given a text T = t 1 t 2 • • • t n and a pattern P = p 1 p 2 • • • p m , we investigate the following problems: (1) pattern matching with mismatches: for every i, 1 ≤ i ≤ n − m + 1 output, the distance between P and t i t i+1 • • • t i+m−1 ; and (2) pattern matching with k mismatches: output those positions i where the distance between P and t i t i+1 • • • t i+m−1 is less than a given threshold k. The distance metric used is the Hamming distance. We present some novel algorithms and techniques for solving these problems. We offer deterministic, randomized and approximation algorithms. We consider variants of these problems where there could be wild cards in either the text or the pattern or both. We also present an experimental evaluation of these algorithms. The source code is available at http://www.engr.uconn.edu/∼man09004/kmis.zip.

We consider a version of pattern matching useful in processing large musical data: ¤ matching, which consists in finding matches which are ¤-approximate in the sense of the distance measured as maximum difference between symbols. The alphabet is an interval of integers, and the distance between two symbols ¥ , ¦ is measured as §¥ © ¦ §. We also consider ¤-matching, where is a bound on the total sum of the differences. We first consider "occurrence heuristics" by adapting exact string matching algorithms to the two notions of approximate string matching. The resulting algorithms are efficient in practice. Then we consider "substring heuristics". We present ¤-matching algorithms fast on the average providing that the pattern is "non-flat" and the alphabet interval is large. The pattern is "flat" if its structure does not vary substantially. The algorithms, named ¤-BM1, ¤-BM2 and ¤-BM3 can be thought as members of the generalized Boyer-Moore family of algorithms. The algorithms are fast on average. This is the first paper on the subject, previously only "occurrence heuristics" have been considered. Our substring heuristics are much stronger and refer to larger parts of texts (not only to single positions). We use ¤-versions of suffix tries and subword

Algorithmica

We introduce data structures answering queries concerning the occurrences of patterns from a given dictionary D in fragments of a given string T of length n. The dictionary is internal in the sense that each pattern in D is given as a fragment of T . This way, D takes space proportional to the number of patterns d = |D| rather than their total length, which could be Θ(n • d). In particular, we consider the following types of queries: reporting and counting all occurrences of patterns from D in a fragment T [i . . j] and reporting distinct patterns from D that occur in T [i . . j]. We show how to construct, in O((n + d) log O(1) n) time, a data structure that answers each of these queries in time O(log O(1) n + |output|). The case of counting patterns is much more involved and needs a combination of a locally consistent parsing with orthogonal range searching. Reporting distinct patterns, on the other hand, uses the structure of maximal repetitions in strings. Finally, we provide tight-up to subpolynomial factors-upper and lower bounds for the case of a dynamic dictionary. 1 The Õ(•) notation suppresses log O(1) n factors.

2010

This paper addresses the online exact string matching problem which consists in finding all occurrences of a given pattern p in a text t. It is an extensively studied problem in computer science, mainly due to its direct applications to such diverse areas as text, image and signal processing, speech analysis and recognition, data compression, information retrieval, computational biology and chemistry. Since 1970 more than 80 string matching algorithms have been proposed, and more than 50% of them in the last ten years. In this note we present a comprehensive list of all string matching algorithms and present experimental results in order to compare them from a practical point of view. ¿From our experimental evaluation it turns out that the performance of the algorithms are quite different for different alphabet sizes and pattern length.

Proceedings of the thirty-sixth annual ACM symposium on Theory of computing, 2004

This paper considers various flavors of the following online problem: preprocess a text or collection of strings, so that given a query string p, all matches of p with the text can be reported quickly. In this paper we consider matches in which a bounded number of mismatches are allowed, or in which a bounded number of "don't care" characters are allowed. The specific problems we look at are: indexing, in which there is a single text t, and we seek locations where p matches a substring of t; dictionary queries, in which a collection of strings is given upfront, and we seek those strings which match p in their entirety; and dictionary matching, in which a collection of strings is given upfront, and we seek those substrings of a (long) p which match an original string in its entirety. These are all instances of an all-to-all matching problem, for which we provide a single solution. The performance bounds all have a similar character. For example, for the indexing problem with n = |t| and m = |p|, the query time for k substitutions is O(m + (c 1 log n) k k! + # matches), with a data structure of size O(n (c 2 log n) k k!) and a preprocessing time of O(n (c 2 log n) k k!), where c1, c2 > 1 are constants. The deterministic preprocessing assumes a weakly nonuniform RAM model; this assumption is not needed if randomization is used in the preprocessing.

Theoretical Computer Science, 2006

We present a radically new indexing approach for approximate string matching. The scheme uses the metric properties of the edit distance and can be applied to any other metric between strings. We build a metric space where the sites are the nodes of the suffix tree of the text, and the approximate query is seen as a proximity query on that metric space. This permits us finding the occ occurrences of a pattern of length m, permitting up to r differences, in a text of length n over an alphabet of size σ, in average time O(m 1+ǫ + occ) for any ǫ > 0, if r = o(m/ log σ m) and m > 1+ǫ ǫ log σ n. The index works well up to r < (3− √ 2)m/ log σ m, where it achieves its maximum average search complexity O(m 1+ √ 2+ǫ + occ). The construction time of the index is O(m 1+ √ 2+ǫ n log n) and its space is O(m 1+ √ 2+ǫ n). This is the first index achieving average search time polynomial in m and independent of n, for r = O(m/ log σ m). Previous methods achieve this complexity only for r = O(m/ log σ n). We also present a simpler scheme needing O(n) space.

The study and comparison of strings of symbols from a nite or an in nite alphabet is relevant to various areas of science, notably molecular biology, speech recognition, and computer science. In particular, the problem of nding the minimum "distance" between two strings (in general, two blocks of data) is of great importance. In this paper we investigate the (string) pattern matching problem in a probabilistic framework, namely, it is assumed that both strings form an independent sequences of i.i.d. symbols. Given a text string a of length n and a pattern string b of length m, let M m;n be the maximum number of matches between b and all m-substrings of a. Our main probabilistic result shows that M m;n ? mP = ( p 2m log n) in probability (pr.) provided m; n ! 1 such that log n = o(m), where P is the probability of a match between any two symbols of these strings. If the alphabet is symmetric (i.e., all symbols occur with the same probability), a stronger result holds, namely (M m;n ? mP) p 2m(1=V ? 1=V 2 ) log n (pr.), where V is the size of the alphabet. In either case, symmetric alphabet or not, we also prove that M m;n =m ! P almost surely (a.s).