Post on 18-Apr-2015
Cin – UFPE
Danielle Nathália Gomes da Silva
Anderson Paulo da Silva
{dngs, aps3} @cin.ufpe.br
Recife, Junho de 2008
1
String Matching
Emparelhamento de Cadeias
Guia1. Motivação2. Definição3. Notação e Terminologia4. Algoritmos
1. Força Bruta Simples2. Rabin-Karp3. Emparelhamento por Autômato
Finito4. Knuth-Moris Pratt.
2
Motivação
Encontra sequências: Grupo de pixels (leitura de um pergaminho); Grupo de índices de um banco de dados; Um texto (no caso de um “search” de um editor de texto); Uma sequência de DNA;
3
Motivação
Objetivo:Encontrar uma cadeia de caracteres e geralmente, todas as ocorrências dessa cadeia (conhecida como padrão) em um determinado texto.
4
Visão Geral1. Força Bruta Simples: Desliza através do texto
verificando caractere a caractere.
2. Rabin-Karp: Codifica o padrão buscado como uma tabela hash.
3. Emparelhamento por Autômato Finito: Para cada padrão é criado um autômato finito determinístico que o identifica no texto.
4. Knuth-Moris Pratt (KMP): Custo linear, Otimização do simples e do AF. Mais usado para encontrar sequencia de DNA.
5
...Força Bruta KR - 1980 KMP/BM - 1977 AF - 1970
Quadro Comparativo
6
Algoritmo Tempo de pré-processamento
Tempo de Emparelhamento
Simples 0 Ο((n-m+1)m)
Rabin-Karp Θ(m) Ο((n-m+1)m)
Autômato Finito Ο(m3|∑|) Θ(n)
Knuth-Morris-Pratt Θ(m) Θ(n)
Com exceção do algoritmo de Força Bruta, todos os outros que serão apresentados, têm uma etapa anterior ao emparelhamento, que é fase de pré-processamento do padrão.
Sendo o tempo total do algoritmo o tempo de processamento mais o tempo de emparelhamento.
DefiniçõesTexto é um array de tamanho n T [ 1 ... n]Padrão é um array de tamanho m P [ 1 ... m]T n = 8P s=2 m= 3s deslocamento
Com m ≤ n
7
a b baac b c
c a a
DefiniçõesQuando o padrão P ocorre? Quando temos um deslocamento valido?1. Se 0 ≤ s ≤ n - m2. T [s+1 ... s+m] = P [1 ... m]3. T [s+j] = P [j], para 1 ≤ j ≤ m
8
Definição1. Se 0 ≤ s ≤ n - m (Possíveis valores de s)
s=0s=1 s=2s=3s=4s=5
9
a b c a a b b c
c c c
c c c
c c c
c c c
c c c
c c c
Definição2. T [s+1 ... s+m] = P [1 ... m]
T n = 8P s=2 m = 3
T [2+1 ... 2+3] = P [1 ... 3]T [3, 4, 5] = P [1, 2, 3]
10
a b c a a b b c
c c c
Definição3. T [s+j] = P [j], para 1 ≤ j ≤ m
T n = 8P s=2 m = 3
Se j = 31 ≤ j ≤ 3, T [2+3] = P [3]
11
a b c a a b b c
c c c Verifica para todos os valores de j
Notação e Terminologia∑ Sigma, representa um alfabeto∑* Sigma asterisco, conjunto de todas as cadeias de comprimento finito formadas, usando caracteres do alfabeto ∑ε Cadeia vazia e pertence a ∑*lXl Comprimento de XXY Concatenação de duas cadeias X e Y. E tem comprimento lXl + lYl
12
Notação e Terminologia1.Prefixo: w é prefixo de x, denota-se por w x, se x=wy para y ∑*. Então se w x, |w| ≤ |x|. Ex.: ab abcca
2.Sufixo: w é sufixo de x, denota-se por wx, se x=yw para y ∑*. Então se w x, |w| ≤ |x|. Ex.: cca abcca
13
Notação e Terminologia
14
a. Se |x| ≤ |y|, então, x y.
X
Z
Y
X
Y
Prova gráfica do Lema 32.1
Suponha que x,y e z sejam cadeias tais que x z e y z.
Notação e Terminologia
15
b. Se |x| |y|, então, y x.
X
Z
Y
X
Y
Notação e Terminologia
16
c. Se |x| |y|, então, y x.
X
Z
Y
X
Y
Notação e TerminologiaTrazendo para nosso contexto:1. Denotaremos o prefixo de k
caracteres P[1...k] do padrão P[1...m] por Pk.
2. Então, P0= ε e Pm=P=P[1...m].
3. Também denota-se para k caracteres do texto T como Tk.
Objetivo: Encontrar “s” válidos tal que P T s+m.
17
Notação e Terminologia T 1 ...n Tk 1 ...k
P 1 ...m Pk 1 ...k
Ilustrando:T n = 6P s=0 m = 3, P Ts+m -> P T3
s=1 P T4
s=2 P T5
s=3 P T6
18
a a b a c b a a
a c b
c
a a
a a b a c b a a
a c b
c
a a
a a b a c
a c b a a
a c b a a a
a a a
a a a
a a a
a a a
O Algoritmo de Força Bruta SimplesO algoritmo de força bruta procura por todos os deslocamentos s válidos, usando um loop para verificar a condição de que:
P[1 .. m] = T[s + 1 .. s + m] para cada n – m + 1 possível valor de s.
19
O Algoritmo de Força Bruta Simples
NAIVE-STRING-MATCHER (T, P)
1 n ← comprimento[T]
2 m ← comprimento[P]
3 for s ← 0 to n-m
4 do if P[1...m]=T[s+1...s+m]
5 then imprimir “Padrão ocorre com deslocamento” s
20
Caminha os possíveis valores de s
Verifica a condiçãode igualdade
O Algoritmo de Força Bruta Simples
O tempo de complexidade deste algoritmo no pior caso é O((n – m + 1)m). Serão feitas comparações para cada deslocamento s, de acordo com o tamanho do padrão m.
Considere:
T n=7
P m=5
S assume n-m+1 = 3.
=(7-5+1)5
=15
21
b c a a b b c b c a a b b c
a a b b c a a b b c
a a b b c
a a b b c
Se m = n/2, EntãoO (n/2 x n)O (n2/2) 1/2 O(n2) O(n2)
O Algoritmo de Força Bruta SimplesExercício 32.1-1 (Cormen)
TP s=0
s=1 P[1,2,3,4]=T[2,3,4,5] s=2 s=3
s=4 s=5
P[1,2,3,4]=T[6,7,8,9]...
s=11
22
0 0 0 0 1 0 0 0 1 0 1 0 0 0 1
0 0 0 1
0 0 0 1
0 0 0 1
0 0 0 1
0 0 0 1
0 0 0 1
0 0 0 1
O Algoritmo de Força Bruta Simples
23
Exemplo de busca em textoT e x t o d e e x e m p l o p a r a u m a b u s c a d i r e t a
E x e m
e x e m
e x e m
e x e m
e x e m
e x e m
e x e m
e x e m
e x e m
e x e m
Rabin-Karp Princípio: Transforma o padrão procurado
em um número, seguindo determinadas regras.
O métodos é baseado em processar a função de assinatura de cada substring de m-caracteres no texto e checar se é igual a assinatura da função da palavra procurada.
O padrão P ocorre no texto T se o valor calculado para P for igual ao valor calculado para qualquer substring X de T, de tamanho m, tal que | X | = | P |
24
Rabin-KarpCada caractere será um dígito decimal31415 corresponde ao nº decimal 31.415
... ... ...
25
2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
8 9 3 11 0 1 7 8 4 5 1
011 7 9 1
1
Os padrões podem ser texto
Por isso precisamos verifica a condição de igualdade
Rabin-Karp Acrescentando notação: p – número correspondente de P;
ts – número correspondente de T;
d – cardinalidade do alfabeto ; Então cada caractere é um dígito na base d.q – número primo, como: 16647133;
Então temos s válidos se, p = ts.
Como calcular p e ts ?
26
Rabin-KarpCom o alfabeto = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} e || = 10
P
Temos:
(P[1] * 10 + P[2]) = 19
(19 * 10) + P[3] = 199
(199 * 10) + P[4] = 1991
Generalizando:
P[m] + || (P[m-1]+ || (P[m-2] + ... + || (P[2] + | P[1]) ))
27
1 9 9 1 ∑ = alfabeto
|∑| = tamanho de ∑
Dado um caractere, a representação numérica deste será sua posição no alfabeto ∑
Rabin-KarpRealiza pré-processamento do padrão P em tempo (m)
|P| = m
Usando a regra de Horner, podemos calcular o valor de p no tempo O (m)
P = P[m]+10(P[m-1]+10(P[m-2] + ... + 10(P[2]+10P[1])...))
Comparar P com as m 1ª posições de T.
O t0 pode ser calculado de modo semelhante, mas os t1 ... tn-m ?
28
2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
2 3 5 9
Rabin-KarpPara calcular os ts, com s = 1 ... n-m. Temos s=6.ts+1 = 10(ts – 10m-1T[s+1]) + T[s+m+1]
ts+1 = 10(31415 – 30000) + 2
ts+1 = 10(1415) + 2
ts+1 = 14152
... ... ...
29
2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
8 9 3 11 0 1 7 8 4 5 1
011 7 9 1
1
Remove o dígito de mais alta ordem de ts.
Rabin-Karp10m-1T[s+1] – Remover dígito de mais alta ordem.
1991 – 10m-1
1991 – 1000991 991 x 10 9910 + 0 = 9910
30
1 9 9 1 0 2 0 1 4 1 5 2 6 7 3 9 9 2 1
1 9 9 0
O dígito de mais alta ordem foi retirado.
Acrescenta a casa decimal para a substring voltar a ter tamanho m
É previamente calculado. Nesta operação matemática a complexidade depende do nº de bits. Custo O(lg m).
O(1)
Faz esse processo O(n – m)
Rabin-KarpOs valores das transformações de P e das substrings de T são
muito grande, quando m e |∑| são muito longos
Ajustando a equação para funcionar em módulo q.14152 (d(ts – h T[s+1]) + T[s+m+1]) mod q
14152 10(31415 – 3x10000) + 2 (mod 13)
14152 10(7-3x3) + 2 (mod 13)14152 8 (mod 13)
Onde,
d = ||h dm-1
31
3 1 4 1 5 2
7 8
Rabin-KarpRealiza pré-processamento em tempo
(lg m) + (m) + (m) = (m) Emparelhamento (matching)
n-m+1 deslocamento possíveis T deve ser calculado com deslocamento s+1. Processar T no deslocamento s+1 custa O(1), então transformar todo T leva tempo (n-m+1)
Quantas comparações possíveis entre o número calculado p e para t vamos realizar? (n-m+1)
Até agora temos (2(n-m+1)) = (n-m+1)
32
Processar o texto e fazer comparações entre dos nº entre as chaves
Rabin-KarpAnálise do pior caso.
Entretanto para (n-m+1) deslocamento possíveis, no pior caso, pode haver necessidade de comparar caractere a caractere de p com todos os ts. Para comparar o com ts, custa o tamanho do padrão, O(m), então temos que, o custo de emparelhamento no pior caso é: (n-m+1) x (m) = ((n-m+1)m)O custo total do algoritmo é a soma do tempo de pré-processamento com o tempo de emparelhamento.
((n-m+1)m) + (m)
((n-m)m)
(n x m)
33
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
2 2 2 2
Se m = n/2, EntãoO (n/2 x n)O (n2/2) 1/2 O(n2) O(n2)
Rabin-KarpRealiza pré-processamento do padrão P em tempo O(m)O tempo de processamento de T O(n)
Pior caso:Realiza o emparelhamento de P em T O((n-m+1)m) = O (m x n) Se m= n\2, O (n2)
34
Rabin-Karp
35
RABIN-KARP-MACHER (T, P, d, q)
1 n ← comprimento[T]
2 m ← comprimento[P]
3 h ← d m-1 mod q
4 p ← 0
5 t0 ← 0
6 for i ← 1 to m \\ Pré-processamento
7 do p ← (dp + P[i]) mod q
8 t0 ← (t0 + T[i]) mod q
9 for s ← 0 to n-m \\ Emparelhamento
10 do if p = ts
11 then if P [1...m] = T [s + 1 ... s + m]
12 then “Padrão ocorre no deslocamento” s
13 if s < n-m
14 then ts+1 ← (d(ts – T[s+1]h) + T[s+m+1]) mod q
Inicializa o hash(p) da palavra e do texto, hash(t)
Compara caracteres da substring com a palavra, eliminando o acerto espúrio
Rabin-Karp
36
Localizar o padrão 31415 no texto 2359023141526739921. 31415 mod 13 = 7, então, deve-se procurar por todas as combinações de P onde mod 13 = 7 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 8 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
--------- 9 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
--------- 3 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
--------- 11 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
--------- 0 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
--------- 1 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
--------- 7 Comparação bem sucedida na posição 7
2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 8 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 4 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 5 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 10 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 11 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 7 Comparação mal sucedida 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 9 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 11
Rabin-Karp
37
Localizar o padrão 31415 no texto 2359023141526739921. 31415 mod 13 = 7, então, deve-se procurar por todas as combinações de P onde mod 13 = 7 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 8 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
--------- 9 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
--------- 3 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
--------- 11 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
--------- 0 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
--------- 1 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
--------- 7 Comparação bem sucedida na posição 7
2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 8 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 4 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 5 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 10 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 11 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 7 Comparação mal sucedida 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 9 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1 --------- 11
Emparelhamento de cadeias com autômatos finitos
Notação:
Um autômato finito é uma 5-tupla (Q, q0, A, ,)
Onde:
Q – Conjunto de estados
q0 - Estado Inicial (q0 Q) A – Conjunto de estados de aceitação (A Q) - Alfabeto de entrada finito - Função de transição
Autômato de emparelhamento
Autômato que aceita a string “ababaca”.
0 1 2 5 63 4 7a b a b a ac
b, c a
c
b, c
c
a
b, c
a
b
b, c
c
b
a
Autômatos e função
40
1 0 0
1 2 0
3 0 0
1 4 0
5 0 0
1 4 6
7 0 0
1 2 0
a b c
EntradaEstado
0
1
2
3
4
5
6
7
i – 1 2 3 4 5 6 7 8 9 10 11T[i] - a b a b a b a c a b aEstado (Ti) 0 1 2 3 4 5 4 5 6 7 2 3
Função de estado final e função sufixo
1. (w) – Função de Estado Final() = q0
(wa) = ((w), a) para w *, a
2. (x) – Função SufixoÉ o comprimento do mais longo prefixo de P
que é um sufixo de x(x) = max{k: Pk x} P = ab
() = 0(ccaca) = 1(ccab) = 2
Para um padrão P de comprimentom, temos (x) = m P x
Função de Transição, Função de Estado Final e Função Sufixo
1. A função de transição é definida pela seguinte equação, para qualquer estado “q” e caractere “a”:
(q, a) = (P qa).
2. Uma boa razão intuitiva para a definição anterior é:
(Ti) = (Ti)
43
T[i ] = a b a b a b a c a b aP = a b a b a c a
0 1 2 5 63 4 7a b a b a ac
b, c a
c
b, c
c
a
b, c
a
b
b, c
c
b
a
Autômato de emparelhamento
44
T[i ] = a b a b a b a c a b aP = a b a b a c a
0 1 2 5 63 4 7a b a b a ac
b, c a
c
b, c
c
a
b, c
a
b
b, c
c
b
a
Autômato de emparelhamento
45
T[i ] = a b a b a b a c a b aP = a b a b a c a
0 1 2 5 63 4 7a b a b a ac
b, c a
c
b, c
c
a
b, c
a
b
b, c
c
b
a
Autômato de emparelhamento
46
T[i ] = a b a b a b a c a b aP = a b a b a c a
0 1 2 5 63 4 7a b a b a ac
b, c a
c
b, c
c
a
b, c
a
b
b, c
c
b
a
Autômato de emparelhamento
47
T[i ] = a b a b a b a c a b aP = a b a b a c a
0 1 2 5 63 4 7a b a b a ac
b, c a
c
b, c
c
a
b, c
a
b
b, c
c
b
a
Autômato de emparelhamento
48
T[i ] = a b a b a b a c a b aP = a b a b a c a
0 1 2 5 63 4 7a b a b a ac
b, c a
c
b, c
c
a
b, c
a
b
b, c
c
b
a
Autômato de emparelhamento
49
T[i ] = a b a b a b a c a b aP = a b a b a c a
0 1 2 5 63 4 7a b a b a ac
b, c a
c
b, c
c
a
b, c
a
b
b, c
c
b
a
Autômato de emparelhamento
50
T[i ] = a b a b a b a c a b aP = a b a b a c a
0 1 2 5 63 4 7a b a b a ac
b, c a
c
b, c
c
a
b, c
a
b
b, c
c
b
a
Autômato de emparelhamento
51
T[i ] = a b a b a b a c a b aP = a b a b a c a
0 1 2 5 63 4 7a b a b a ac
b, c a
c
b, c
c
a
b, c
a
b
b, c
c
b
a
Autômato de emparelhamento
52
T[i ] = a b a b a b a c a b aP = a b a b a c a
0 1 2 5 63 4 7a b a b a ac
b, c a
c
b, c
c
a
b, c
a
b
b, c
c
b
a
Autômato de emparelhamento
Automato de Emparelhamento
FINITE-AUTOMATON-MATCHER(T, , m)
n comprimento[T]
q 0
for i 1 to n
do q (q, T[i])
if q = m
then imprimir “padrão ocorre com deslocamento” i-m
(n)
Computando a função de Transição
COMPUTE-TRANSITION-FUNCTION(P, )
m comprimento[P]
for q 0 to m
do for cada caractere “a”
do kmin(m+1, q+2)
repeat k k-1
until Pk Pqa
(q, a) k
return
m* m* m*|| = O(m3| |)
Algoritmo KMP (Knuth-Morris-Pratt)
Algoritmo de emparelhamento em tempo linear;
Evita por completo o cálculo da função de transição;
Evita testes de deslocamento inúteis;
Algoritmo KMP – Função Prefixo
Definição:
A função prefixo para o padrão P é a função:
{1, 2, …, m} {0, 1, …, m-1} tal que
*[q] = max{k: k<q e Pk Pq}
Em outras palavras: [q] é o comprimento do prefixo mais longo de P que também é sufixo de Pq.
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
57
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
58
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
59
Êpa!
Antes do erro a string “10”foi lida no texto. Logo o padrão não
precisa ser comparado com a segunda posição
do texto.
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1
60
Êpa!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
61
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
62
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
63
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
64
Êpa!
A última substring lida foi “101”. Logo o padrão pode avançar 2 posições a direita
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
65
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
66
Êpa!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
67
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
68
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
69
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
70
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
71
Êpa!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
72
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
73
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
74
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
75
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
76
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
77
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
78
Ôba!
Algoritmo KMP (Knuth – Morris – Pratt)
T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0P = 1 0 1 0 0 1 1 1
P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1 P = 1 0 1 0 0 1 1 1
79
Algoritmo Compute-Prefix-Function
80
Compute-Prefix-Function(P)
m comprimento[P]
[1] 0
k 0
For q 2 to m
do while k > 0 e P[k+1] P[q]
do k [k]
if P[k+1] = P[q]
then k k + 1
[q] k
return
i 1 2 3 4 5 6 7 8 9 10
P[i] a b a b a b a b c a[i] 0
Algoritmo Compute-Prefix-Function
81
Compute-Prefix-Function(P)
m comprimento[P]
[1] 0
k 0
For q 2 to m
do while k > 0 e P[k+1] P[q]
do k [k]
if P[k+1] = P[q]
then k k + 1
[q] k
return
i 1 2 3 4 5 6 7 8 9 10
P[i] a b a b a b a b c a[i] 0 0
Algoritmo Compute-Prefix-Function
82
Compute-Prefix-Function(P)
m comprimento[P]
[1] 0
k 0
For q 2 to m
do while k > 0 e P[k+1] P[q]
do k [k]
if P[k+1] = P[q]
then k k + 1
[q] k
return
i 1 2 3 4 5 6 7 8 9 10
P[i] a b a b a b a b c a[i] 0 0 1
Algoritmo Compute-Prefix-Function
83
Compute-Prefix-Function(P)
m comprimento[P]
[1] 0
k 0
For q 2 to m
do while k > 0 e P[k+1] P[q]
do k [k]
if P[k+1] = P[q]
then k k + 1
[q] k
return
i 1 2 3 4 5 6 7 8 9 10
P[i] a b a b a b a b c a[i] 0 0 1 2
Algoritmo Compute-Prefix-Function
84
Compute-Prefix-Function(P)
m comprimento[P]
[1] 0
k 0
For q 2 to m
do while k > 0 e P[k+1] P[q]
do k [k]
if P[k+1] = P[q]
then k k + 1
[q] k
return
i 1 2 3 4 5 6 7 8 9 10
P[i] a b a b a b a b c a[i] 0 0 1 2 3
Algoritmo Compute-Prefix-Function
85
Compute-Prefix-Function(P)
m comprimento[P]
[1] 0
k 0
For q 2 to m
do while k > 0 e P[k+1] P[q]
do k [k]
if P[k+1] = P[q]
then k k + 1
[q] k
return
i 1 2 3 4 5 6 7 8 9 10
P[i] a b a b a b a b c a[i] 0 0 1 2 3 4
Algoritmo Compute-Prefix-Function
86
Compute-Prefix-Function(P)
m comprimento[P]
[1] 0
k 0
For q 2 to m
do while k > 0 e P[k+1] P[q]
do k [k]
if P[k+1] = P[q]
then k k + 1
[q] k
return
i 1 2 3 4 5 6 7 8 9 10
P[i] a b a b a b a b c a[i] 0 0 1 2 3 4 5
Algoritmo Compute-Prefix-Function
87
Compute-Prefix-Function(P)
m comprimento[P]
[1] 0
k 0
For q 2 to m
do while k > 0 e P[k+1] P[q]
do k [k]
if P[k+1] = P[q]
then k k + 1
[q] k
return
i 1 2 3 4 5 6 7 8 9 10
P[i] a b a b a b a b c a[i] 0 0 1 2 3 4 5 6
Algoritmo Compute-Prefix-Function
88
Compute-Prefix-Function(P)
m comprimento[P]
[1] 0
k 0
For q 2 to m
do while k > 0 e P[k+1] P[q]
do k [k]
if P[k+1] = P[q]
then k k + 1
[q] k
return
i 1 2 3 4 5 6 7 8 9 10
P[i] a b a b a b a b c a[i] 0 0 1 2 3 4 5 6 0
Algoritmo Compute-Prefix-Function
89
Compute-Prefix-Function(P)
m comprimento[P]
[1] 0
k 0
For q 2 to m
do while k > 0 e P[k+1] P[q]
do k [k]
if P[k+1] = P[q]
then k k + 1
[q] k
return
(m) Amortizada
i 1 2 3 4 5 6 7 8 9 10
P[i] a b a b a b a b c a[i] 0 0 1 2 3 4 5 6 0 1
Algoritmo KMP (Knuth–Morris–Pratt)
90
KMP - MATCHER(T, P)n comprimento[T]
m comprimento[P]
Compute-Prefix-Function(P)
q 0
for i 1 to n
do while q > 0 e P[q+1] T[i]
do q [q]
if P[q+1] = T[i]
then q q + 1
if q = m
then print “ Padrão ocorre com deslocamento” i – m
q [q]
(n) Amortizada
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
P[i]
a b a b a b a b c a
T[i]
a b a b a b a b a b a b c a a
[i]
0 0 1 2 3 4 5 6 0 1
Knuth-Morris-Pratt (KMP)
91
H o o l a - H o o l a g i r l s l i k e H o o l i g a n s H o o l i g a n H o o l i g a n H o o l i g a n H o o l i g a n H o o l i g a n . . . . . . . . . . . . . . . H o o l i g a n
Exemplo de busca em texto
Boore Moore
92
Inicia a busca comparando-se os caracteres do final da cadeia;
Compara as observações anteriores da cadeia, mesmo artifício do KMP;
Faz uso de duas heurísticas: mau-caractere e bom sufixo;
A escolha da heurística depende da sua aplicação;
Texto com grande diversidade de caractere (mau-caractere);
Boore Moore
93
Exemplo de busca em texto
H o o L a - H o o l a g i r l s l i k e H o o l i g a n s
H o o L i g a n
H o o l i g a n
H o o l i g a n
H o o l i g a n
H o o l i g a n
Boore Moore
94
Exemplo de busca em texto
A s T r i n g e x a m p l e c o n s i s t i n g o f . . .
s t i N g
s t i n g
s t i n g
s t i n g
s t i n g
s t i n g
s t i n g
Bibliografiahttp://en.wikipedia.org/wiki/String_searching_algorithmhttp://dalton.dsc.ufcg.edu.br/edados/index.php/Casamento_de_Padr%C3%B5es_em_Strings#Vis.C3.A3o_Geral Carvalho, Paulo. Oliveira, Deive. Guaracy, Alessandra. Gomes, Alisson. Albuquerque, Jones. Um Estudo Teórico e Experimental em Algoritmos Clássicos de Busca em Texto. UFLA - Universidade Federal de Lavras. Silva, Danielle. Fernandes, Carlos. Joab, Rony. Algoritmos para Busca de Padrões em Sequências. UFRPE – Universidade Federal Rural de Pernambuco.Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford. Introduction to Algorithms, second edition, MIT Press and McGraw-Hill.
95