slide1 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Cin – UFPE Danielle Nathália Gomes da Silva Anderson Paulo da Silva { dngs , aps3} @ cin.ufpe.br PowerPoint Presentation
Download Presentation
Cin – UFPE Danielle Nathália Gomes da Silva Anderson Paulo da Silva { dngs , aps3} @ cin.ufpe.br

Loading in 2 Seconds...

play fullscreen
1 / 95

Cin – UFPE Danielle Nathália Gomes da Silva Anderson Paulo da Silva { dngs , aps3} @ cin.ufpe.br - PowerPoint PPT Presentation


  • 97 Views
  • Uploaded on

String Matching Emparelhamento de Cadeias. Cin – UFPE Danielle Nathália Gomes da Silva Anderson Paulo da Silva { dngs , aps3} @ cin.ufpe.br Recife, Junho de 2008. Guia. Motivação Definição Notação e Terminologia Algoritmos Força Bruta Simples Rabin-Karp

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Cin – UFPE Danielle Nathália Gomes da Silva Anderson Paulo da Silva { dngs , aps3} @ cin.ufpe.br' - vin


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide1

String Matching

Emparelhamento

de Cadeias

Cin – UFPE

Danielle Nathália Gomes da Silva

Anderson Paulo da Silva

{dngs, aps3} @cin.ufpe.br

Recife, Junho de 2008

slide2
Guia
  • Motivação
  • Definição
  • Notação e Terminologia
  • Algoritmos
      • Força Bruta Simples
      • Rabin-Karp
      • Emparelhamento por Autômato Finito
      • Knuth-Moris Pratt.
motiva o
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;
motiva o1
Motivação

Objetivo:

Encontrar uma cadeia de caracteres e geralmente, todas as ocorrências dessa cadeia (conhecida como padrão) em um determinado texto.

vis o geral
Visão Geral
  • Força Bruta Simples: Desliza através do texto verificando caractere a caractere.
  • Rabin-Karp: Codifica o padrão buscado como uma tabela hash.
  • Emparelhamento por Autômato Finito: Para cada padrão é criado um autômato finito determinístico que o identifica no texto.
  • Knuth-Moris Pratt (KMP): Custo linear, Otimização do simples e do AF. Mais usado para encontrar sequencia de DNA.

...Força Bruta

AF - 1970

KMP/BM - 1977

KR - 1980

quadro comparativo
Quadro Comparativo
  • 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 es
Definições

Texto é um array de tamanho n  T [ 1 ... n]

Padrão é um array de tamanho m  P [ 1 ... m]

T n = 8

P s=2 m= 3

s  deslocamento

Com m ≤ n

a

b

c

a

a

b

b

c

c

a

a

defini es1
Definições

Quando o padrão P ocorre? Quando temos um deslocamento valido?

  • Se 0 ≤ s ≤ n - m
  • T [s+1 ... s+m] = P [1 ... m]
  • T [s+j] = P [j], para 1 ≤ j ≤ m
defini o
Definição
  • Se 0 ≤ s ≤ n - m (Possíveis valores de s)

s=0

s=1

s=2

s=3

s=4

s=5

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 o1
Definição
  • T [s+1 ... s+m] = P [1 ... m]

T n = 8

Ps=2 m = 3

T [2+1 ... 2+3] = P [1 ... 3]

T [3, 4, 5] = P [1, 2, 3]

a

b

c

a

a

b

b

c

c

c

c

defini o2
Definição
  • T [s+j] = P [j], para 1 ≤ j ≤ m

T n = 8

P s=2 m = 3

Se j = 3

1 ≤ j ≤ 3, T [2+3] = P [3]

a

b

c

a

a

b

b

c

Verifica para todos os valores de j

c

c

c

nota o e terminologia
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 X

XY  Concatenação de duas cadeias X e Y. E tem comprimento lXl + lYl

nota o e terminologia1
Notação e Terminologia
  • 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
  • Sufixo: w é sufixo de x, denota-se por wx, se x=yw para y  ∑*. Então se w x, |w| ≤ |x|. Ex.: cca abcca
nota o e terminologia2
Notação e Terminologia

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 terminologia3
Notação e Terminologia

Se |x| |y|, então, y  x.

X

Z

Y

X

Y

nota o e terminologia4
Notação e Terminologia

Se |x| |y|, então, y  x.

X

Z

Y

X

Y

nota o e terminologia5
Notação e Terminologia

Trazendo para nosso contexto:

  • Denotaremos o prefixo de k caracteres P[1...k] do padrão P[1...m] por Pk.
  • Então, P0= ε e Pm=P=P[1...m].
  • Também denota-se para k caracteres do texto T como Tk.

Objetivo:

Encontrar “s” válidos tal que P  T s+m.

nota o e terminologia6
Notação e Terminologia

T 1 ...n

Tk 1 ...k

P 1 ...m

Pk 1 ...k

Ilustrando:

T n = 6

P s=0 m = 3, P  Ts+m -> P  T3

s=1 P  T4

s=2 P  T5

s=3 P  T6

a

a

b

a

c

a

a

b

a

c

b

a

a

c

a

c

b

a

a

a

c

b

a

a

a

a

b

a

c

b

a

a

c

a

c

b

a

a

a

a

c

b

a

a

a

a

a

a

a

a

a

a

a

a

a

a

o algoritmo de for a bruta simples
O Algoritmo de Força Bruta Simples

O 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.

o algoritmo de for a bruta simples1
O Algoritmo de Força Bruta Simples

NAIVE-STRING-MATCHER (T, P)

  • n ← comprimento[T]
  • m ← comprimento[P]
  • for s ← 0 to n-m
  • do if P[1...m]=T[s+1...s+m]
  • then imprimir “Padrão ocorre com deslocamento” s

Caminha os possíveis valores de s

Verifica a condição

de igualdade

o algoritmo de for a bruta simples2
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

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ão

O (n/2 x n)

O (n2/2)

1/2 O(n2)

O(n2)

o algoritmo de for a bruta simples exerc cio 32 1 1 cormen
O Algoritmo de Força Bruta SimplesExercício 32.1-1 (Cormen)

T

P 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

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 simples3
O Algoritmo de Força Bruta Simples

Exemplo de busca em texto

rabin karp
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 |
rabin karp1
Rabin-Karp
  • Cada caractere será um dígito decimal
  • 31415 corresponde ao nº decimal 31.415

... ... ...

Os padrões podem ser texto

9

9

2

1

2

3

5

9

0

2

3

1

4

1

5

2

6

7

3

11

8

9

3

11

0

1

7

8

4

5

10

11

7

9

Por isso precisamos verifica a condição de igualdade

rabin karp2
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 ?
rabin karp3
Rabin-Karp

Com 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]) ))

1

9

9

1

∑ = alfabeto

|∑| = tamanho de ∑

Dado um caractere, a representação numérica deste será sua posição no alfabeto ∑

rabin karp4
Rabin-Karp
  • Realiza 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 ?

9

9

2

1

2

3

5

9

0

2

3

1

4

1

5

2

6

7

3

2

3

5

9

rabin karp5
Rabin-Karp

Para 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

... ... ...

Remove o dígito de mais alta ordem de ts.

9

9

2

1

2

3

5

9

0

2

3

1

4

1

5

2

6

7

3

11

8

9

3

11

0

1

7

8

4

5

10

11

7

9

rabin karp6
Rabin-Karp

10m-1T[s+1] – Remover dígito de mais alta ordem.

1991 – 10m-1

1991 – 1000

991

991 x 10

9910 + 0 = 9910

9

9

2

1

1

9

9

1

0

2

0

1

4

1

5

2

6

7

3

1

9

9

0

É previamente calculado. Nesta operação matemática a complexidade depende do nº de bits. Custo O(lg m).

O dígito de mais alta ordem foi retirado.

Faz esse processo O(n – m)

Acrescenta a casa decimal para a substring voltar a ter tamanho m

O(1)

rabin karp7
Rabin-Karp

Os 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

3

1

4

1

5

2

7

8

rabin karp8
Rabin-Karp
  • Realiza 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)

Processar o texto e fazer comparações entre dos nº entre as chaves

rabin karp9
Rabin-Karp
  • Aná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)

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ão

O (n/2 x n)

O (n2/2)

1/2 O(n2)

O(n2)

rabin karp10
Rabin-Karp
  • Realiza 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)
rabin karp11
Rabin-Karp

RABIN-KARP-MACHER (T, P, d, q)

  • n ← comprimento[T]
  • m ← comprimento[P]
  • h ← d m-1 mod q
  • p ← 0
  • t0 ← 0
  • for i ← 1 to m \\ Pré-processamento
  • do p ← (dp + P[i]) mod q
  • t0← (t0 + T[i]) mod q
  • for s ← 0 to n-m \\ Emparelhamento
  • do if p = ts
  • then if P [1...m] = T [s + 1 ... s + m]
  • then “Padrão ocorre no deslocamento” s
  • if s < n-m
  • 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

emparelhamento de cadeias com aut matos finitos
Emparelhamento de cadeias com autômatosfinitos
  • Notação:
  • Um autômatofinito é 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 entradafinito

 - Função de transição

aut mato de emparelhamento
Autômato de emparelhamento

Autômatoqueaceita a string “ababaca”.

b, c

c

b

b, c

a

b

b

a

a

b

a

c

a

0

1

2

3

4

5

6

7

c

a

a

a

b, c

b, c

c

aut matos e fun o
Autômatos e função

Entrada

Estado

a b c

0

1

2

3

4

5

6

7

i – 1 2 3 4 5 6 7 8 9 10 11

T[i] - a b a b a b a c a b a

Estado (Ti) 0 1 2 3 4 5 4 5 6 7 2 3

fun o de estado final e fun o sufixo
Função de estado final e funçãosufixo
  • (w) – Função de Estado Final
    • () = q0
    • (wa) = ((w), a) para w  *, a  
  • (x) – Função Sufixo
    • É o comprimento do maislongoprefixo 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 comprimento

m, temos(x) = m  P  x

fun o de transi o fun o de estado final e fun o sufixo
Função de Transição, Função de Estado Final e Função Sufixo
  • A função de transição  é definida pela seguinte equação, para qualquer estado “q” e caractere “a”:
    • (q, a) = (P qa).
  • Uma boa razão intuitiva para a definição anterior é:
    • (Ti) = (Ti)
aut mato de emparelhamento1
Autômato de emparelhamento

T[i] = a b a b a b a c a b a

P = a b a b a c a

b, c

c

b

b, c

a

b

b

a

a

b

a

c

a

0

1

2

3

4

5

6

7

c

a

a

a

b, c

b, c

c

aut mato de emparelhamento2
Autômato de emparelhamento

T[i] = a b a b a b a c a b a

P = a b a b a c a

b, c

c

b

b, c

a

b

b

a

a

b

a

c

a

0

1

2

3

4

5

6

7

c

a

a

a

b, c

b, c

c

aut mato de emparelhamento3
Autômato de emparelhamento

T[i] = a b a b a b a c a b a

P = a b a b a c a

b, c

c

b

b, c

a

b

b

a

a

b

a

c

a

0

1

2

3

4

5

6

7

c

a

a

a

b, c

b, c

c

aut mato de emparelhamento4
Autômato de emparelhamento

T[i] = a b a b a b a c a b a

P = a b a b a c a

b, c

c

b

b, c

a

b

b

a

a

b

a

c

a

0

1

2

3

4

5

6

7

c

a

a

a

b, c

b, c

c

aut mato de emparelhamento5
Autômato de emparelhamento

T[i] = a b a b a b a c a b a

P = a b a b a c a

b, c

c

b

b, c

a

b

b

a

a

b

a

c

a

0

1

2

3

4

5

6

7

c

a

a

a

b, c

b, c

c

aut mato de emparelhamento6
Autômato de emparelhamento

T[i] = a b a b a b a c a b a

P = a b a b a c a

b, c

c

b

b, c

a

b

b

a

a

b

a

c

a

0

1

2

3

4

5

6

7

c

a

a

a

b, c

b, c

c

aut mato de emparelhamento7
Autômato de emparelhamento

T[i] = a b a b a b a c a b a

P = a b a b a c a

b, c

c

b

b, c

a

b

b

a

a

b

a

c

a

0

1

2

3

4

5

6

7

c

a

a

a

b, c

b, c

c

aut mato de emparelhamento8
Autômato de emparelhamento

T[i] = a b a b a b a c a b a

P = a b a b a c a

b, c

c

b

b, c

a

b

b

a

a

b

a

c

a

0

1

2

3

4

5

6

7

c

a

a

a

b, c

b, c

c

aut mato de emparelhamento9
Autômato de emparelhamento

T[i] = a b a b a b a c a b a

P = a b a b a c a

b, c

c

b

b, c

a

b

b

a

a

b

a

c

a

0

1

2

3

4

5

6

7

c

a

a

a

b, c

b, c

c

aut mato de emparelhamento10
Autômato de emparelhamento

T[i] = a b a b a b a c a b a

P = a b a b a c a

b, c

c

b

b, c

a

b

b

a

a

b

a

c

a

0

1

2

3

4

5

6

7

c

a

a

a

b, c

b, c

c

automato de emparelhamento
Automato de Emparelhamento

FINITE-AUTOMATON-MATCHER(T, , m)

n  comprimento[T]

q  0

fori  1 to n

do q (q, T[i])

if q = m

thenimprimir “padrãoocorre com deslocamento” i-m

(n)

computando a fun o de transi o
Computando a função de Transição

COMPUTE-TRANSITION-FUNCTION(P, )

m  comprimento[P]

forq  0 to m

do for cadacaractere “a” 

dokmin(m+1, q+2)

repeat k  k-1

untilPkPqa

(q, a)  k

return

m* m* m*|| = O(m3| |)

algoritmo kmp knuth morris pratt
Algoritmo KMP (Knuth-Morris-Pratt)
  • Algoritmo de emparelhamentoem tempo linear;
  • Evitaporcompleto o cálculodafunção de transição;
  • Evita testes de deslocamentoinúteis;
algoritmo kmp fun o prefixo
Algoritmo KMP – Função Prefixo

Definição:

  • A funçãoprefixopara o padrão P é a função:

{1, 2, …, m}  {0, 1, …, m-1} talque

*[q] = max{k: k<q e PkPq}

  • Emoutraspalavras: [q] é o comprimento do prefixomaislongo de P quetambém é sufixo de Pq.
algoritmo kmp knuth morris pratt1
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0

P = 1 0 1 0 0 1 1 1

Ôba!

algoritmo kmp knuth morris pratt2
Algoritmo KMP (Knuth – Morris – Pratt)

T = 10 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0

P = 10 1 0 0 1 1 1

Ôba!

algoritmo kmp knuth morris pratt3
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0

P = 1 0 1 0 0 1 1 1

Êpa!

Antes do erro a string “10”foi lida no texto. Logo o padrãonãoprecisa ser comparado com a segundaposição do texto.

algoritmo kmp knuth morris pratt4
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0

P = 1 0 1 0 0 1 1 1

P = 1 0 1 0 0 1 1 1

Êpa!

algoritmo kmp knuth morris pratt5
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0

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

Ôba!

algoritmo kmp knuth morris pratt6
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 10 1 1 0 1 0 1 0 0 1 1 1 0 0

P = 1 0 1 0 0 1 1 1

P = 1 0 1 0 0 1 1 1

P = 10 1 0 0 1 1 1

Ôba!

algoritmo kmp knuth morris pratt7
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 101 1 0 1 0 1 0 0 1 1 1 0 0

P = 1 0 1 0 0 1 1 1

P = 1 0 1 0 0 1 1 1

P = 101 0 0 1 1 1

Ôba!

algoritmo kmp knuth morris pratt8
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0

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

Êpa!

A última substring lidafoi “101”. Logo o padrãopodeavançar 2 posições a direita

algoritmo kmp knuth morris pratt9
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0

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

Ôba!

algoritmo kmp knuth morris pratt10
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0

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

Êpa!

algoritmo kmp knuth morris pratt11
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0

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

Ôba!

algoritmo kmp knuth morris pratt12
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 10 1 0 1 0 0 1 1 1 0 0

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 = 10 1 0 0 1 1 1

Ôba!

algoritmo kmp knuth morris pratt13
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 101 0 1 0 0 1 1 1 0 0

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 = 101 0 0 1 1 1

Ôba!

algoritmo kmp knuth morris pratt14
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 101 0 1 0 0 1 1 1 0 0

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 = 1010 0 1 1 1

Ôba!

algoritmo kmp knuth morris pratt15
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0

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

Êpa!

algoritmo kmp knuth morris pratt16
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0

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

P = 1 0 1 0 0 1 1 1

Ôba!

algoritmo kmp knuth morris pratt17
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 10 1 0 0 1 1 1 0 0

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

P = 10 1 0 0 1 1 1

Ôba!

algoritmo kmp knuth morris pratt18
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 101 0 0 1 1 1 0 0

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

P = 101 0 0 1 1 1

Ôba!

algoritmo kmp knuth morris pratt19
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 1010 0 1 1 1 0 0

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

P = 1010 0 1 1 1

Ôba!

algoritmo kmp knuth morris pratt20
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 10100 1 1 1 0 0

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

P = 10100 1 1 1

Ôba!

algoritmo kmp knuth morris pratt21
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 101001 1 1 0 0

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

P = 101001 1 1

Ôba!

algoritmo kmp knuth morris pratt22
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 1010011 1 0 0

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

P = 1010011 1

Ôba!

algoritmo kmp knuth morris pratt23
Algoritmo KMP (Knuth – Morris – Pratt)

T = 1 0 0 1 0 1 1 0 10100111 0 0

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

P = 10100111

algoritmo compute prefix function
Algoritmo Compute-Prefix-Function

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 

algoritmo compute prefix function1
Algoritmo Compute-Prefix-Function

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 

algoritmo compute prefix function2
Algoritmo Compute-Prefix-Function

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 

algoritmo compute prefix function3
Algoritmo Compute-Prefix-Function

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 

algoritmo compute prefix function4
Algoritmo Compute-Prefix-Function

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 

algoritmo compute prefix function5
Algoritmo Compute-Prefix-Function

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 

algoritmo compute prefix function6
Algoritmo Compute-Prefix-Function

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 

algoritmo compute prefix function7
Algoritmo Compute-Prefix-Function

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 

algoritmo compute prefix function8
Algoritmo Compute-Prefix-Function

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 

algoritmo compute prefix function9
Algoritmo Compute-Prefix-Function

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

algoritmo kmp knuth morris pratt24
Algoritmo KMP (Knuth–Morris–Pratt)

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ãoocorre com deslocamento” i – m

q  [q]

(n)  Amortizada

knuth morris pratt kmp
Knuth-Morris-Pratt (KMP)

Exemplo de busca em texto

boore moore
Boore Moore
  • 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 moore1
Boore Moore

Exemplo de busca em texto

boore moore2
Boore Moore

Exemplo de busca em texto

bibliografia
Bibliografia
  • http://en.wikipedia.org/wiki/String_searching_algorithm
  • http://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.