Algoritmos

Algoritmos de
de Matching
Matching

Bibliografia

Dan Gusfield, Algorithms on Strings, Trees, and Sequences:

Computer Science and Computational Biology,Cambridge
University Press, 1997.
 Algoritmos
Algoritmos de
de Matching
Matching
O problema de Matching:

Dada uma string P, chamada padrão, e uma outra string T, chamada

texto, o problema de Matching exato é encontrar todas as ocorrências
de P em T.

P=aba

T=bbabaxababay
 Algoritmos
Algoritmos de
de Matching
Matching
Algoritmo Ingênuo :

P=aba aba
T=bbabaxababay
aba aba

Complexidade: O(nm), onde n e m são os tamanhos de P e T

 Algoritmos
Algoritmos de
de Matching
Matching

Diversos algoritmos tem sido propostos na literatura para resolver

o problema de matching em tempo linear, mas a maioria deles se
baseiam nas idéias dos algoritmos de:

• Boyer-Moore algoritmo em 1977

• Knuth-Morris-Pratt também em 1977

 Algoritmo
Algoritmo Knuth-Morris-Pratt
Knuth-Morris-Pratt
(KMP)
(KMP)
A idéia é pre-processar o padrão P antes de realizar o matching.

Seja spi o comprimento do maior sufixo de P[1..i] que é igual a

um prefixo de P e que P(i+1) e P(spi+1) sejam diferentes.

P = bbccaebbcabd

sp8Sp
= 19=3
 Algoritmo
Algoritmo Knuth-Morris-Pratt
Knuth-Morris-Pratt
(KMP)
(KMP)
Regra de translação de P:

Suponha que P esteja alinhado com T e que o primeiro erro ocorra

na posição i+1 de P e k de T. Então P será transladado i-spi para
a direita e a nova comparação começa em T(k).
1 234 5 6 789
P = abcxabcde K = 10 ; i = 7
sp7 = 3;
1 23 456 78 9 01 2 34 56 7 8 Translado = 7 - 3 = 4
T = xyabcxabcxadcdqfeg
abcxabcde
abcxabcde O(m)
 Algoritmo
Algoritmo Knuth-Morris-Pratt
Knuth-Morris-Pratt
(KMP)
(KMP)
Cálculo dos spi

A fim de calcular os spi, primeiro calculamos os spbi, que

são definidos como o comprimento do maior sufixo de P[1..i]
que é igual a um prefixo de P.

P = bbccaebbcabd

spbSp =3
8 =9 2
 Algoritmo
Algoritmo Knuth-Morris-Pratt
Knuth-Morris-Pratt
(KMP)
(KMP)
Cálculo dos spbi

Suponha que os sbpi já tenham sido calculados para i ≤ k.

Temos dois casos a considerar:

1) Se P(k+1) = P(spbk +1) então spbk+1 = spbk + 1

x x
spbk k k+1
2) Se P(k+1) ≠ P(spbk +1) então:
 Algoritmo
Algoritmo Knuth-Morris-Pratt
Knuth-Morris-Pratt
(KMP)
(KMP)
Cálculo dos spbi

2) Se P(k+1) ≠ P(spbk +1) então:

x y x
spbk k k+1
Spbk+1
 Algoritmo
Algoritmo Knuth-Morris-Pratt
Knuth-Morris-Pratt
(KMP)
(KMP)
Algoritmo para Cálculo dos spbi 1 234 5 6 789
P = abcxabcde
Spb1 = 0
for k=1 to n-1 k x v spb1 = 0
x = P(k+1) 0 spb2 = 0
1 b
v = spbk 2 c 0 spb3 = 0
while P(v+1) ≠ x and v ≠ 0 3 x 0 spb4 = 0
v = spbv 4 a 0 spb5 = 1
if P(v+1) = x 5 b 1 spb6 = 2
6 c 2
spbk+1 = v+1 spb7 = 3
7 c 3 0
else 8 d 0 spb8 = 0
spbk+1 = 0 spb9 = 0
O(n)
 Algoritmo
Algoritmo Knuth-Morris-Pratt
Knuth-Morris-Pratt
(KMP)
(KMP)
1 234 5 6 789
Algoritmo para Cálculo dos spi P = abcxabcde
sp1 = 0 sp0 = 0
sp1 = 0 k v spb1 = 0 sp1 = 0
for k=2 to n spb2 = 0 sp2 = 0
2 0
v = spbk 3 0 spb3 = 0 sp3 = 0
if P(v+1) ≠ P(k+1) 4 0 spb4 = 0 sp4 = 0
spk = v 5 1 spb5 = 1 sp5 = 0
else 6 2 spb6 = 2 sp6 = 0
7 3 sp7 = 3
spk = spv spb7 = 3
8 0
9 0 spb8 = 0 sp8 = 0
spb9 = 0 sp9 = 0
Tempo do algoritmo KMP é O(n+m)
 Algoritmos
Algoritmos de
de Matching
Matching
Múltiplos Padrões:

Seja P = {P1, P2, ..., Pz} um conjunto de padrões

Aplicando o KMP para cada padrão temos O(n+zm) comparações,
onde n é o comprimento total de P . Aho-Corasick em 1975
desenvolveram um algoritmo baseado em keyword tree com
complexidade O(n+m).

Uma Keyword Tree para P é uma árvore com as seguintes propriedades:

• cada aresta da árvore é rotulada com um caracter
• quaisquer duas arestas saindo do mesmo nó possuem rótulos distintos
• todo padrão Pi é mapeado para algum nó v da árvore tal que os caracteres
no caminho da raiz até v formam o padrão Pi.
 Algoritmos
Algoritmos de
de Matching
Matching

Exemplo: P = {potato, poetry, pottery, science, school}

p s
c h o o l struct keyword
o 5
i {
t e e char edge;
t
t n char *str;
a r
e struct keyword *children;
t y c
o r };
e
y 2
1 4
3

Utilizando o algoritmo ingênuo com a árvore temos O(nm)

 Algoritmos
Algoritmos de
de Matching
Matching
Seja lp(v) o comprimento do maior sufixo da string str(v)
que é prefixo de algum padrão Pi

Por exemplo: P={potato, tattoo, theater, other}

o t h e r struct keyword
2 p t h {
o e char edge;
a a
t t char *str;
t
a e struct keyword *children;
3 t r struct keyword *nv;
t int lpv;
o o };
o
 Algoritmos
Algoritmos de
de Matching
Matching
o t h e r
p t h
o e
a a
t t
t
a e
3 t r
t
o o

o
O(m) comparações

T= x x p o t a t t o o x x

Trans: 8 -3 = 5 Erro em 8
 Algoritmos
Algoritmos de
de Matching
Matching

Algumas observações:

• O tempo para calcular os lpv e os nv é O(n), onde n é o

comprimento total de P. Portanto, a complexidade total do
algoritmo é O(n+m).

• Se algum padrão em P é uma substring de outro padrão em

em P, então, após alguns ajustes no algoritmo, a complexidade
complexidade para o matching exato é O(n+m+k), onde k
é o número de ocorrências encontradas.
 Algoritmos
Algoritmos de
de Matching
Matching
Árvore
Árvore de
de Sufixos
Sufixos
Definição: Uma árvore de sufixos para um conjunto de m caracteres S
é uma árvore com exatamente m folhas possuindo as seguintes propriedades:

• Cada nó interno, diferente da raiz, tem pelo menos dois filhos.

• Cada aresta da árvore é rotulada com uma substring de S
• Nenhuma arestas saindo de um nó pode ter rótulos começando com
o mesmo caracter.
• Para qualquer folha i a concatenação das substrings no caminho da
raiz até a folha i contém o sufixo de S que começa na posição i, isto
é, contém S[i..m].
 Algoritmos
Algoritmos de
de Matching
Matching
Árvore
Árvore de
de Sufixos
Sufixos
1 2 3 4 5 6 7
Exemplo: S = x a b x a c $

x a b x a c 1
c
a
b

4
x

b
x
a

c a
c

c c

3 5 2
6
Obs: A fim de garantir a existência da árvore de sufixos é necessario
introduzir um caracter diferente dos demais no final de S.
 Algoritmos
Algoritmos de
de Matching
Matching
Árvore
Árvore de
de Sufixos
Sufixos
1 2 3 4 5 6 P=xa
Exemplo: S = x a b x a c

x a b x a c 1
c
a
b

4
x

b
x
a

c a
c

c c

3 5 2
6
 Algoritmos
Algoritmos de
de Matching
Matching
Árvore
Árvore de
de Sufixos
Sufixos
Construção da árvore de sufixos (algoritmo ingênuo)
S=x a b x a c
x a b x a c 1
c
a
b

4
b
x

x
a

c a
c

c c
O(m2)
3 5 2
6
 Algoritmos
Algoritmos de
de Matching
Matching
Árvore
Árvore de
de Sufixos
Sufixos

Construção da árvore de sufixos em O(m):

• Primeiro algoritmo com complexidade O(m) é devido a

P. Weiner em 1973.
• M. McCreight em 1976 propos um algoritmo mais eficiente
• E. Ukkonen em 1995 desenvolveu um algoritmo conceitualmente
mais simples.