Longest common substring problem
From Wikipedia, the free encyclopedia
The longest common substring problem is to find the longest string (or strings) that is a substring (or are substrings) of two or more strings. It should not be confused with the longest common subsequence problem. (For an explanation of the difference between a substring and a subsequence, see Substring vs. subsequence).
Contents |
[edit] Example
The longest common substrings of the strings "ABAB", "BABA" and "ABBA" are the strings "AB" and "BA" of length 2. Other common substrings are "A", "B" and the empty string "".
ABAB ||| BABA || ABBA
[edit] Problem definition
Given two strings, S of length m and T of length n, find the longest strings which are a substrings of both S and T.
A generalisation is the k-common substring problem. Given the set of strings S = {S1,...,SK}, where | Si | = ni and Σni = N. Find for each 2 ≤ k ≤ K, the longest strings which occur as substrings of at least k strings.
[edit] Algorithms
You can find the lengths and starting positions of the longest common substrings of S and T in Θ(n + m) with the help of a generalised suffix tree. Finding them by dynamic programming costs Θ(nm). The solutions to the generalised problem take Θ(n1 + ... + nK) and Θ(n1·...·nK) time.
[edit] Suffix tree
You can find the longest common substrings of a set of strings by building a generalised suffix tree for the strings, and then finding the deepest internal nodes which has leaf nodes from all the strings in the subtree below it. In the figure on the right you see the suffix tree for the strings "ABAB", "BABA" and "ABBA", padded with unique string terminators, to become "ABAB$0", "BABA$1" and "ABBA$2". The nodes representing "A", "B", "AB" and "BA" all have descendant leaves from all of the strings, numbered 0, 1 and 2.
Building the suffix tree takes Θ(n) time (if the size of the alphabet is constant). If you traverse the tree bottom up, and maintain a bit vector telling which strings are seen below each node, you can solve the k-common substring problem in Θ(NK) time. If you prepare your suffix tree for constant time lowest common ancestor retrieval, you can solve it in Θ(N) time.[1]
[edit] Dynamic programming
You first find the longest common suffix for all pairs of prefixes of the strings. The longest common suffix is
![\mathit{LCSuff}(S_{1..p}, T_{1..q}) =
\begin{cases}
\mathit{LCSuff}(S_{1..p-1}, T_{1..q-1}) + 1 & \mathrm{if } \; S[p] = T[q] \\
0 & \mathrm{otherwise}
\end{cases}](http://upload.wikimedia.org/math/5/9/b/59bedec58669e638a84364c93529cb4e.png)
For the example strings "ABAB" and "BABA":
| A | B | A | B | ||
|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | |
| B | 0 | 0 | 1 | 0 | 1 |
| A | 0 | 1 | 0 | 2 | 0 |
| B | 0 | 0 | 2 | 0 | 3 |
| A | 0 | 1 | 0 | 3 | 0 |
The maximal of these longest common suffixes of possible prefixes must be the longest common substrings of S and T. These are shown on diagonals, in red, in the table.
This can be extended to more than two strings by adding more dimensions to the table.
[edit] Pseudocode
 |
The Wikibook Algorithm implementation has a page on the topic of |
The following pseudocode finds the set of longest common substrings between two strings with dynamic programming:
function LCSubstr(S[1..m], T[1..n])
L := array(0..m, 0..n)
z := 0
ret := {}
for i := 1..m
for j := 1..n
if S[i] = T[j]
if i = 1 or j = 1
L[i,j] := 1
else
L[i,j] := L[i-1,j-1] + 1
if L[i,j] > z
z := L[i,j]
ret := {}
if L[i,j] = z
ret := ret ∪ {S[i-z+1..i]}
return ret
This algorithm runs in O(mn) time. The variable z is used to hold the length of the longest common substring found so far. The set ret is used to hold the set of strings which are of length z. The set ret can be saved efficiently by just storing the index i, which is the last character of the longest common substring (of size z) instead of S[i-z+1..i]. Thus all the longest common substrings would be, for each i in ret, S[(ret[i]-z)..(ret[i])].
The following tricks can be used to reduce the memory usage of an implementation:
- Keep only the last and current row of the DP table to save memory (O(min(m,n)) instead of O(mn))
- Store only non-zero values in the rows. You can do this by using hash tables instead of arrays. This is useful for large alphabets.
[edit] References
- ^ Gusfield, Dan (1999) [1997]. Algorithms on Strings, Trees and Sequences: Computer Science and Computational Biology. USA: Cambridge University Press. ISBN 0-521-58519-8.
