2.

Exact String Matching

Let T = T [0..n) be the text and P = P [0..m) the pattern. We say that P
occurs in T at position j if T [j..j + m) = P .

Example: P = aine occurs at position 6 in T = karjalainen.

In this part, we will describe algorithms that solve the following problem.

Problem 2.1: Given text T [0..n) and pattern P [0..m), report the first
position in T where P occurs, or n if P does not occur in T .

The algorithms can be easily modified to solve the following problems too.

• Existence: Is P a factor of T ?

• Counting: Count the number of occurrences of P in T .

• Listing: Report all occurrences of P in T .

74
The naive, brute force algorithm compares P against T [0..m), then against
T [1..1 + m), then against T [2..2 + m) etc. until an occurrence is found or
the end of the text is reached. The text factor T [j..j + m) that is currently
being compared against the pattern is called the text window.

Algorithm 2.2: Brute force

Input: text T = T [0 . . . n), pattern P = P [0 . . . m)
Output: position of the first occurrence of P in T
(1) i ← 0; j ← 0
(2) while i < m and j < n do
(3) if P [i] = T [j] then i ← i + 1; j ← j + 1
(4) else j ← j − i + 1; i ← 0
(5) if i = m then return j − m else return n

The worst case time complexity is O(mn). This happens, for example, when
P = am−1 b = aaa..ab and T = an = aaaaaa..aa.

75
(Knuth–)Morris–Pratt

The Brute force algorithm forgets everything when it shifts the window.

The Morris–Pratt (MP) algorithm remembers matches. It never goes back

to a text character that already matched.

The Knuth–Morris–Pratt (KMP) algorithm remembers mismatches too.

Example 2.3:
Brute force Morris–Pratt Knuth–Morris–Pratt
ainaisesti-ainainen ainaisesti-ainainen ainaisesti-ainainen
ainai//nen (6 comp.) nen (6)
ainai// nen (6)
ainai//
ainainen (1)
// nainen (1)
ai// ainainen (1)
//
ainainen (1)
/ ainainen (1)
//
nainen (3)
ai//
/inainen (1)
a
ainainen (1)
//

76
MP and KMP algorithms never go backwards in the text. When they
encounter a mismatch, they find another pattern position to compare
against the same text position. If the mismatch occurs at pattern position i,
then f ail[i] is the next pattern position to compare.
The only difference between MP and KMP is how they compute the failure
function f ail.
Algorithm 2.4: Knuth–Morris–Pratt / Morris–Pratt
Input: text T = T [0 . . . n), pattern P = P [0 . . . m)
Output: position of the first occurrence of P in T
(1) compute f ail[0..m]
(2) i ← 0; j ← 0
(3) while i < m and j < n do
(4) if i = −1 or P [i] = T [j] then i ← i + 1; j ← j + 1
(5) else i ← f ail[i]
(6) if i = m then return j − m else return n

• f ail[i] = −1 means that there is no more pattern positions to compare

against this text positions and we should move to the next text position.

• f ail[m] is never needed here, but if we wanted to find all occurrences, it

would tell how to continue after a full match.
77
We will describe the MP failure function here. The KMP failure function is
left for the exercises.

• When the algorithm finds a mismatch between P [i] and T [j], we know
that P [0..i) = T [j − i..j).
• Now we want to find a new i0 < i such that P [0..i0) = T [j − i0..j).
Specifically, we want the largest such i0 .
• This means that P [0..i0) = T [j − i0..j) = P [i − i0..i). In other words,
P [0..i0 ) is the longest proper border of P [0..i).

Example: ai is the longest proper border of ainai.

• Thus f ail[i] is the length of the longest proper border of P [0..i).

• P [0..0) = ε has no proper border. We set f ail[0] = −1.

78
Example 2.5: Let P = ainainen. i P [0..i) border f ail[i]
0 ε – -1
1 a ε 0
2 ai ε 0
3 ain ε 0
4 aina a 1
5 ainai ai 2
6 ainain ain 3
7 ainaine ε 0
8 ainainen ε 0

The (K)MP algorithm operates like an automaton, since it never moves

backwards in the text. Indeed, it can be described by an automaton that
has a special failure transition, which is an ε-transition that can be taken
only when there is no other transition to take.

Σ a i n a i n e n
-1 0 1 2 3 4 5 6 7 8

79
An efficient algorithm for computing the failure function is very similar to
the search algorithm itself!

• In the MP algorithm, when we find a match P [i] = T [j], we know that

P [0..i] = T [j − i..j]. More specifically, P [0..i] is the longest prefix of P
that matches a suffix of T [0..j].
• Suppose T = #P [1..m), where # is a symbol that does not occur in P .
Finding a match P [i] = T [j], we know that P [0..i] is the longest prefix
of P that is a proper suffix of T [0..j]. Thus f ail[j + 1] = i + 1.

Algorithm 2.6: Morris–Pratt failure function computation

Input: pattern P = P [0 . . . m)
Output: array f ail[0..m] for P
(1) i ← −1; j ← 0; f ail[j] ← i
(2) while j < m do
(3) if i = −1 or P [i] = P [j] then i ← i + 1; j ← j + 1; f ail[j] ← i
(4) else i ← f ail[i]
(5) return f ail

• When the algorithm reads f ail[i] on line 4, f ail[i] has already been
computed.

80
Theorem 2.7: Algorithms MP and KMP preprocess a pattern in time O(m)
and then search the text in time O(n) in the general alphabet model.

Proof. We show that the text search requires O(n) time. Exactly the same
argument shows that pattern preprocessing needs O(m) time.

It is sufficient to count the number of comparisons that the algorithms

make. After each comparison P [i] vs. T [j], one of the two conditional
branches is executed:

then Here j is incremented. Since j never decreases, this branch can be

taken at most n + 1 times.

else Here i decreases since f ail[i] < i. Since i only increases in the
then-branch, this branch cannot be taken more often than the
then-branch.


81
Shift-And (Shift-Or)
When the MP algorithm is at position j in the text T , it computes the
longest prefix of the pattern P [0..m) that is a suffix of T [0..j]. The
Shift-And algorithm computes all prefixes of P that are suffixes of T [0..j].

• The information is stored in a bitvector D of length m, where D.i = 1 if

P [0..i] = T [j − i..j] and D.i = 0 otherwise. (D.0 is the least significant
bit.)

• When D.(m − 1) = 1, we have found an occurrence.

The bitvector D is updated at each text position j:

• There are precomputed bitvectors B[c], for all c ∈ Σ, where B[c].i = 1 if

P [i] = c and B[c].i = 0 otherwise.

• D is updated in two steps:

1. D ← (D << 1) | 1 (the bitwise shift and the bitwise or). Now D tells,
which prefixes would match if T [j] would match every character.
2. D ← D & B[T [j]] (the bitwise and). Remove the prefixes where T [j]
does not match.
82
Let w be the wordsize in the word RAM model. Assume first that m ≤ w.
Then each bitvector can be stored in a single integer and the bitwise
operations can be executed in constant time.
Algorithm 2.8: Shift-And
Input: text T = T [0 . . . n), pattern P = P [0 . . . m)
Output: position of the first occurrence of P in T
Preprocess:
(1) for c ∈ Σ do B[c] ← 0
(2) for i ← 0 to m − 1 do B[P [i]] ← B[P [i]] + 2i // B[P [i]].i ← 1
Search:
(3) D ← 0
(4) for j ← 0 to n − 1 do
(5) D ← ((D << 1) | 1) & B[T [j]]
(6) if D & 2m−1 6= 0 then return j − m + 1 // D.(m − 1) = 1
(7) return n
Shift-Or is a minor optimization of Shift-And. It is the same algorithm
except the roles of 0’s and 1’s in the bitvectors have been swapped. Then
line 5 becomes D ← (D << 1) | B[T [j]]. Note that the “ | 1” was removed,
because the shift already brings the correct bit to the least significant bit
position.
83
Example 2.9: P = assi, T = apassi, bitvectors are columns.

B[c], c ∈ {a,i,p,s} D at each step

a i p s a p a s s i
a 1 0 0 0 a 0 1 0 1 0 0 0
s 0 0 0 1 s 0 0 0 0 1 0 0
s 0 0 0 1 s 0 0 0 0 0 1 0
i 0 1 0 0 i 0 0 0 0 0 0 1

The Shift-And algorithm can also be seen as a bitparallel simulation of the

nondeterministic automaton that accepts a string ending with P .
Σ

a s s i
-1 0 1 2 3

After processing T [j], D.i = 1 if and only if there is a path from the initial
state (state -1) to state i with the string T [0..j].

84
In the integer alphabet model when m ≤ w:

• Preprocessing time is O(σ + m).

• Search time is O(n).

If m > w, we can store the bitvectors in dm/we machine words and perform
each bitvector operation in O(dm/we) time.

• Preprocessing time is O(σdm/we + m).

• Search time is O(ndm/we).

If no pattern prefix longer than w matches a current text suffix, then only
the least significant machine word contains 1’s. There is no need to update
the other words; they will stay 0.

• Thus the search time is O(n) on average.

Algorithms like Shift-And that take advantage of the implicit parallelism in

bitvector operations are called bitparallel.
85
Karp–Rabin

The Karp–Rabin hash function (Definition 1.43) was originally developed for
solving the exact string matching problem. The idea is to compute the hash
values or fingerprints H(P ) and H(T [j..j + m)) for all j ∈ [0..n − m].

• If H(P ) 6= H(T [j..j + m)), then we must have P 6= T [j..j + m).

• If H(P ) = H(T [j..j + m), the algorithm compares P and T [j..j + m) in
brute force manner. If P 6= T [j..j + m), this is a false positive.

The text factor fingerprints are computed in a sliding window fashion. The
fingerprint for T [j + 1..j + 1 + m) = αT [j + m] is computed from the
fingerprint for T [j..j + m) = T [j]α in constant time using Lemma 1.44:
H(T [j + 1..j + 1 + m)) = (H(T [j]α) − H(T [j]) · rm−1 ) · r + H(T [j + m])) mod q
= (H(T [j..j + m)) − T [j] · rm−1 ) · r + T [j + m]) mod q .
A hash function that supports this kind of sliding window computation is
known as a rolling hash function.

86
Algorithm 2.10: Karp-Rabin
Input: text T = T [0 . . . n), pattern P = P [0 . . . m)
Output: position of the first occurrence of P in T
(1) Choose q and r; s ← rm−1 mod q
(2) hp ← 0; ht ← 0
(3) for i ← 0 to m − 1 do hp ← (hp · r + P [i]) mod q // hp = H(P )
(4) for j ← 0 to m − 1 do ht ← (ht · r + T [j]) mod q
(5) for j ← 0 to n − m − 1 do
(6) if hp = ht then if P = T [j . . . j + m) then return j
(7) ht ← ((ht − T [j] · s) · r + T [j + m]) mod q
(8) if hp = ht then if P = T [j . . . j + m) then return j
(9) return n

In the integer alphabet model:

• The worst case time complexity is O(mn).

• The average case time complexity is O(m + n).

Karp–Rabin is not competitive in practice for a single pattern, but can be

for multiple patterns (exercise).
87
Horspool

The algorithms we have seen so far access every character of the text. If we
start the comparison between the pattern and the current text position from
the end, we can often skip some text characters completely.

There are many algorithms that start from the end. The simplest are the
Horspool-type algorithms.

The Horspool algorithm checks first the last character of the text window,
i.e., the character aligned with the last pattern character. If that doesn’t
match, it moves (shifts) the pattern forward until there is a match.

Example 2.11: Horspool

ainaisesti-ainainen
ainaine/n
ainaine//
n
ainainen

88
More precisely, suppose we are currently comparing P against T [j..j + m).
Start by comparing P [m − 1] to T [k], where k = j + m − 1.

• If P [m − 1] 6= T [k], shift the pattern until the pattern character aligned

with T [k] matches, or until the full pattern is past T [k].
• If P [m − 1] = T [k], compare the rest in a brute force manner. Then
shift to the next position, where T [k] matches.

The length of the shift is determined by the shift table that is precomputed
for the pattern. shif t[c] is defined for all c ∈ Σ:

• If c does not occur in P , shif t[c] = m.

• Otherwise, shif t[c] = m − 1 − i, where P [i] = c is the last occurrence of
c in P [0..m − 2].

Example 2.12: P = ainainen. c last occ. shif t

a ainainen 4
e ainainen 1
i ainainen 3
n ainainen 2
Σ \ {a,e,i,n} — 8
89
Algorithm 2.13: Horspool
Input: text T = T [0 . . . n), pattern P = P [0 . . . m)
Output: position of the first occurrence of P in T
Preprocess:
(1) for c ∈ Σ do shif t[c] ← m
(2) for i ← 0 to m − 2 do shif t[P [i]] ← m − 1 − i
Search:
(3) j ← 0
(4) while j + m ≤ n do
(5) if P [m − 1] = T [j + m − 1] then
(6) i←m−2
(7) while i ≥ 0 and P [i] = T [j + i] do i ← i − 1
(8) if i = −1 then return j
(9) j ← j + shif t[T [j + m − 1]]
(10) return n

90
In the integer alphabet model:

• Preprocessing time is O(σ + m).

• In the worst case, the search time is O(mn).
For example, P = bam−1 and T = an .
• In the best case, the search time is O(n/m).
For example, P = bm and T = an .
• In the average case, the search time is O(n/ min(m, σ)).
This assumes that each pattern and text character is picked
independently by uniform distribution.

In practice, a tuned implementation of Horspool is very fast when the

alphabet is not too small.

91