Thuật toán Algorithms (Phần 26)
lượt xem 7
download
Thuật toán Algorithms (Phần 26)
Tham khảo tài liệu 'thuật toán algorithms (phần 26)', khoa học tự nhiên, toán học phục vụ nhu cầu học tập, nghiên cứu và làm việc hiệu quả
Bình luận(0) Đăng nhập để gửi bình luận!
Nội dung Text: Thuật toán Algorithms (Phần 26)
 STRING SEARCHING 243 and has limited the extent, to which they are used. (In fact, the story goes that an unknown systems programmer found Morris’ algorithm too difficult to understand and replaced it with a bruteforce implementation.) In 1980, R. M. Karp and M. 0. Rabin observed that the problem is not as different from the standard searching problem as it had seemed, and came up with an algorithm almost as simple as the bruteforce algorithm which virtually always runs in time proportional to M + N. Furthermore, their algorithm extends easily to twodimensional patterns and text, which makes it more useful than the others for picture processing. This story illustrates that the search for a “better algorithm” is still very often justified: one suspects that there are still more developments on the horizon even for this problem. BruteForce Algorithm The obvious method for pattern matching that immediately comes to mind is just to check, for each possible position in the text at which the pattern could match, whether it does in fact match. The following program searches in this way for the first occurrence of a pattern p [ 1. .M] in a text string a [ 1. .N] : function brutesearch: integer; var i, j: integer; begin i:=l; j:=l; repeat if a[i]=plj] then begin i:=i+l; j:=j+l end else begin i:=ij+2; j:=1 end; until (j>M)or (i>N); if j>M then brutesearch:=iM else brutesearch:=i end ; The program keeps one pointer (i) into the text, and another pointer (j) into the pattern. As long as they point to matching characters, both pointers are incremented. If the end of the pattern is reached (j>M), then a match has been found. If i and j point to mismatching characters, then j is reset to point to the beginning of the pattern and i is reset to correspond to moving the pattern to the right one position for matching against the text. If the end of the text is reached (i>N), then there is no match. If the pattern does not occur in the text, the value N+l is returned. In a textediting application, the inner loop of this program is seldom iterated, and the running time is very nearly proportional to the number of
 244 CHAPTER 19 text characters examined. For example, suppose that we are looking for the pattern STING in the text string A STRING SEARCHING EXAMPLE CONSISTING OF SIMPLE TEXT Then the statement j:=j+l is executed only four times (once for each S, but twice for the first ST) before the actual match is encountered. On the other hand, this program can be very slow for some patterns. For example, if the pattern is 00000001 and the text string is: 00000000000000000000000000000000000000000000000000001 then j is incremented 7*45 (315) times before the match is encountered. Such degenerate strings are not likely in English (or Pascal) text, but the algorithm does run more slowly when used on binary (twocharacter) text, as might occur in picture processing and systems programming applications. The following table shows what happens when the algorithm is used to search for 10010111 in the following binary string: 100111010010010010010111000111 1001 1 10 10010 10010 10010 10010111 There is one line in this table for each time the body of the repeat loop is entered, and one character for each time j is incremented. These are the “false starts” that occur when trying to find the pattern: an obvious goal is to try to limit the number and length of these. KnuthMorrisPratt Algorithm The basic idea behind the algorithm discovered by Knuth, Morris, and Pratt is this: when a mismatch is detected, our “false start” consists of characters that we know in advance (since they’re in the pattern). Somehow we should be able to take advantage of this information instead of backing up the i pointer over all those known characters.
 STRING SEARCHING 245 For a simple example of this, suppose that the first character in the pattern doesn’t appear again in the pattern (say the pattern is 10000000). Then, suppose we have a false start j characters long at some position in the text. When the mismatch is detected, we know, by dint of the fact that j characters have matched, that we don’t have to “back up” the text pointer i, since none of the previous jl characters in the text can match the first character in the pattern. This change could be implemented by replacing i:=ij+2 in the program above by i:=i+l. The practical effect of this change is limited because such a specialized pattern is not particularly likely to occur, but the idea is worth thinking about because the Knuth MorrisPratt algorithm is a generalization. Surprisingly, it is always possible to arrange things so that the i pointer is never decremented. Fully skipping past the pattern on detecting a mismatch as described in the previous paragraph won’t work when the pattern could match itself at the point of the mismatch. For example, when searching for 10100111 in 1010100111 we first detect the mismatch at the fifth character, but we had better back up to the third character to continue the search, since otherwise we would miss the match. But we can figure out ahead of time exactly what to do, because it depends only on the pattern, as shown by the following table: j p[l..jl] next b] 2 11 1 3 10 1 4 101 2 5 1010 3 The array next [1..M] will be used to determine how far to back up when a mismatch is detected. In the table, imagine that we slide a copy of the first jl characters of the pattern over itself, from left to right starting with the first character of the copy over the second character of the pattern, stopping when all overlapping characters match (or there are none). These overlapping characters define the next possible place that the pattern could match, if a mismatch is detected at pbl. The distance to back up (next b]) is exactly one plus the number of the overlapping characters. Specifically, for j>l, the value of nextb] is the maximum k
 246 CHAPTER 19 table. As we’ll soon see, it is convenient to define next[I] to be 0. This next array immediately gives a way to limit (in fact, as we’ll see, eliminate) the “backup” of the text pointer i: a generalization of the method above. When i and j point to mismatching characters (testing for a pattern match beginning at position ij+1 in the text string), then the next possible position for a pattern match is beginning at position inextIj]+l. But by definition of the next table, the first nextb]I characters at that position match the first nextb]l characters of the pattern, so there’s no need to back up the i pointer that far: we can simply leave the i pointer unchanged and set the j pointer to next b], as in the following program: function kmpsearch : integer ; var i, j: integer; begin i:=l; j:=l; repeat if (j=O) or (a[i]=pb]) then begin i:=i+l; j:=j+l end else begin j:=nextLj] end; until (j>M) or (i>N); if j> M then kmpsearch : =iM else kmpsearch : =i; end ; When j=l and a[i] does not match the pattern, there is no overlap, so we want to increment i and set j to the beginning of the pattern. This is achieved by defining next [I] to be 0, which results in j being set to 0, then i is incremented and j set to 1 next time through the loop. (For this trick to work, the pattern array must be declared to start at 0, otherwise standard Pascal will complain about subscript out of range when j=O even though it doesn’t really have to access p[O] to determine the truth of the or.) Functionally, this program is the same as brutesearch, but it is likely to run faster for patterns which are highly selfrepetitive. It remains to compute the next table. The program for this is short but tricky: it is basically the same program as above, except that it is used to match the pattern against itself.
 STRING SEARCHING 247 procedure initnext ; var i, j: integer; begin i:=l; j:=O; next[l]:=O; repeat if (j=O) or (p[i]=plj]) then begin i:=i+l; j:=j+l; next[i]:=j end else begin j:=nextIj] end; until i>M; end ; Just after i and j are incremented, it has been determined that the first jl characters of the pattern match the characters in positions p [ij 1. .i1 1, the last jl characters in the first il characters of the pattern. And this is the largest j with this property, since otherwise a “possible match” of the pattern with itself would have been missed. Thus, j is exactly the value to be assigned to next [il. An interesting way to view this algorithm is to consider the pattern as fixed, so that the next table can be “wired in” to the program. For example, the following program is exactly equivalent to the program above for the pattern that we’ve been considering, but it’s likely to be much more efficient. i:=O; 0: i:=i+l; 1: if a[i]‘l’then goto 0; i:=i+l; 2: if a[i]‘O’then goto 1; i:=i+l; 3: if a[i]‘l’then goto 1; i:=i+l; 4: if a[i]‘O’then goto 2; i:=i+l; 5: if a[i]‘O’then goto 3; i:=i+l; 6: if a[i]‘l’then goto 1; i:=i+l; 7: if a[i]‘l’then goto 2; i:=i+l; 8: if a[i]‘l’then goto 2; i:=i+l; search : =i8; The goto labels in this program correspond precisely to the next table. In fact, the in&next program above which computes the next table could easily be modified to output this program! To avoid checking whether i>N each time i is incremented, we assume that the pattern itself is stored at the end of the text as a sentinel, in a[N+l ..N+M]. (This optimization could also be applied to the standard implementation.) This is a simple example of a “stringsearching compiler” : given a pattern, we can produce a very efficient
 248 CHAPTER 19 program which can scan for that pattern in an arbitrarily long text string. We’ll see generalizations of this concept in the next two chapters. The program above uses just a few very basic operations to solve the string searching problem. This means that it can easily be described in terms of a very simple machine model, called a finitestate machine. The following diagram shows the finitestate machine for the program above: cd. .. . I,. e. // \ / ’\ ‘\ // \ \ ’ \ ff _ \ f \ 1 '0 1 0 0 '1 ;D \' \\ ' / I // , ',‘Z H' / / // .' /  . Nw . #CC /' =z _ cc) The machine consists of states (indicated by circled letters) and transi tions (indicated by arrows). Each state has two transitions leaving it: a match transition (solid line) and a nonmatch transition (dotted line). The states are where the machine executes instructions; the transitions are the goto in structions. When in the state labeled “5,” the machine can perform just one instruction: “if t.he current character is x then scan past it and take the match transition, otherwise take the nonmatch transition.” To “scan past” a character means to take the next character in the string as the “current character”; the machine scans past characters as it matches them. There is one exception to this: the nonmatch transition in the first state (marked with a double line) also requires that the machine scan to the next charac ter. (Essentially this corresponds to scanning for the first occurrence of the first character in the pattern.) In the next chapter we’ll see how to use a similar (but more powerful) machine to help develop a much more powerful patternmatching algorithm. The alert reader may have noticed that there’s still some room for im provement in this algorithm, because it doesn’t take into account the character which caused the mismatch. For example, suppose that we encounter 1011 when searching for our sample pattern 10100111. After matching 101, we find a mismatch on the fourth character, at which point the next table says to check the second character, since we already matched the 1 in the third character. However, we could not have a match here: from the mismatch, we know that the next character in the text is not 0, as required by the pattern.
 STRING SEARCHING 249 Another way to see this is to look at the version of the program with the next table “wired in”: at label 4 we go to 2 if a[i] is not 0, but at label 2 we go to 1 if a[i] is not 0. Why not just go to 1 directly? Fortunately, it is easy to put this change into the algorithm. We need only replace the statement next[i] :=j in the initnext program by if plj]p[i] then next[i]:=j else next[i]:=nextb]; With this change, we either increment j cr reset it from the next table at most once for each value of i, so the algorithm is clearly linear. The KnuthMorrisPratt algorithm LS not likely to be significantly faster than the bruteforce method in most actual applications, because few ap plications involve searching for highly selfrepetitive patterns in highly self repetitive text. However, the method does have a major virtue from a practi cal point of view: it proceeds sequentially through the input and never “backs up” in the input. This makes the method convenient for use on a large file being read in from some external device. (Algorithms which require backup require some complicated buffering in this situation.) BoyerMoore Algorithm If “backing up” is not a problem, then a significantly faster string searching method can be developed by scanning .,he pattern from right to left when trying to match it against the text. When searching for our sample pattern 10100111, if we find matches on the eighth, seventh, and sixth character but not on the fifth, then we can immediatelyi slide the pattern seven positions to the right, and check the fifteenth character next, because our partial match found 111, which might appear elsewhm?re in the pattern. Of course, the pattern at the end does appear elsewhere: in general, so we need a next table as above. For example, the following is a righttoleft version of the next table for the pattern 10110101: j p[Mj+2..M] p[Mn~3xt~]+l..M] nextb] 2 1 101 4 3 010110101 7 4 10101 2 5 010110101 5 6 1010110101 5 7 11010110101 5 8 011010110101 1 5
 250 CHAPTER 19 The number at the right on the jth line of the table gives the maximum number of character positions that the pattern can be shifted to the right given that a mismatch in a righttoleft scan occurred on the jth character from the right in the pattern. This is found in a similar manner as before, by sliding a copy of the pattern over the last jl characters of itself from left to right starting with the nexttolast character of the copy lined up with the last character of the pattern, stopping when all overlapping characters match (also taking into account the character which caused the mismatch). This leads directly to a program which is quite similar to the above implementation of the KnuthMorrisPratt method. We won’t go into this in more detail because there is a quite different way to skip over characters with righttoleft pattern scanning which is much better in many cases. The idea is to decide what to do next based on the character that caused the mismatch in the tezt as well as the pattern. The simplest realization of this leads immediately to a quite useful program. Consider the first example that we studied, searching for the pattern STING in the text string A STRING SEARCHING EXAMPLE CONSISTING OF SIMPLE TEXT Proceeding from right to left to match the pattern, we first check the G in the pattern against the R (the fifth character) in the text. Not only do these not match, but also we can notice that R does not appear anywhere in the pattern, so we might as well slide it all the way past the R. The next comparison is of the G in the pattern against the fifth character following the R (the S in SEARCHING). This time, we can slide the pattern to the right until its S matches the S in the text. Then the G in the pattern is compared against the C in SEARCHING, which doesn’t appear in the pattern, so it can be slid five more places to the right. After three more fivecharacter skips, we arrive at the T in CONSISTING, at which point we align the pattern so that the its T matches the T in the text and find the full match. This method brings us right to the match position at a cost of examining only seven characters in the text (and five more to verify the match)! If the alphabet is not small and the pattern is not long, then this “mismatched character algorithm” will find a pattern of length M in a text string of length N in about N/M steps. The mismatched character algorithm is quite easy to implement. It simply improves a bruteforce righttoleft pattern scan by using an array skip which tells, for each character in the alphabet, how far to skip if that character appears in the text and causes a mismatch:
 STRING SEARCHING 251 function mischarsearch: integer; var i, j: integer; begin i:=M; j:=:M; repeat if a[i]=pb] then begin i:=i1; j:=j1 end else begin i:=i+Mj+l; j:=M; if skip[index(a[i])]>Mj+1 then i:=i+skip[index(a[i])](Mj+l); end; until (jN); mischarsearch:=i+l end ; The statement i:=i+Mj+1 resets i to the next position in the text string (as the pattern moves from lefttoright across it); then j:=M resets the pattern pointer to prepare for a righttoleft characterbycharacter match. The next statement moves the pattern even further across the text, if warranted. For simplicity, we assume that we have a function index(c: char): integer; that returns 0 for blanks and i for the ith letter of the alphabet, and a procedure initskip which initializes the skip array tll M for characters not in the pattern and then for j from 1 to M sets skip[index(pb])] to Mj. For example, for the pattern STING, the skip entry for G would be 0, the entry for N would be 1, the entry for I would be 2, the entry for T would be 3, the entry for S would be 4, and the entries for all other letters T,vould be 5. Thus, for example, when an S is encountered during a righttolefi, search, the i pointer is incremented by 4 so that the end of the pattern is alig;ned four positions to the right of the S (and consequently the S in the pattern lines up with the S in the text). If there were more than one S in the pattern, we would want to use the rightmost one for this calculation: hence the skip array is built by scanning from left to right. Boyer and Moore suggested combining the two methods we have outlined for righttoleft patt,ern scanning, choosing the larger of the two skips called for. The mismatched character algorithm obviously won’t help much for bi nary strings, because there are only two possibilities for characters which cause the mismatch (and these are both likely to be in the pattern). However, the bits can be grouped together to make “characters” which can be used exactly
 252 CRAI’TER 19 as above. If we take b bits at a time, then we need a skip table with 2b entries. The value of b should be chosen small enough so that this table is not too large, but large enough that most bbit sections of the text are not likely to be in the pattern. Specifically, there are M  b + 1 different bbit sections in the pattern (one starting at each bit position from 1 through Mb+ 1) so we want M  b + 1 to be significantly less than 2b. For example, if we take b to be about lg(4M), then the skip table will be more than threequarters filled with M entries. Also b must be less than M/2, otherwise we could miss the pattern entirely if it were split between two bbit text sections. RabinKarp Algorithm A bruteforce approach to string searching which we didn’t examine above would be to use a large memory to advantage by treating each possible M character section of the text as a key in a standard hash table. But it is not necessary to keep a whole hash table, since the problem is set up so that only one key is being sought: all that we need to do is to compute the hash function for each of the possible Mcharacter sections of the text and check if it is equal to the hash function of the pattern. The problem with this method is that it seems at first to be just as hard to compute the hash function for M characters from the text as it is merely to check to see if they’re equal to the pattern. Rabin and Karp found an easy way to get around this problem for the hash function h(k) = kmodq where q (the table size) is a large prime. Their method is based on computing the hash function for position i in the text given its value for position i  1. The method follows quite directly from the mathematical formulation. Let’s assume that we translate our M characters to numbers by packing them together in a computer word, which we then treat as an integer. This corresponds to writing the characters as numbers in a based number system, where d is the number of possible characters. The number corresponding to a[i..i + M  l] is thus z = a[i]dMP1 + a[i + lIdMe + ... + a[i + M  l] and we can assume that we know the value of h(z) = xmodq. But shifting one position right in the text simply corresponds to replacing x by (x  a[i]dMel)d + a[i + M]. A fundamental property of the mod operation is that we can perform it at any time during these operations and still get the same answer. Put another way, if we take the remainder when divided by q after each arithmetic operation (to keep the numbers that we’re dealing with small) then we get the same answer that we would if we were to perform all of the arithmetic operations, then take the remainder when divided by q.
CÓ THỂ BẠN MUỐN DOWNLOAD

Thuật toán Algorithms (Phần 1)
10 p  74  18

Thuật toán Algorithms (Phần 16)
10 p  71  15

Thuật toán Algorithms (Phần 2)
10 p  57  10

Thuật toán Algorithms (Phần 8)
10 p  60  9

Thuật toán Algorithms (Phần 11)
10 p  61  9

Thuật toán Algorithms (Phần 3)
10 p  62  8

Thuật toán Algorithms (Phần 12)
10 p  54  8

Thuật toán Algorithms (Phần 4)
10 p  54  7

Thuật toán Algorithms (Phần 13)
10 p  52  7

Thuật toán Algorithms (Phần 6)
10 p  62  7

Thuật toán Algorithms (Phần 10)
10 p  51  6

Thuật toán Algorithms (Phần 9)
10 p  57  6

Thuật toán Algorithms (Phần 7)
10 p  49  6

Thuật toán Algorithms (Phần 5)
10 p  60  6

Thuật toán Algorithms (Phần 14)
10 p  34  5

Thuật toán Algorithms (Phần 15)
10 p  38  4

Thuật toán Algorithms (Phần 17)
10 p  38  4