21
November Meeting 10, 2004
String Matching
(read Section 32 on String Matching in C ORMEN , L EISERSON , R IVEST, S TEIN)
HOCUSPOCUSABRA BRACADABRA... ABRA ABR AB A CADABRA ACADABRA RACADABRA BRACADABRA
The straightforward approach to solving this problem uses two nested for-loops. The outer loop enumerates the and the inner loop compares with . We improve this algorithm by exiting the inner loop as soon as we nd the rst mismatch. to do ; for while and do ++ endwhile; if then print ; stop endif endfor; print there is no match. In the worst case, we test against substrings comparing pairs of characters in each test, which takes time O( ). We can in fact create an input where the running time is as high as this pessimistic estimate: take a text consisting of As and search with a pattern AA...AB of
Figure 104: Action of the straightforward algorithm. The box marks the leftmost mismatch for each shift.
algorithm increments the shift and starts the substring comparison from scratch. Note, however, that there is no point in looking at the shift . We already know that because it matched during the previous comparison. Likewise, we already know that the next shift also fail, so why bother looking there? Finally, we cannot immediately rule out a when we get to match based on earlier considerations. However, since we already know that , we should not start the substring comparison from scratch. Instead, we should start the substring comparison at the second character of the pattern, since we do not yet know whether or not it matches the corresponding text character. Notice that with these improvements the character comparison should always advance through the text. More precisely, once we have found a match for a text character, we
81
2 RQP
Text and Pattern. The problem we want to solve is the following. Given two strings, a text and a pattern , nd the rst substring of the text that is the same as the pattern. Here a substring is just a contiguous subarray. For any shift let denote the substring . More formally, we want to nd the smallest shift such that , or report that there is no match.
Redundant Comparisons. Suppose we are looking for the pattern ABRACADABRA in some longer text using the above straightforward algorithm. Consider the case shown in Figure 104 in which, for shift , the substring comparison fails at the fth position. At this point the
U S 2 A5
de20c a 2'cab ` 2 RY
S 2 TX8 W 2 S #VUT
$ 6I
In this and the next two sections we will talk about strings, which are really just arrays. The elements of the array come from a constant size set called the alphabet; the elements themselves are called characters. Common examples are English text whose alphabet consists of 26 letters plus special characters, stands of DNA constructed form an alphabet of four nucleotides, and proteins constructed from an alphabet of twenty aminoacids.
As followed by one B. On the other hand, breaking out of the inner loop at the rst mismatch makes the algorithm quite practical. Certainly for random strings, the probability of having long common substrings is rather small. But then again, text is typically not random.
) $ 6GF7
& '
9 8D 29 ) CB9 2 A@9 $ 87 65 2
2 & 3' 10 %' ( ) ) $ %#"!
& 0
& 2 6 E(9 ) 2
H
9
& 4
if or the current label is $, then we follow the success edge and increment ; if , then we follow the failure edge back to an earlier state and we keep unchanged.
The nite state machine is a convenient metaphor for a simple type of algorithm. Knuth-Morris-Pratt Algorithm. In a real implementation, we would of course not construct the entire graph. Since the success edges go through the pattern in order, we only have to remember the failure edges. Each state has one failure edge (except for states labeled with the two special characters, which have none) and we encode them so that for each there is a failure in an array edge from state to state . Following a failure edge back to an earlier state corresponds to shifting the pattern forward. For now, we assume that the failure edges are correctly computed and stored in the array . The algorithm implementing the nite state machine then looks as follows.
old s T P
new s
i =
ABRACADABR ABRACADABR
j
Figure 105: The new position, , precedes the rst character of the largest sufx that is a proper prex of the pattern.
!
$
A B
A
R
R
A
B A D A
C
82
cS
9
the pattern, except for two special states which are labeled $ and !. Success edges connect the characters in the sequence of the pattern beginning at $ and ending at !. Failure edges point back to earlier characters. Figure 106 illustrates the idea for the pattern ABRACADABRA which we considered earlier.
9 $ P
9
%$
9
Figure 106: The nite state machine for ABRACADABRA. The (thick) success edges connect the characters in sequence while the (thin) failure return edges to earlier positions in the string.
It is fairly easy to analyze the running time of the algorithm. At each character comparison, either we increase and by one each, or we decrease and leave unchanged. We can increment at most times before we run out of text, which implies that there are at most that many successful comparisons. Similarly there can be at most failed comparisons, since the number of times we decrease cannot exceed the number of times we increment . In other words, we amortize character mismatches over earlier character matches. The number of character comparisons performed by the Knuth-Morris-Pratt algorithm is less than , hence the running time is in O( ).
" ! 2 #6 G6(9 ) 2 9 9 (9 2 c 9 2 9 2 (9 2
; for to do while and
do
endwhile; ++; if then print ; stop endif endfor; print there is no match.
Finite State Machines. If we have a string matching algorithm that always advances through the text, we can interpret it as feeding the text through a nite state machine, which is a directed graph with labeled vertices. Each vertex is called a state and is labeled with a character from
9
2
9
9
c 9
9 2
9 2
never need to do another comparison with that character again. In other words, we should improve the straightforward algorithm so that it always advances through the text. We also need a good rule for nding the next shift. Remember that a prex of a string is a substring that includes the rst character. Symmetrically, a sufx is a substring that includes the last character. A prex or sufx is proper if it is not the entire string. Suppose that we have just discovered that . The next reasonable shift is the , which is a smallest value of such that sufx of the previously read text, is also a proper prex of the pattern; see Figure 105.
We use the nite state machine to search for the pattern as follows. At all times, we have a current text character and a current state, which is usually labeled by some pattern character . Initially, and the current state is the one labeled $. We iterate the following two rules:
b $ V )
9 2
endif endfor.
Alternatively, we can compute the improved failure function directly by substituting lines 2, 3, 4 for the line 1 in the earlier algorithm.
endif;
A 0
B 1
R 1
A 1
C 2
A 1
D 2
A 1
B 2
R 3
A 4
The improved failure function is shown in Table 16 and the corresponding nite state machine is shown in Figure 107.
A 0 B 1 R 1 A 0 C 2 A 0 D 2 A 0 B 1 R 1 A 0
Table 15: Failure function of the string ABRACADABRA.
is essentially to use the Knuth-Morris-Pratt algorithm to look for the pattern inside itself. The variable identies as the longest prex of that is also a sufx of . If matches we increment , else we try the previously computed next smaller prex: ;
Table 16: The improved failure function of ABRACADABRA. The changed failure pointers are bold.
!
$
A
while...