Outline

String Matching
Introduction Nave Algorithm Rabin-Karp Algorithm Knuth-Morris-Pratt (KMP) Algorithm

Introduction
What is string matching?
Finding all occurrences of a pattern in a given text (or body of text) While using editor/word processor/browser Login name & password checking Virus detection Header analysis in data communications DNA sequence analysis, Web search engines (e.g. Google), image analysis

Many applications

String-Matching Problem
The text is in an array T [1..n] of length n The pattern is in an array P [1..m] of length m Elements of T and P are characters from a finite alphabet
E.g., = {0,1} or = {a, b, , z}

Usually T and P are called strings of characters

String-Matching Problem

contd

We say that pattern P occurs with shift s in text T if:

a) 0 s n-m and b) T [(s+1)..(s+m)] = P [1..m]

If P occurs with shift s in T, then s is a valid shift, otherwise s is an invalid shift String-matching problem: finding all valid shifts for a given T and P

Example 1
1 2 3 4 5 6 7 8 9 10 11 12 13

text T

a b c a b a a b c a b a c

pattern P

s=3
a b a a
1 2 3 4

shift s = 3 is a valid shift (n=13, m=4 and 0 s n-m holds)

Example 2 3 4
3 4 5 6 7 8 9 10 11 12 13

pattern P a b a a
1 2

text T

a b c a b a a b c a b a a

s=3

a b a a

s=9

a b a a

Nave String-Matching Algorithm

Input: Text strings T [1..n] and P[1..m] Result: All valid shifts displayed NAVE-STRING-MATCHER (T, P) n length[T] m length[P] for s 0 to n-m if P[1..m] = T [(s+1)..(s+m)] print pattern occurs with shift s

Nave Algorithm

The Nave algorithm consists in checking, at all the positions in the text between 0 to n-m, whether an occurrence of the pattern starts there or not. After each attempt, it shifts the pattern by exactly one position to the right. Example (from left to right): a b c a b c a a b c a (shift = 0) a b c a (shift = 1) a b c a (shift = 2) a b c a (shift = 3)

Analysis: Worst-case Example

1 2 3 4

pattern P a a a b
1 2 3 4 5 6 7 8 9 10 11 12 13

text T

a a a a a a a a a a a a a

a a a b

a a a b

Worst-case Analysis

There are m comparisons for each shift in the worst case There are n-m+1 shifts So, the worst-case running time is ((nm+1)m)
In the example on previous slide, we have (13-4+1)4 comparisons in total

Nave method is inefficient because information from a shift is not used again

Analysis
Brute force pattern matching runs in time O(mn) in the worst case.
But most searches of ordinary text take O(m+n), which is very quick.

continued

Brute-force Analysis (Best)

Best Case
Example1: Found in first position of text
Text: 0000000000000000001 Pattern: 000 Cost = O(M)

Example2: Pattern Not found and always a mismatch on first character

Text: 0000000000000000001 Pattern: 11 Cost = O(N+M)

Nave Algorithm
Example (from right to left): a b c a b c a a b c a (shift =3) a b c a (shift = 2) a b c a (shift = 1) a b c a (shift = 0) Pattern occur with shift 0 and 3

Rabin-Karp Algorithm

Has a worst-case running time of O((nm+1)m) but average-case is O(n+m)

Also works well in practice

Based on number-theoretic notion of modular equivalence We assume that = {0,1, 2, , 9}, i.e., each character is a decimal digit
In general, use radix-d where d = ||

Rabin-Karp Approach
We can view a string of k characters (digits) as a length-k decimal number
E.g., the string 31425 corresponds to the decimal number 31,425

Given a pattern P [1..m], let p denote the corresponding decimal value Given a text T [1..n], let ts denote the decimal value of the length-m substring T [(s+1)..(s+m)] for s=0,1,,(n-m)

Rabin-Karp Approach

contd

ts = p iff T [(s+1)..(s+m)] = P [1..m] s is a valid shift iff ts = p p can be computed in O(m) time
p = P[m] + 10 (P[m-1] + 10 (P[m-2]+))

t0 can similarly be computed in O(m) time Other t1, t2,, tn-m can be computed in O(nm) time since ts+1 can be computed from ts in constant time

Rabin-Karp Approach

contd

ts+1 = 10(ts - 10m-1 T [s+1]) + T [s+m+1]

E.g., if T={,3,1,4,1,5,2,}, m=5 and ts= 31,415, then ts+1 = 10(31415 100003) + 2 =14152 Thus we can compute p in (m) and can compute t0, t1, t2,, tn-m in (n-m+1) time And we can find al occurrences of the pattern P[1m] in text T[1n] with (m) preprocessing time and (n-m+1) matching time.

Buta problem: this is assuming p and ts are small numbers They may be too large to work with easily

Rabin-Karp Approach

contd

Solution: we can use modular arithmetic with a suitable modulus, q

E.g., ts+1 (10(ts T[s+1]h) + T [s+m+1]) (mod q) Where h =10 m-1 (mod q)

q is chosen as a small prime number ; e.g., 13 for radix 10

Generally, if the radix is d, then dq should fit within one computer word

How values modulo 13 are computed

3 1 4 1 5 2

old highorder digit

new loworder digit

14152 ((31415 3 10000) 10 + 2 )(mod 13)

((7 3 3) 10 + 2 )(mod 13)

8 (mod 13)

Problem of Spurious Hits

ts p (mod q) does not imply that ts=p
Modular equivalence does not necessarily mean that two integers are equal

A case in which ts p (mod q) when ts p is called a spurious hit On the other hand, if two integers are not modular equivalent, then they cannot be equal

Example
3 1 4 1 5 pattern

mod 13
7
1 2 3 4 5 6 7 8

text
9 10 11 12 13 14

2 3 1 4 1 5 2 6 7 3 9 9 2 1 mod 13 1 7 8 4 5 10 11 7 9 11 valid spurious match hit

Rabin-Karp Algorithm

Basic structure like the nave algorithm, but uses modular arithmetic as described For each hit, i.e., for each s where ts p (mod q), verify character by character whether s is a valid shift or a spurious hit In the worst case, every shift is verified
Running time can be shown as O((n-m+1)m)

Average-case running time is O(n+m)

Example 2
Let T = a b c b a b and P = a b c Take a = 97, b = 98, c= 99 (i.e. ASCII value of characters). = 256. Integer value of P, p = c + 256(b+256 a) = [99 + 256(98+256 97)] % 256 =197 In similar fashion, we can calculate hash value of m-length text and compare to check valid / spurious hit (as in previous slides). Analysis In the worst case, every shift is verified Running time can be shown as O((n-m+1)m) Average-case running time is O (n + m)

3. The KMP Algorithm

The Knuth-Morris-Pratt (KMP) algorithm looks for the pattern in the text in a left-toright order (like the brute force algorithm).
But it shifts the pattern more intelligently than the brute force algorithm.

continued

 If a mismatch occurs between the text and pattern P at P[j], what is the most we can shift the pattern to avoid wasteful comparisons?
Answer: the largest prefix of P[0 .. j-1] that is a suffix of P[1 .. j-1]

Example
T: P:

j=5
jnew = 2

Why

j == 5

Find largest prefix (start) of: "a b a a b" ( P[0..j-1] ) which is suffix (end) of: "b a a b" ( p[1 .. j-1] )
Answer: "a b" Set j = 2 // the new j value

KMP Failure Function

KMP preprocesses the pattern to find matches of prefixes of the pattern with the pattern itself. j = mismatch position in P[] k = position before the mismatch (k = j-1). The failure function F(k) is defined as the size of the largest prefix of P[0..k] that is also a suffix of P[1..k].

Failure Function Example

P: "abaaba" j: 012345
j F(j) 0 0 1 0 2 1

(k == j-1)
3 1 4 2

F(k) is the size of the largest prefix.

In code, F() is represented by an array, like the table.

P: "abaaba" Why is F(4) == 2?

F(4) means
find the size of the largest prefix of P[0..4] that is also a suffix of P[1..4] = find the size largest prefix of "abaab" that is also a suffix of "baab" = find the size of "ab" =2

Using the Failure Function

Knuth-Morris-Pratts algorithm modifies the brute-force algorithm.
if a mismatch occurs at P[j] (i.e. P[j] != T[i]), then k = j-1; j = F(k); // obtain the new j

Example
T: P:
a b a c a a b a c c a b a c a b a a b b
1 2 3 4 5 6

a b a c a b
7

a b a c a b
8 9 10 11 12

a b a c a b
13

a b a c a b

k
F(k

0 0

1 0

2 1

3 0

4 1

14 15 16 17 18 19

a b a c a b

P: "abacab" Why is F(4) == 1?

F(4) means
find the size of the largest prefix of P[0..4] that is also a suffix of P[1..4] = find the size largest prefix of "abaca" that is also a suffix of "baca" = find the size of "a" =1

KMP Advantages
KMP runs in optimal time: O(m+n)
very fast

The algorithm never needs to move backwards in the input text, T

this makes the algorithm good for processing very large files that are read in from external devices or through a network stream

KMP Disadvantages
KMP doesnt work so well as the size of the alphabet increases
more chance of a mismatch (more possible mismatches) mismatches tend to occur early in the pattern, but KMP is faster when the mismatches occur later