SUBSTRING SEARCH BBM ALGORITHMS DEPT. OF COMPUTER ENGINEERING

Transcription

1 BBM LGORITHMS DEPT. OF OMPUTER ENGINEERING SUBSTRING SERH cknowledgement: The course slides are adapted from the slides prepared by R. Sedgewick and K. Wayne of Princeton University. 1

2 TODY Substring search Brute force Knuth-Morris-Pratt Boyer-Moore Rabin-Karp 2

3 Substring search Goal. Find pattern of length M in a text of length N. typically N >> M pattern text N E E D L E I N H Y S T K N E E D L E I N match 3 3

4 Substring search applications Goal. Find pattern of length M in a text of length N. typically N >> M pattern N E E D L E text I N H Y S T K N E E D L E I N match Substring search omputer forensics. Search memory or disk for signatures, e.g., all URLs or RS keys that the user has entered

5 Substring search applications Goal. Find pattern of length M in a text of length N. typically N >> M pattern text N E E D L E I N H Y S T K N E E D L E I N match Identify patterns indicative of spam. PROFITS L0SE WE1GHT There is no catch. This is a one-time mailing. This message is sent in compliance with spam regulations. 5 5

6 Substring search applications Electronic surveillance. Need to monitor all internet traffic. (security) No way! (privacy) Well, we re mainly interested in TTK T DWN OK. Build a machine that just looks for that. TTK T DWN substring search machine found 6 6

7 Substring search applications Screen scraping. Extract relevant data from web page. Ex. Find string delimited by <b> and </b> after first occurrence of pattern Last Trade:. <tr> <td class= "yfnc_tablehead1" width= "48%"> Last Trade: </td> <td class= "yfnc_tabledata1"> <big><b>452.92</b></big> </td></tr> <td class= "yfnc_tablehead1" width= "48%"> Trade Time: </td> <td class= "yfnc_tabledata1">

8 Screen scraping: Java implementation Java library. The indexof() method in Java's string library returns the index of the first occurrence of a given string, starting at a given offset. public class StockQuote { public static void main(string[] args) { String name = " In in = new In(name + args[0]); String text = in.readll(); int start = text.indexof("last Trade:", 0); int from = text.indexof("<b>", start); int to = text.indexof("</b>", from); String price = text.substring(from + 3, to); StdOut.println(price); } } % java StockQuote goog % java StockQuote msft

9 Brute force Knuth-Morris-Pratt Boyer-Moore Rabin-Karp SUBSTRING SERH 9

10 Brute-force substring search heck for pattern starting at each text position. i j i+j txt B D B R B R pat B R entries in red are mismatches B R B R entries in gray are for reference only B R entries in black match the text B R B R return i when j is M match 10 10

11 Brute-force substring search: Java implementation heck for pattern starting at each text position. i j i+j B D B R D R D R public static int search(string pat, String txt) { int M = pat.length(); int N = txt.length(); for (int i = 0; i <= N - M; i++) { int j; } for (j = 0; j < M; j++) if (txt.chart(i+j)!= pat.chart(j)) break; index in text where if (j == M) return i; pattern starts } return N; not found 11 11

12 Brute-force substring search: worst case Brute-force algorithm can be slow if text and pattern are repetitive. i j i+j txt B B pat B B B B B Brute-force substring search (worst case) match Worst case. ~ M N char compares

13 Backup In many applications, we want to avoid backup in text stream. Treat input as stream of data. bstract model: standard input. Brute-force algorithm needs backup for every mismatch. matched chars backup pproach 1. Maintain buffer of last M characters. B pproach 2. Stay tuned. TTK T DWN substring search machine found B shift pattern right one position B mismatch B 13 13

14 Brute-force substring search: alternate implementation Same sequence of char compares as previous implementation. i points to end of sequence of already-matched chars in text. j stores number of already-matched chars (end of sequence in pattern). i j B D B R 7 3 D R 5 0 D R public static int search(string pat, String txt) { int i, N = txt.length(); int j, M = pat.length(); for (i = 0, j = 0; i < N && j < M; i++) { if (txt.chart(i) == pat.chart(j)) j++; else { i -= j; j = 0; } } if (j == M) return i - M; } else return N; backup 14 14

15 lgorithmic challenges in substring search Brute-force is not always good enough. Theoretical challenge. Linear-time guarantee. Practical challenge. void backup in text stream. fundamental algorithmic problem often no room or time to save text Now is the time for all people to come to the aid of their party. Now is the time for all good people to come to the aid of their party. Now is the time for many good people to come to the aid of their party. Now is the time for all good people to come to the aid of their party. Now is the time for a lot of good people to come to the aid of their party. Now is the time for all of the good people to come to the aid of their party. Now is the time for all good people to come to the aid of their party. Now is the time for each good person to come to the aid of their party. Now is the time for all good people to come to the aid of their party. Now is the time for all good Republicans to come to the aid of their party. Now is the time for all good people to come to the aid of their party. Now is the time for many or all good people to come to the aid of their party. Now is the time for all good people to come to the aid of their party. Now is the time for all good Democrats to come to the aid of their party. Now is the time for all people to come to the aid of their party. Now is the time for all good people to come to the aid of their party. Now is the time for many good people to come to the aid of their party. Now is the time for all good people to come to the aid of their party. Now is the time for a lot of good people to come to the aid of their party. Now is the time for all of the good people to come to the aid of their party. Now is the time for all good people to come to the aid of their attack at dawn party. Now is the time for each person to come to the aid of their party. Now is the time for all good people to come to the aid of their party. Now is the time for all good Republicans to come to the aid of their party. Now is the time for all good people to come to the aid of their party. Now is the time for many or all good people to come to the aid of their party. Now is the time for all good people to come to the aid of their party. Now is the time for all good Democrats to come to the aid of their party

16 Brute force Knuth-Morris-Pratt Boyer-Moore Rabin-Karp SUBSTRING SERH 16

17 Knuth-Morris-Pratt substring search Intuition. Suppose we are searching in text for pattern B. Suppose we match 5 chars in pattern, with mismatch on 6 th char. We know previous 6 chars in text are BB. Don't need to back up text pointer! text after mismatch on sixth char brute-force backs up to try this B B B and this and this B and this but no backup is needed i B and this assuming {, B } alphabet pattern B B B B Knuth-Morris-Pratt algorithm. lever method to always avoid backup. (!) 17 17

18 Deterministic finite state automaton (DF) DF is abstract string-searching machine. Finite number of states (including start and halt). Exactly one transition for each char in alphabet. ccept if sequence of transitions leads to halt state. internal representation j pat.chart(j) dfa[][j] B B B If in state j reading char c: if j is 6 halt and accept else move to state dfa[c][j] graphical representation B, B 0 1 B 2 3 B B, B, 18 18

19 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, B, 19 19

20 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, B, 20 20

21 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, B, 21 21

22 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, B, 22 22

23 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, B, 23 23

24 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, B, 24 24

25 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, B, 25 25

26 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, B, 26 26

27 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, B, 27 27

28 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, B, 28 28

29 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, B, 29 29

30 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, B, 30 30

31 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, B, 31 31

32 DF simulation B B B pat.chart(j) dfa[][j] B B B B, B 0 1 B 2 3 B B, substring found B, 32 32

33 Interpretation of Knuth-Morris-Pratt DF Q. What is interpretation of DF state after reading in txt[i]?. State = number of characters in pattern that have been matched. Ex. DF is in state 3 after reading in txt[0..6]. length of longest prefix of pat[] that is a suffix of txt[0..i] i txt B B B suffix of text[0..6] pat B B prefix of pat[] B, B 0 1 B 2 3 B B, B, 33 33

34 Knuth-Morris-Pratt substring search: Java implementation Key differences from brute-force implementation. Need to precompute dfa[][] from pattern. Text pointer i never decrements. public int search(string txt) { int i, j, N = txt.length(); } for (i = 0, j = 0; i < N && j < M; i++) j = dfa[txt.chart(i)][j]; if (j == M) return i - M; else return N; Running time. Simulate DF on text: at most N character accesses. Build DF: how to do efficiently? [warning: tricky algorithm ahead] no backup 34 34

35 Knuth-Morris-Pratt substring search: Java implementation Key differences from brute-force implementation. Need to precompute dfa[][] from pattern. Text pointer i never decrements. ould use input stream. public int search(in in) { int i, j; } for (i = 0, j = 0;!in.isEmpty() && j < M; i++) j = dfa[in.readhar()][j]; if (j == M) return i - M; else return NOT_FOUND; no backup B, B 0 1 B 2 3 B B, B, 35 35

36 Knuth-Morris-Pratt construction Include one state for each character in pattern (plus accept state). pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B

37 Knuth-Morris-Pratt construction Match transition. If in state j and next char c == pat.chart(j), go to j+1. first j characters of pattern have already been matched next char matches now first j+1 characters of pattern have been matched pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B 0 1 B 2 3 B

38 Knuth-Morris-Pratt construction Mismatch transition: back up if c!= pat.chart(j). pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, j 0 1 B 2 3 B

39 Knuth-Morris-Pratt construction Mismatch transition: back up if c!= pat.chart(j). pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, j 0 1 B 2 3 B

40 Knuth-Morris-Pratt construction Mismatch transition: back up if c!= pat.chart(j). pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, j 0 1 B 2 3 B B, 40 40

41 Knuth-Morris-Pratt construction Mismatch transition: back up if c!= pat.chart(j). pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, j 0 1 B 2 3 B B, 41 41

42 Knuth-Morris-Pratt construction Mismatch transition: back up if c!= pat.chart(j). pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, j 0 1 B 2 3 B B, B, 42 42

43 Knuth-Morris-Pratt construction Mismatch transition: back up if c!= pat.chart(j). pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, B j 0 1 B 2 3 B B, B, 43 43

44 Knuth-Morris-Pratt construction pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, B 0 1 B 2 3 B B, B, 44 44

45 How to build DF from pattern? Include one state for each character in pattern (plus accept state). pat.chart(j) dfa[][j] B B B

46 How to build DF from pattern? Match transition. If in state j and next char c == pat.chart(j), go to j+1. first j characters of pattern have already been matched next char matches now first j+1 characters of pattern have been matched pat.chart(j) dfa[][j] B B B B 2 3 B

47 How to build DF from pattern? Mismatch transition. If in state j and next char c!= pat.chart(j), then the last j-1 characters of input are pat[1..j-1], followed by c. To compute dfa[c][j]: Simulate pat[1..j-1] on DF and take transition c. Running time. Seems to require j steps. still under construction (!) Ex. dfa[''][5] = 1; dfa['b'][5] = 4 simulate BB; simulate BB; take transition '' take transition 'B' = dfa[''][3] = dfa['b'][3] j pat.chart(j) B B simulation B, of BB B j 0 1 B 2 3 B B, B, 47 47

48 How to build DF from pattern? Mismatch transition. If in state j and next char c!= pat.chart(j), then the last j-1 characters of input are pat[1..j-1], followed by c. state X To compute dfa[c][j]: Simulate pat[1..j-1] on DF and take transition c. Running time. Takes only constant time if we maintain state X. Ex. dfa[''][5] = 1; dfa['b'][5] = 4; from state X, from state X, take transition '' take transition 'B' = dfa[''][x] = dfa['b'][x] X'= 0 from state X, take transition '' = dfa[''][x] B B B, X B j 0 1 B 2 3 B B, B, 48 48

49 Knuth-Morris-Pratt construction (in linear time) Include one state for each character in pattern (plus accept state). pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B

50 Knuth-Morris-Pratt construction (in linear time) Match transition. For each state j, dfa[pat.chart(j)][j] = j+1. first j characters of pattern have already been matched now first j+1 characters of pattern have been matched pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B 0 1 B 2 3 B

51 Knuth-Morris-Pratt construction (in linear time) Mismatch transition. For state 0 and char c!= pat.chart(j), set dfa[c][0] = 0. pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, j 0 1 B 2 3 B

52 Knuth-Morris-Pratt construction (in linear time) Mismatch transition. For each state j and char c!= pat.chart(j), set dfa[c][j] = dfa[c][x]; then update X = dfa[pat.chart(j)][x]. X = simulation of empty string pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, j 0 1 B 2 3 B X 52 52

53 Knuth-Morris-Pratt construction (in linear time) Mismatch transition. For each state j and char c!= pat.chart(j), set dfa[c][j] = dfa[c][x]; then update X = dfa[pat.chart(j)][x]. X = simulation of B pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, j X 0 1 B 2 3 B B, 53 53

54 Knuth-Morris-Pratt construction (in linear time) Mismatch transition. For each state j and char c!= pat.chart(j), set dfa[c][j] = dfa[c][x]; then update X = dfa[pat.chart(j)][x]. X = simulation of B pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, j 0 1 B 2 3 B X B, 54 54

55 Knuth-Morris-Pratt construction (in linear time) Mismatch transition. For each state j and char c!= pat.chart(j), set dfa[c][j] = dfa[c][x]; then update X = dfa[pat.chart(j)][x]. X = simulation of B B pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, j 0 1 B 2 3 B X B, B, 55 55

56 Knuth-Morris-Pratt construction (in linear time) Mismatch transition. For each state j and char c!= pat.chart(j), set dfa[c][j] = dfa[c][x]; then update X = dfa[pat.chart(j)][x]. X = simulation of B B pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, j B 0 1 B 2 3 B X B, B, 56 56

57 Knuth-Morris-Pratt construction (in linear time) Mismatch transition. For each state j and char c!= pat.chart(j), set dfa[c][j] = dfa[c][x]; then update X = dfa[pat.chart(j)][x]. X = simulation of B B pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B X B, B 0 1 B 2 3 B B, j B, 57 57

58 Knuth-Morris-Pratt construction (in linear time) pat.chart(j) dfa[][j] B B B onstructing the DF for KMP substring search for B B B, B 0 1 B 2 3 B B, B, 58 58

59 onstructing the DF for KMP substring search: Java implementation For each state j: opy dfa[][x] to dfa[][j] for mismatch case. Set dfa[pat.chart(j)][j] to j+1 for match case. Update X. public KMP(String pat) { this.pat = pat; M = pat.length(); dfa = new int[r][m]; dfa[pat.chart(0)][0] = 1; for (int X = 0, j = 1; j < M; j++) { for (int c = 0; c < R; c++) dfa[c][j] = dfa[c][x]; dfa[pat.chart(j)][j] = j+1; X = dfa[pat.chart(j)][x]; } } copy mismatch cases set match case update restart state Running time. M character accesses (but space proportional to R M)

60 KMP substring search analysis Proposition. KMP substring search accesses no more than M + N chars to search for a pattern of length M in a text of length N. Pf. Each pattern char accessed once when constructing the DF; each text char accessed once (in the worst case) when simulating the DF. Proposition. KMP constructs dfa[][] in time and space proportional to R M. Larger alphabets. Improved version of KMP constructs nfa[] in time and space proportional to M. 0 1 B 2 3 B KMP NF for BB 60 60

61 Knuth-Morris-Pratt: brief history Independently discovered by two theoreticians and a hacker. - Knuth: inspired by esoteric theorem, discovered linear-time algorithm - Pratt: made running time independent of alphabet size - Morris: built a text editor for the D 6400 computer Theory meets practice. SIM J. OMPUT. Vol. 6, No. 2, June 1977 FST PTTERN MTHING IN STRINGS* DONLD E. KNUTHf, JMES H. MORRIS, JR.:l: ND VUGHN R. PRTT bstract. n algorithm is presented which finds all occurrences of one. given string within another, in running time proportional to the sum of the lengths of the strings. The constant of proportionality is low enough to make this algorithm of practical use, and the procedure can also be extended to deal with some more general pattern-matching problems. theoretical application of the algorithm shows that the set of concatenations of even palindromes, i.e., the language {can}*, can be recognized in linear time. Other algorithms which run even faster on the average are also considered. Don Knuth Jim Morris Vaughan Pratt 61 61

62 Brute force Knuth-Morris-Pratt Boyer-Moore Rabin-Karp SUBSTRING SERH 62

63 Boyer Moore Intuition Scan the text with a window of M chars (length of pattern) Pattern in Text (M) Text Scan Window (M) ase 1: Scan Window is exactly on top of the searched pattern - Starting from one end check if all characters are equal. (We must check!) ase 2: Scan Window starts after the pattern starts

64 Boyer Moore Intuition (2) ase 3: Scan Window starts before the pattern starts ase 4: Independent In case 4, simply shift window M characters void ase 2 onvert ase 3 to ase 1, by shifting appropriately 64 64

65 Boyer Moore Intuition (3) If we can recognise the character in the scan window end-point, we can find how many characters to shift. B D E F G H So, for example D is the 4th character, we must shift window 4 characters so that they overlap. d = 4 d = 4 B D E F G H 65 65

66 Boyer Moore Intuition (4) potential problem, the character in the text can repeat. For example, pattern = XXXX and the text is X X X X X X X X X X X Solution: be conservative, choose the instance with the least Shift (so we cannot miss the others)

67 Boyer Moore Intuition (5) X X X X X X X X X X X Search: XXXX So, for the example when it is at the endpoint we must shift for 2 characters. text: X we have a mismatch in last, now we must shift only once, so that we can check the configuration where the we found moves to middle. text: YXX we have a mismatch in Y, now we must shift 3 times as we know that the last 2 characters are in pattern and they can be repeating in the first 3 characters

68 Boyer-Moore: mismatched character heuristic Intuition. Scan characters in pattern from right to left. an skip as many as M text chars when finding one not in the pattern. - First we check the character in index pattern.length()-1 - It is N which is not E, so we know that first 5 characters is not a match. Shift text 5 characters - S!= E so shift 5, E == E so we can check for the pattern.length()-2, L!=N, skip 4. i text j F I N D I N H Y S T K N E E D L E I N 0 5 N E E D L E pattern 5 5 N E E D L E 11 4 N E E D L E 15 0 N E E D L E return i = 15 Mismatched character heuristic for right-to-left (Boyer-Moore) substring search 68 68

69 Boyer-Moore: mismatched character heuristic Q. How much to skip? ase 1. Mismatch character not in pattern. before i txt pat T L E N E E D L E i after txt pat T L E N E E D L E mismatch character 'T' not in pattern: increment i one character beyond 'T' 69 69

70 Boyer-Moore: mismatched character heuristic Q. How much to skip? ase 2a. Mismatch character in pattern. before i txt pat N L E N E E D L E after txt pat i N L E N E E D L E mismatch character 'N' in pattern: align text 'N' with rightmost pattern 'N' 70 70

71 Boyer-Moore: mismatched character heuristic Q. How much to skip? ase 2b. Mismatch character in pattern (but heuristic no help). before i txt pat E L E N E E D L E i aligned with rightmost E? txt pat E L E N E E D L E mismatch character 'E' in pattern: align text 'E' with rightmost pattern 'E'? 71 71

72 Boyer-Moore: mismatched character heuristic Q. How much to skip? ase 2b. Mismatch character in pattern (but heuristic no help). before i txt pat E L E N E E D L E i after txt pat E L E N E E D L E mismatch character 'E' in pattern: increment i by

73 Boyer-Moore: mismatched character heuristic Q. How much to skip?. Precompute index of rightmost occurrence of character c in pattern (-1 if character not in pattern). right = new int[r]; for (int c = 0; c < R; c++) right[c] = -1; for (int j = 0; j < M; j++) right[pat.chart(j)] = j; N E E D L E c right[c] B D E L M N Boyer-Moore skip table computation 73 73

74 Boyer-Moore: Java implementation } public int search(string txt) { int N = txt.length(); int M = pat.length(); int skip; for (int i = 0; i <= N-M; i += skip) { skip = 0; for (int j = M-1; j >= 0; j--) { if (pat.chart(j)!= txt.chart(i+j)) { skip = Math.max(1, j - right[txt.chart(i+j)]); break; } in case other term is nonpositive } if (skip == 0) return i; } return N; compute skip value match 74 74

75 nother Example SERH FOR: XXXX X X X X X X X X X X X If the window scan points to an unrecognised character, we can skip past that character. For this example, for the initial step we first match X at the end, when check for previous character () which is not in the string we skip 3 steps. The X at the end, we matched can still be the first character of the pattern, so we do not skip that

76 Boyer-Moore: analysis Property. Substring search with the Boyer-Moore mismatched character heuristic takes about ~ N / M character compares to search for a pattern of length M in a text of length N. Worst-case. an be as bad as ~ M N. sublinear! i skip txt B B B B B B B B B B 0 0 B B B B 1 1 B B B B 2 1 B B B B 3 1 B B B B 4 1 B B B B 5 1 B B B B Boyer-Moore-Horspool substring search (worst case) Boyer-Moore variant. an improve worst case to ~ 3 N by adding a KMP-like rule to guard against repetitive patterns. pat 76 76

77 Brute force Knuth-Morris-Pratt Boyer-Moore Rabin-Karp SUBSTRING SERH 77

78 Rabin-Karp fingerprint search Basic idea = modular hashing. ompute a hash of pattern characters 0 to M - 1. For each i, compute a hash of text characters i to M + i - 1. If pattern hash = text substring hash, check for a match. pat.chart(i) i % 997 = 613 txt.chart(i) i % 997 = % 997 = % 997 = % 997 = % 997 = % 997 = 929 match 6 return i = % 997 = 613 Basis for Rabin-Karp substring search 78 78

79 Efficiently computing the hash function Modular hash function. Using the notation t i for txt.chart(i), we wish to compute xi = ti R M-1 + ti+1 R M ti+m-1 R 0 (mod Q) Intuition. M-digit, base-r integer, modulo Q. Horner's method. Linear-time method to evaluate degree-m polynomial. pat.chart() i % 997 = 2 R Q % 997 = (2*10 + 6) % 997 = % 997 = (26*10 + 5) % 997 = % 997 = (265*10 + 3) % 997 = % 997 = (659*10 + 5) % 997 = 613 // ompute hash for M-digit key private long hash(string key, int M) { long h = 0; for (int j = 0; j < M; j++) h = (R * h + key.chart(j)) % Q; return h; } 79 79

80 Efficiently computing the hash function hallenge. How to efficiently compute x i+1 given that we know x i. xi = ti R M 1 + ti+1 R M ti+m 1 R 0 xi+1 = ti+1 R M 1 + ti+2 R M ti+m R 0 Key property. an update hash function in constant time! xi+1 = ( xi t i R M 1 ) R + t i +M current value subtract leading digit multiply by radix add new trailing digit (can precompute R M 2 ) i current value new value text * current value subtract leading digit multiply by radix add new trailing digit new value 80 80

81 Rabin-Karp substring search example i % 997 = 3 Q % 997 = (3*10 + 1) % 997 = % 997 = (31*10 + 4) % 997 = % 997 = (314*10 + 1) % 997 = % 997 = (150*10 + 5) % 997 = 508 RM R % 997 = (( *(997-30))*10 + 9) % 997 = % 997 = (( *(997-30))*10 + 2) % 997 = % 997 = (( *(997-30))*10 + 6) % 997 = % 997 = (( *(997-30))*10 + 5) % 997 = 442 match % 997 = (( *(997-30))*10 + 3) % 997 = % 997 = (( *(997-30))*10 + 5) % 997 = 613 return i-m+1 = 6 Rabin-Karp substring search example 81 81

82 Rabin-Karp: Java implementation public class RabinKarp { private long pathash; private int M; private long Q; private int R; private long RM; // pattern hash value // pattern length // modulus // radix // R^(M-1) % Q public RabinKarp(String pat) { M = pat.length(); R = 256; Q = longrandomprime(); } RM = 1; for (int i = 1; i <= M-1; i++) RM = (R * RM) % Q; pathash = hash(pat, M); a large prime (but avoid overflow) precompute R M 1 (mod Q) private long hash(string key, int M) { /* as before */ } } public int search(string txt) { /* see next slide */ } 82 82

83 Rabin-Karp: Java implementation (continued) Monte arlo version. Return match if hash match. public int search(string txt) check for hash collision { int N = txt.length(); using rolling hash function int txthash = hash(txt, M); if (pathash == txthash) return 0; for (int i = M; i < N; i++) { txthash = (txthash + Q - RM*txt.chart(i-M) % Q) % Q; txthash = (txthash*r + txt.chart(i)) % Q; if (pathash == txthash) return i - M + 1; } return N; } Las Vegas version. heck for substring match if hash match; continue search if false collision

84 Rabin-Karp analysis Theory. If Q is a sufficiently large random prime (about M N 2 ), then the probability of a false collision is about 1 / N. Practice. hoose Q to be a large prime (but not so large as to cause overflow). Under reasonable assumptions, probability of a collision is about 1 / Q. Monte arlo version. lways runs in linear time. Extremely likely to return correct answer (but not always!). Las Vegas version. lways returns correct answer. Extremely likely to run in linear time (but worst case is M N)

85 Rabin-Karp fingerprint search dvantages. Extends to 2d patterns. Extends to finding multiple patterns. Disadvantages. rithmetic ops slower than char compares. Las Vegas version requires backup. Poor worst-case guarantee

86 Substring search cost summary ost of searching for an M-character pattern in an N-character text. algorithm version operation count guarantee typical backup in input? correct? extra space brute force M N 1.1 N yes yes 1 Knuth-Morris-Pratt full DF (lgorithm 5.6 ) mismatch transitions only 2 N 1.1 N no yes MR 3 N 1.1 N no yes M full algorithm 3 N N / M yes yes R Boyer-Moore mismatched char heuristic only (lgorithm 5.7 ) M N N / M yes yes R Rabin-Karp Monte arlo (lgorithm 5.8 ) 7 N 7 N no yes 1 Las Vegas 7 N 7 N no yes yes 1 probabilisitic guarantee, with uniform hash function 86 86