Amihood Amir

Faster algorithms for string matching with k mismatches

The string matching with mismatches problem is that of finding the number of mismatches between a pattern P of length m and every length m substring of the text T. Currently, the fastest algorithms for this problem are the following. The Galil-Giancarlo algorithm finds all locations where the pattern has at most k errors (where k is part of the input) in time O(nk). The Abrahamson algorithm finds the number of mismatches at every location in time O(n√ m log m). 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√k log k). We also show an algorithm that solves the above problem in time O((n + (nk3)/m) log k).

Maximum Agreement Subtree in a Set of Evolutionary Trees: Metrics and Efficient Algorithms

The maximum agreement subtree approach is one method of reconciling different evolutionary trees for the same set of species. An agreement subtree enables choosing a subset of the species for whom the restricted subtree is equivalent (under a suitable definition) in all given evolutionary trees. Recently, dynamic programming ideas were used to provide polynomial time algorithms for finding a maximum homeomorphic agreement subtree of two trees. Generalizing these methods to sets of more than two trees yields algorithms that are exponential in the number of trees. Unfortunately, it turns out that in reality one is usually presented with more than two trees, sometimes as many as thousands of trees. In this paper we prove that the maximum homeomorphic agreement subtree problem is

Some connections between bounded query classes and nonuniform complexity

\cal{NP}

Alphabet dependence in parameterized matching

-complete for three trees with unbounded degrees. We then show an approximation algorithm of time O(kn5) for choosing the species that are not in a maximum agreement subtree of a set of k trees. Our approximation is guaranteed to provide a set that is no more than 4 times the optimum solution. While the set of evolutionary trees may be large in practice, the trees usually have very small degrees, typically no larger than three. We develop a new method for finding a maximum agreement subtree of k trees, of which one has degree bounded by d. This new method enables us to find a maximum agreement subtree in time O(knd + 1+ n2d).

Text Indexing and Dictionary Matching with One Error

It is shown that if there is a polynomial-time algorithm that tests k(n)=O(log n) points for membership in a set A by making only k(n)-1 adaptive queries to an oracle set X, then A belongs to NP/poly intersection co-NP/poly (if k(n)=O(1) then A belong to P/poly). In particular, k(n)=O(log n) queries to an NP-complete set (k(n)=O(1) queries to an NP-hard set) are more powerful than k(n)-1 queries, unless the polynomial hierarchy collapses. Similarly, if there is a small circuit that tests k(n) points for membership in A by making only k(n)-1 adaptive queries to a set X, then there is a correspondingly small circuit that decides membership in A without an oracle. An investigation is conducted of the quantitatively stronger assumption that there is a polynomial-time algorithm that tests 2/sup k/ strings for membership in A by making only k queries to an oracle X, and qualitatively stronger conclusions about the structure of A are derived: A cannot be self-reducible unless A in P, and A cannot be NP-hard unless P=NP. Similar results hold for counting classes. In addition, relationships between bounded-query computations, lowness, and the p-degrees are investigated.<<ETX>>

Efficient 2-Dimensional Approximate Matching of Half-Rectangular Figures

Abstract The classical pattern matching paradigm is that of seeking occurences 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 program fragments 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 occurences of one string in the other are sought, where renaming of the variables from Π is allowed in a match. In this paper we provide an algorithm to find all occurences of a pattern string of length m in a text string of length n under the parameterized pattern matching model. Our algorithm takes time O(n log π), where π = min(m, |Π|), independent of |Σ|. Our algorithm is optimal since weshow that this dependence on |Π| is inherent to any algorithm for this problem in the comparison model.

An Alphabet Independent Approach to Two-Dimensional Pattern Matching

The indexing problem is where a text is preprocessed and subsequent queries of the form “Find all occurrences of pattern P in the text” are answered in time proportional to the length of the query and the number of occurrences. In the dictionary matching problem a set of patterns is preprocessed and subsequent queries of the form “Find all occurrences of dictionary patterns in text T” are answered in time proportional to the length of the text and the number of occurrences.There exist efficient worst-case solutions for the indexing problem and the dictionary matching problem, but none that find approximate occurrences of the patterns, i.e., where the pattern is within a bound edit (or Hamming) distance from the appropriate text location.In this paper we present a uniform deterministic solution to both the indexing and the general dictionary matching problem with one error. We preprocess the data in time O(nlog2n), where n is the text size in the indexing problem and the dictionary size in the dictionary matching problem. Our query time for the indexing problem is O(mlognloglogn+tocc), where m is the query string size and tocc is the number of occurrences. Our query time for the dictionary matching problem is O(nlog3dloglogd+tocc), where n is the text size and d the dictionary size. The time bounds above apply to both bounded and unbounded alphabets.

A new and versatile method for association generation

Finding all occurrences of a non-rectangular pattern of height m and area a in an n×n text with no more than k mismatch, insertion, and deletion errors is an important problem in computer vision. It can be solved using a dynamic programming approach in time O(an2). We show a O(kn2 √ m logm √ k log k + k2n2) algorithm which combines convolutions with dynamic programming. At the heart of the algorithm are the Smaller Matching Problem and the k-Aligned Ones with Location Problem. Efficient algorithms to solve both these problems are presented. The results presented in this paper appeared in the proceedings of the Second Symposium on Descrete Algorithms [AF91] College of Computing, Georgia Institute of Technology, Atlanta, GA 30332-0280; (404) 853-0083; amir@cc.gatech.edu; Partially supported by NSF grant IRI-9013055. DIMACS, Box 1179, Rutgers University, Piscataway, NJ 08855; (908) 932-5928; farach@dimacs.rutgers.edu

Fast parallel and serial multidimensional approximate array matching

There are many solutions to the string matching problem that are strictly linear in the input size and independent of alphabet size. Furthermore, the model of computation for these algorithms is very weak: they allow only simple arithmetic and comparisons of equality between characters of the input. In contrast, algorithms for two-dimensional matching have needed stronger models of computation, most notably assuming a totally ordered alphabet. The fastest algorithms for two-dimensional matching have therefore had a logarithmic dependence on the alphabet size. In the worst case, this gives an algorithm that runs in

Polynomial terse sets

O(n^2 \log{m})