Dictionary matching and indexing with errors and don't cares

ACM Transactions on Database Systems, 1983

We consider the problem of designing an information retrieval system on which partial match queries have to be answered. Each record in the system consists of a list of attributes , and a partial match query specifies the values of some of the attributes. The records are stored in buckets in a secondary memory, and in order to answer a partial match query all the buckets that may contain a record satisfying the specifications of that query must be retrieved. The bucket in which a given record is stored is found by a multiple key hashing function, which maps each attribute to a string of a fixed number of bits. The address of that bucket is then represented by the string obtained by concatenating the strings on which the various attributes were mapped. A partial match query may specify only part of the bits in the string representing the address, and the larger the number of bits specified, the smaller the number of buckets that have to be retrieved in order to answer the query. The ...

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.

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.

2015

Given a pattern string $P$ of length $n$ and a query string $T$ of length $m$, where the characters of $P$ and $T$ are drawn from an alphabet of size $\Delta$, the {\em exact string matching} problem consists of finding all occurrences of $P$ in $T$. For this problem, we present algorithms that in $O(n\Delta^2)$ time pre-process $P$ to essentially identify $sparse(P)$, a rarely occurring substring of $P$, and then use it to find occurrences of $P$ in $T$ efficiently. Our algorithms require a worst case search time of $O(m)$, and expected search time of $O(m/min(|sparse(P)|, \Delta))$, where $|sparse(P)|$ is at least $\delta$ (i.e. the number of distinct characters in $P$), and for most pattern strings it is observed to be $\Omega(n^{1/2})$.

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∆−δ )).

Algorithmica, 1999

We present a new algorithm for on-line approximate string matching. The algorithm is based on the simulation of a nondeterministic finite automaton built from the pattern and using the text as input. This simulation uses bit operations on a RAM machine with word length w = (log n) bits, where n is the text size. This is essentially similar to the model used in Wu and Manber's work, although we improve the search time by packing the automaton states differently. The running time achieved is O(n) for small patterns (i.e., whenever mk = O(log n)), where m is the pattern length and k < m is the number of allowed errors. This is in contrast with the result of Wu and Manber, which is O(kn) for m = O(log n). Longer patterns can be processed by partitioning the automaton into many machine words, at O(mk/w n) search cost. We allow generalizations in the pattern, such as classes of characters, gaps, and others, at essentially the same search cost.

Theoretical Computer Science, 2011

We introduce a new dimension to the widely studied on-line approximate string matching problem, by introducing an error threshold parameter ǫ so that the algorithm is allowed to miss occurrences with probability ǫ. This is particularly appropriate for this problem, as approximate searching is used to model many cases where exact answers are not mandatory. We show that the relaxed version of the problem allows us breaking the average-case optimal lower bound of the classical problem, achieving average case O(n log σ m/m) time with any ǫ = poly(k/m), where n is the text size, m the pattern length, k the number of errors for edit distance, and σ the alphabet size. Our experimental results show the practicality of this novel and promising research direction.

SIAM Journal on Computing, 1997

This paper considers how many character comparisons are needed to find all occurrences of a pattern of length m in a text of length n. The main contribution is to show an upper bound of the form of n + O(n/m) character comparisons, following preprocessing. Specifically, we show an upper bound of n + 8 3(m+1) (n − m) character comparisons. This bound is achieved by an online algorithm which performs O(n) work in total and requires O(m) space and O(m 2) time for preprocessing. The current best lower bound for online algorithms is n + 16 7m+27 (n − m) character comparisons for m = 16k + 19, for any integer k ≥ 1, and for general algorithms is n + 2 m+3 (n − m) character comparisons, for m = 2k + 1, for any integer k ≥ 1.

Theoretical Computer Science, 2006

Let T be a text of length n and P be a pattern of length m, both strings over a fixed finite alphabet A. The k-difference (k-mismatch, respectively) problem is to find all occurrences of P in T that have edit distance (Hamming distance, respectively) at most k from P . In this paper we investigate a well-studied case in which T is fixed and preprocessed into an indexing data structure so that any pattern query can be answered faster. We give a solution using an O(n log n) bits indexing data structure with O(|A| k m k ·max(k, log n)+occ) query time, where occ is the number of occurrences. The best previous result requires O(n log n) bits indexing data structure and gives O(|A| k m k+2 + occ) query time. Our solution also allows us to exploit compressed suffix arrays to reduce the indexing space to O(n) bits, while increasing the query time by an O(log n) factor only.

Journal of Algorithms, 2004

The string matching with mismatches problem is that of finding the number of mismatches between pattern P of length m and every length m substring of the text T. Currently, the best algorithms for this problem are the following. The Landau-Vishkin algorithm finds all locations where the pattern has at most k errors (where k is part of the input) in time O(nk). The We present an algorithm that is faster than both. Our algorithm finds all locations where the pattern has at most k errors in time O ( n ~) . We also show an algorithm that solves the above problem in time O((~ + "k3 ~ log k).