String Matching. Pattern Matching. Algorithms on Strings. Deterministic Finite Automaton. Brute-Force Algorithm. Plan:

Transcription

1 Algorithm Design nd Anlysis Victor Admchik CS 5-45 Spring 25 Lecture 24 Apr 2, 25 Crnegie Mellon University String Mtching Pln: Knuth-Morris-Prtt Aho-Corsick Rin-Krp J.Morris D.Knuth Algorithms on Strings Pttern Mtching Wild-crd Mtching Compute distnce etween two strings Compute longest sustring Compute chepest tree connecting ll given strings (phylogeny tree) Compute shortest superstring of ll strings Pttern Mtching Let T e string of length N over finite lphet S nd P e string of length M over S In pttern mtching prolem we serch for ll occurrences of pttern P in text T. Brute-Force Algorithm It runs in time O(n m) Exmple of worst cse: T = h P = h my occur in imges nd DNA sequences unlikely in English text Deterministic Finite Automton A finite utomton M is defined s 5-tuple M = (Σ, Q, q, A, ) Σ is the lphet Q is the set of sttes q Q is the strt stte A Q is the set of ccept sttes : Q Σ Q is the trnsition function L(M) = the lnguge of mchine M = set of ll strings mchine M ccepts

2 q M = (Q, Σ,, q, F) Q = {q, q, q2, q3} : Q Σ Q trnsition function Σ = {,} q Q is strt stte A = {q, q2} Q ccept sttes q M q 3, q 2 q q q q q 2 q 2 q 2 q 3 q 2 q 3 q q 2 strt stte (q ) trnsitions, The mchine ccepts string if the process ends in n ccept stte (doule circle) ccept sttes (F) ϵ sttes The Knuth-Morris-Prtt Algorithm (976) Build DFA from pttern Run DFA on multiple texts Build DFA from pttern The lphet is {, }. The pttern is. To crete DFA we consider ll prefixes ε,,,,,,,, These prefixes re sttes. The initil stte is ε (empty string). The pttern is the ccept stte. DFA Construction The Knuth-Morris-Prtt Algorithm (976) 97 Cook pulished pper out possiility of existence of such lgorithm Knuth nd Prtt developed n lgorithm Mtched: Morris discovered the sme lgorithm 2

3 Building DFA The Algorithm - Motivtion Wht is the worst-cse runtime of uilding DFA? O(M 3 Σ) M = pttern.length(); Σ = lphet.size(); elimintes the need to compute the entire trnsition function. Algorithm compres the pttern to the text in left-to-right, ut shifts the pttern more intelligently thn the rute-force lgorithm. When mismtch occurs, wht is the most we cn shift the pttern so s to void redundnt comprisons? x j No need to repet these comprisons text pttern Resume compring here we need to go ck s fr s possile in order to gurntee tht we don t miss nything. x It would we dngerous to move ck to We could miss something! So we need to tke the LONGEST suffix of P which is prefix of P How much cn string overlp with itself t ech position? Compute the length of the longest prefix of P tht is proper suffix of P. It determines where to go whenever there is mismtch in the next letter. Mtching 3

4 Mismtch It determines where to go whenever there is mismtch in the next letter. 4

5 Mtch Mismtch 5

6 6

7 The Algorithm Implementtion Filure Function Consider ll prefixes w[] of pttern, define [k] = mx(j<k w[j] is suffix w[k]) [k] is clled filure function, since it represents only ckwrd trnsitions, in other words, it determines where to go whenever there is mismtch in the next letter.,,, = {,,,, 2, 3} = {,,,, 2, 2, 3} = {,,2,,,2,,,2,3} Filure Function int[] pi = new int[pttern.length()]; int x = ; for(int p = ; p < pttern.length(); p++) { while(x > && pttern.chrat(x)!= pttern.chrat(p)) x = pi[x-]; } if(pttern.chrat(x) == pttern.chrat(p)) x++; pi[p] = x; Mtching x = ; for(int k = ; k < text.length(); k++) { while(x> && pttern.chrat(x)!= text.chrat(k)) x = pi[x-]; } if(pttern.chrat(x) == text.chrat(k)) x++; if(x == pttern.length()) return true; The Algorithm Theorem: At most 2N comprisons in totl Applictions DNA mtching: DNA consists of smll molecules clled nucleotides. There re four of them Adenine, Cytosine, Gunine nd Thymine. Therefore, {A, C, G, T} cretes n lphet. Protein mtching: Proteins re composed of mino cids. There re siclly 2 mino cids. Hence, protein cn e represented s string over 2 letters. 7

8 The Aho-Corsick Algorithm (986) Ptterns {he, she, his, hers} strt h e 2 r s 8 * 9 i The lgorithm preprocesses the set of ptterns. s 3 h 6 4 s e n 7 n 5 The Aho-Corsick Algorithm We still use the longest suffix rule. If we fil on mking trnsition from node N to its child, we trnsition to node M, where the string tht defines M is the frthest node (longest prefix) from the root which is lso suffix of the string we hd mtched when we filed (removing the first trnsition). The only difference is tht insted of trversing single string left-to-right we now hve to trverse trie. The Rin-Krp Algorithm (98) The lgorithm uses the ide of hshing pttern = 4848 The min ide text = We do not mtch string ginst given pttern, ut rther compre their hsh codes. The min ide pttern = 4848 % 7 = % 7 = % 7 = % 7 = 28 We red the text in the numer of chrcters equl to the length of the pttern, compute its hsh code nd compre with the pttern hsh code. 8

9 Wht is its complexity? M = pttern.length() N = text.length(); Similr to rute-force mtching The key ide of improving the lgorithm is in computing hsh code in O(). Computing hsh code How cn we get from 45 to 456? We will do this y creting chin of opertions Remove the leding digit, multiply y se, dd single digit. It tkes O() to compute hsh code from the previous vlue. Exmple Exmple Given: hsh code for mod 4 = 36 Tsk: compute hsh code for Given: hsh code for mod 4 = 36 Tsk: compute hsh code for Oserve, 7295 = (3729-3* 4 ) * + 5 Exmple 7295%4 = [(3729%4-3* 4 %4) * + 5]%4 3729%4 is lredy computed. 3* 4 % 4 will e precomputed 7295%4 = [(36-29) * + 5]%4 = 75 % 4 = 34 Rin-Krp formlized Let P[... m] e pttern nd T[... n] e text. We define pttern P = m- P[] + P[m-] + + P[m] nd shift in the text: t s = m- T[s+] + T[s+m-] + + T[s+m] The vlue t s+ cn e otined from t s y t s+ = (t s - m- T[s+]) + T[s+m+] 9

10 Horner s Rule We sid 3729%4 is lredy computed How would you compute it fst? x 4 + x 3 + c x 2 + d x + e = e + x (d + x (c + x ( + x) Implementtion pulic int serch(string T, String P){ int M = P.length(), N = T.length(); int dm =, h =, h2 = ; int p = ; /*pick it t rndom */ int d = 256; /* rdix */ for(int j = ; j < M; j++) dm = (d*dm) % p; for(int j = ; j < M; j++){ h = (h *d + P.chrAt(j)) % p; h2 = (h2*d + T.chrAt(j)) % p; } } Implementtion (cont.) if(h == h2) return ; for(int i = M; i < N; i++) { h2 = (h2 - T.chrAt(i - M) * dm) % p; h2 = (h2*d + T.chrAt(i)) % p; if(h == h2) return i - M + ; } return -; Flse mtch T == P mod q Wht do we do in cse of flse mtch? When we found mtch we cn check the mtch y chr comprison. Flse mtch Theorem. There's pttern of length M nd text of length N. Pick rndom prime [2,, M N 2 ]. The proility of getting flse mtch nywhere in the string is t most 2.53/N.