- Heuristics used to
help speed up the
string matching procedure:
- Looking-Glass Heuristic:
- Try to match the
last character
first
- Example:
T = acgttagatactaggatgcca P = gata Order of matching the characters: (1) acgttagatactaggatgcca gata (2) acgttagatactaggatgcca gata (3) acgttagatactaggatgcca gata (4) acgttagatactaggatgcca gata
- Try to match the
last character
first
- Character-Jump heuristic:
- When a mismatch occurs,
slide
the pattern string
forward
until there is a
match at the
mismatch position
- Example:
T = agcttagatactagtcgatgcca P = gtcga
Matching: (starts at the end) v (1) agcttagatactagtcgatgcca gtcga Mismatch ==> slide P further until a match under mismatched position Result: agcttagatactagtcgatgcca gtcga
- When a mismatch occurs,
slide
the pattern string
forward
until there is a
match at the
mismatch position
- Looking-Glass Heuristic:
- Note:
- Goodrich has
left out another heuristic
in the Boyer-Moore algorithm
that allow the pattern string
to slide on a partial match
See Wikipedia page on Boyer-Moore: click here
- Goodrich's simplified Boyer-Moore algorithm
uses only the
Table 2
It's in fact the BoyerMooreHorspool algorithm: click here
- Goodrich has
left out another heuristic
in the Boyer-Moore algorithm
that allow the pattern string
to slide on a partial match
- We need to know
how far to jump
when there is a
mismatch
- Example:
T = taagccctgatcgatactagtcgatgcca n = 29 P = taagcccttat m = 11
Step 1: 01234567890123456789012345678 (ruler to find i and j) i=10 v taagccctgatcgatactagtcgatgcca taagcccttat ^ j=10 Match => test previous character
Step 2: 01234567890123456789012345678 (ruler to find i and j) i=9 v taagccctgatcgatactagtcgatgcca taagcccttat ^ j=9 Match => test previous character
Step 3: 01234567890123456789012345678 (ruler to find i and j) i=8 v taagccctgatcgatactagtcgatgcca taagcccttat ^ j=8 Mismatch ! SLIDE P: *************** 01234567890123456789012345678 (ruler to find i and j) i=15 v taagccctgatcgatactagtcgatgcca taagcccttat ^ j=8 <----- because we start over from the end *******
Jump distance in THIS example: Before: i = 8 After: i = 15 Jump distance = 15 - 8 = 7 *** How can we compute the jump distance in general ? ***********
- How to determine the
jump distance:
using the last(c) function
- last(c) = the index of the last (right most) occurence of the character c in the pattern
How to use last(c) to compute the jump distance:
T = taagccctgatcgatactagtcgatgcca n = 29 P = taagcccttat m = 11 01234567890123456789012345678 (ruler to find position) P = taagcccttat m = 11 ^ last(g) = 3 ................................. (1)
jump distance = 7 = 10 - 3 = "(m-1) - last(g)" characters .............. (2) ******* |<--->| taagcccttat ^ ^ (last(g)) 3 10 (m-1)
01234567890123456789012345678 (ruler to find i and j) i=8 v taagccctgatcgatactagtcgatgcca taagcccttat ^ j=8 Jump: 01234567890123456789012345678 (ruler to find i and j) i=15 (== old_i + (m-1) - last(g)) v taagccctgatcgatactagtcgatgcca taagcccttat (m-1) - last(g) characters ........... (2) ^ j=8
- Definition:
- last(c) =
the right most position
of the
character c
in the pattern string P
- If character c
does not occur in
pattern P,
we define:
- last(c) = −1 if c ∉ P
- last(c) =
the right most position
of the
character c
in the pattern string P
- Example:
01234567890 P = taagcccttat last(a) = 9 last(g) = 3 last(c) = 6 last(t) = 10 last(b) = -1 last(d) = -1 ...
- Psuedo code of the Preliminary version:
(there is a small problem, will be fixed later)
n = T.lenght(); m = P.length(); last = buildLastFunction(pattern); /* ------------------------------------------- Start by matching the last character in P ------------------------------------------- */ i = m-1; j = m-1; repeat { if ( P[j] and T[i] matches ) { if ( all characters in P matched ) return (match found at position i); match "next" (previous) characters } else /* Mismatch */ slide P over by "skip distance" characters; } (while i < n)In Java:
int BMmatch (String T, String P) { int[] last; int n; int m; int i, j; n = T.lenght(); m = P.length(); last = buildLastFunction(pattern); // last[c] = last(c) i = m-1; j = m-1; do { if ( P[j] == T[i] ) { /* ------------------------------- Characters match up ------------------------------- */ if ( j == 0 ) /* Last character matched up !!! */ { return(i); // Found a match ! } else { i--; // Match "next" pair of characters j--; } } else { /* -------------------------- Mismatch ==> Jump -------------------------- */ i = i + (m-1) + last[c]; // Jump j = m-1; // Match last character in pattern } } while ( i < n );
- Problem:
- You can jump backward if there are multiple of the same character in the pattern
- Example:
01234567890123456789012345678 (ruler to find position) T = taagccctgatcgatactagtcgatgcca n = 29 P = tgatccctgat m = 11 last(g) = 8
Algorithm execution:
01234567890123456789012345678 (ruler to find position) i=10 v T = taagccctgatcgatactagtcgatgcca tgatccctgat ^ j=10 Match => test previous character
01234567890123456789012345678 (ruler to find position) i=9 v T = taagccctgatcgatactagtcgatgcca tgatccctgat ^ j=9 Match => test previous character... and so on..
01234567890123456789012345678 (ruler to find position) i=4 v T = taagccctgatcgatactagtcgatgcca tgatccctgat ^ j=4 Match => test previous character
01234567890123456789012345678 (ruler to find position) i=3 v T = taagccctgatcgatactagtcgatgcca tgatccctgat ^ j=3 Mismatch => i = i + (m-1) - last(g) = 3 + (11-1) - 8 = 5 !!! Result: 01234567890123456789012345678 (ruler to find position) i=5 v T = taagccctgatcgatactagtcgatgcca tgatccctgat
- The difficult solution:
- On a mismatch, you must
jump to the
nearest left occurence
of that chracter
- Example:
01234567890123456789012345678 (ruler to find position) i=3 v T = taagccctgatcgatactagtcgatgcca tgatccctgat ^ j=3 Mismatch => Slide RIGHT until you find a match: 01234567890123456789012345678 (ruler to find position) i=12 v T = taagccctgatcgatactagtcgatgcca tgatccctgat ^ j=3
- What do you need:
- The jump distance last(g)
(and for every other character)
depends
on the mismatch position
Example:
a mismatch on "g" in these positions, slide to "first g" vvvv 01234567890123456789012345678 (ruler to find position) T = taagcccttagcgatactagtcgatgcca tgatcccgtat Result: T = taagcccttagcgatactagtcgatgcca tgatcccgtat
a mismatch on "g" in these positions, slide to "second g" vvvvvv 01234567890123456789012345678 (ruler to find position) T = taagcgcgtatcgatactagtcgatgcca tgatcccgtat Result: T = taagcgcgtatcgatactagtcgatgcca tgatcccgtat
- The jump distance last(g)
(and for every other character)
depends
on the mismatch position
- On a mismatch, you must
jump to the
nearest left occurence
of that chracter
- The simple solution:
- On a mismatch,
if
mismatched position <
the last(c) position,
we slide down 1 position
- Example:
01234567890123456789012345678 (ruler to find position) i=3 v T = taagcacctgatcgatactagtcgatgcca tgatcacctgat ^ ^ j=3 < last(g) Mismatch => Slide RIGHT 1 position...
Result: T = taagcacctgatcgatactagtcgatgcca tgatcacctgat
- On a mismatch,
if
mismatched position <
the last(c) position,
we slide down 1 position
- Pseudo code of the Simplified Boyer-Moore Algorithm:
n = T.lenght(); m = P.length(); last = buildLastFunction(pattern); /* ------------------------------------------- Start by matching the last character in P ------------------------------------------- */ i = m-1; j = m-1; repeat { if ( P[j] and T[i] matches ) { if ( all characters in P matched ) return (match found at position i); match "next" (previous) characters } else /* Mismatch */ { if ( *** mismatched location < last occurence of char *** ) slide P over by 1 character; else slide P over by "skip distance" characters; } (while i < n)In Java:
int BMmatch (String T, String P) { int[] last; int n; int m; int i, j; int last_i; // ***** Remember where we stopped last n = T.lenght(); m = P.length(); last = buildLastFunction(pattern); // last[c] = last(c) i = m-1; last_i = i; // ***** Remember where we stopped last j = m-1; do { if ( P[j] == T[i] ) { /* ------------------------------- Characters match up ------------------------------- */ if ( j == 0 ) /* Last character matched up !!! */ { return(i); // Found a match ! } else { i--; // Match "next" pair of characters j--; } } else { /* -------------------------- Mismatch ==> Jump -------------------------- */ if ( j < last[c] ) { i = last_i + 1; // We passed the "last(c)" position } else { i = i + (m-1) + last[c]; // Normal jump } j = m-1; // Match last character in pattern last_i = i; // ***** Remember where we stopped last } } while ( i < n );
- Example Program:
(Demo above code)
- Prog file: click here
Example input:
T = acgttagatactaggatgcca P = gata