casamento de padrões

Casamento de Padrões

Andrew Cavalcante Pacífico

[email protected]

Instituto de Computação (IComp)

Universidade Federal do Amazonas (UFAM)

Projeto e Análise de Algoritmos

Roteiro

• Introdução

• Definição do Problema

• Algoritmos clássicos

▫ Força Bruta

▫ BMH

▫ Shift-Or

Projeto e Análise de Algoritmos 2

Introdução

• Casamento de padrões possui várias

aplicações:

▫ Editores de texto

▫ Casamento de cadeias de DNA

▫ Recuperação de Informação

• Vários algoritmos propostos


Definição do Problema

• Dadas duas cadeias T e P, verificar se P está

contida em T

• Pode ser exato ou aproximado (com erros)

• Pode ser resolvido em tempo linear em todos os

casos


Casamento de Padrões Exato

• Texto T[1 .. n] e Padrão P[1 .. m]

• Tamanhos n e m, onde m ≤ n

• Encontrar todos os deslocamentos s onde

T[s+1 .. s+m] = P[1 .. m], com 0 ≤ s ≤ n – m


c a d t f l a o p m e n u w g o

a o p m e

T

P s = 6

Casamento de Padrões Aproximado

• Permite inserção, remoção ou substituição de

caracteres no texto

• Número de erros é conhecido como distância de

edição ou distância de Levenshtein

• Objetivo pode ser capturar erros de escrita, ocr

ou simplesmente ajudar um usuário que não

sabe como escrever uma dada palavra


Casamento de Padrões Aproximado

• Inserção

• Remoção

• Substituição


c b a r u a q l o p v c

u a l o

c b a r u a w s o p v c

u a l w

c b a r u a q l o p v c

u a w l

Algoritmos Clássicos


Força Bruta

• Consiste em analisar todas as posições do texto

entre 0 e n - m para verificar ocorrência do

padrão

• O padrão desloca-se no texto como uma janela


Força Bruta

BRUTE-FORCE(T,n,P,m)

1: R Ø

2: for i 1 to n-m+1 do

3: for j 1 to m do

4: if P[j] != T[i+j-1] then

5: break;

6: end if

7: j j + 1

8: end for

9: if j = m+1 then

10: ENQUEUE(R,i);

11: end if

12: end for

13: return R;


Força Bruta


1: R Ø


3: for j 1 to m do


5: break;

6: end if

7: j j + 1

8: end for

9: if j = m+1 then

10: ENQUEUE(R,i);

11: end if

12: end for

13: return R;


u f a m a m u f a m c T

u f a m P

i

1 2 3 4 5 6 7 8 9 10 11 12

j

1 2 3 4

R

Força Bruta


1: R Ø


3: for j 1 to m do


5: break;

6: end if

7: j j + 1

8: end for

9: if j = m+1 then

10: ENQUEUE(R,i);

11: end if

12: end for

13: return R;



u f a m P

i

1 2 3 4 5 6 7 8 9 10 11 12

j

1 2 3 4

R

Força Bruta


1: R Ø


3: for j 1 to m do


5: break;

6: end if

7: j j + 1

8: end for

9: if j = m+1 then

10: ENQUEUE(R,i);

11: end if

12: end for

13: return R;



u f a m P

i

1 2 3 4 5 6 7 8 9 10 11 12

j

1 2 3 4

1 R

Força Bruta


1: R Ø


3: for j 1 to m do


5: break;

6: end if

7: j j + 1

8: end for

9: if j = m+1 then

10: ENQUEUE(R,i);

11: end if

12: end for

13: return R;



u f a m P

i

1 2 3 4 5 6 7 8 9 10 11 12

j

1 2 3 4

1 8 R

Análise do Força Bruta


1: R Ø


3: for j 1 to m do


5: break;

6: end if

7: j j + 1

8: end for

9: if j = m+1 then

10: ENQUEUE(R,i);

11: end if

12: end for

13: return R;


n-m+1 vezes

m vezes

O(1)

T(n) = (n-m+1)m

Qual o problema do Força Bruta ?


Boyer-Moore-Horspool (BMH)

• Idéia básica: otimizar o deslocamento da janela

de comparações

▫ Utiliza heurísticas para saltar caracteres dentro do

texto


BMH – Cálculo dos saltos

• Utiliza-se uma tabela de saltos do tamanho do

alfabeto

• Cada posição da tabela de saltos contém a

distância da última ocorrência do caractere para

o fim do padrão (sem contar a última posição)

▫ Exemplo P = teste

d[t] = 1; d[s] = 2; d[e] = 3; (demais posições da tabela ficam

com um salto do tamanho do padrão)


BMH

BMH(T,n,P,m)

1: for i 1 to Σ do

2: skipTable[i] m;

3: end for

4: for i 1 to m-1 do

5: skipTable[P[i]] m-i;

6: end for

7: i m

8: while i ≤ n do

9: for j 1 downto 1 do

10: if T[i-m+j] != P[j] then

11: break;

12: end if

13: end for

14: if j = 0 then

15: print “Padrão encontrado em: “i

16: end if

17: i i + skipTable[T[i]];

18: end while


BMH

BMH(T,n,P,m)

1: for i 1 to Σ do

2: skipTable[i] m;

3: end for



6: end for

7: i m

8: while i ≤ n do

9: for j m downto 1 do


11: break;

12: end if

13: end for

14: if j = 0 then


16: end if


18: end while


Σ = {a, b, c, d}

4 4 4 4

a b c d

skipTable

a b c a a d b a d b d T

1 2 3 4 5 6 7 8 9 10 11

b c a a P

1 2 3 4

BMH

BMH(T,n,P,m)

1: for i 1 to Σ do

2: skipTable[i] m;

3: end for



6: end for

7: i m

8: while i ≤ n do



11: break;

12: end if

13: end for

14: if j = 0 then


16: end if


18: end while


Σ = {a, b, c, d}

1 3 2 4

a b c d

skipTable


1 2 3 4 5 6 7 8 9 10 11

b c a a P

1 2 3 4

BMH

BMH(T,n,P,m)

1: for i 1 to Σ do

2: skipTable[i] m;

3: end for



6: end for

7: i m

8: while i ≤ n do



11: break;

12: end if

13: end for

14: if j = 0 then


16: end if


18: end while


Σ = {a, b, c, d}

1 3 2 4

a b c d

skipTable


1 2 3 4 5 6 7 8 9 10 11

b c a a P

1 2 3 4

j

i

Análise do BMH

BMH(T,n,P,m)

1: for i 1 to Σ do

2: skipTable[i] m;

3: end for



6: end for

7: i m

8: while i ≤ n do



11: break;

12: end if

13: end for

14: if j = 0 then


16: end if


18: end while


Qual é o melhor caso do

algoritmo ? E o pior ?

Análise do BMH

• Pior caso acontece quando os deslocamentos

são apenas de 1 em 1.

▫ Custo nesse caso: O(nm)

• Melhor caso acontece quando os

deslocamentos são do tamanho do padrão

▫ Custo nesse caso: O(n/m)


Análise do BMH – Pior caso

• Ocorre quando a disposição dos caracteres do

texto e do padrão geram a seguinte situação:


a a a a a a a a a a a T

1 2 3 4 5 6 7 8 9 10 11

b a a a P

1 2 3 4

Σ = {a, b, c, d}

1 3 4 4

a b c d

skipTable

j

i






1 2 3 4 5 6 7 8 9 10 11

b a a a P

1 2 3 4

Σ = {a, b, c, d}

1 3 4 4

a b c d

skipTable

j

i






1 2 3 4 5 6 7 8 9 10 11

b a a a P

1 2 3 4

Σ = {a, b, c, d}

1 3 4 4

a b c d

skipTable

j

i

Comportamento se

repete até o final do

texto






1 2 3 4 5 6 7 8 9 10 11

b a a a P

1 2 3 4

Σ = {a, b, c, d}

1 3 4 4

a b c d

skipTable

j

i

Comportamento se

repete até o final do

texto

(n-m+1)m operações

serão realizadas


BMH(T,n,P,m)

1: for i 1 to Σ do

2: skipTable[i] m;

3: end for



6: end for

7: i m

8: while i ≤ n do



11: break;

12: end if

13: end for

14: if j = 0 then


16: end if


18: end while


Pré-Processamento

O( 𝛴 )

Emparelhamento

n - m + 1 vezes m vezes

O(1)

T(n) = O( 𝛴 ) + (n-m+1)m

T(n) = O(nm)

Análise do BMH – Melhor caso




c d a b c d a b c b a T

1 2 3 4 5 6 7 8 9 10 11

b a a a P

1 2 3 4

Σ = {a, b, c, d}

1 3 4 4

a b c d

skipTable

j

i






1 2 3 4 5 6 7 8 9 10 11

b a a a P

1 2 3 4

Σ = {a, b, c, d}

1 3 4 4

a b c d

skipTable

j

i






1 2 3 4 5 6 7 8 9 10 11

b a a a P

1 2 3 4

Σ = {a, b, c, d}

1 3 4 4

a b c d

skipTable

j

i

𝑛/𝑚 operações

são realizadas


BMH(T,n,P,m)

1: for i 1 to Σ do

2: skipTable[i] m;

3: end for



6: end for

7: i m

8: while i ≤ n do



11: break;

12: end if

13: end for

14: if j = 0 then


16: end if


18: end while


Pré-Processamento

O( 𝛴 )

Emparelhamento

𝑛/𝑚 vezes 1 vez

O(1)

T(n) = O( 𝛴 ) + ( 𝑛/𝑚 )(O(1))

T(n) = O(n/m)

Shift-And

• A idéia do algoritmo é guardar todos os prefixos

de P que casem com um sufixo do texto lido

▫ Utiliza máscara de bits para agilizar as operações

▫ Pode ser visto como a simulação de um autômato

que pesquisa o padrão no texto


Shift-And

Ex:

T = “ABCDEUFAMFGHI”

P = “UFAM”


Shift-And

SHIFT-AND(T,n,P,m)

1: for i 1 to Σ do

2: Masc[i] 0m;

3: end for

4: for i 1 to m do

5: Masc[P[i]] M[P[i]] | 0j-110m-j;

6: end for

7: R 0m;

8: for i 1 to n do

9: R ((R >> 1) | 10m-1) & Masc[T[i]];

10: if R & 0m-11 != 0m then

11: print “Padrão encontrado em: “i-m+1;

12: end if

13: end for


Análise do Shift-And

SHIFT-AND(T,n,P,m)

1: for i 1 to Σ do

2: Masc[i] 0m;

3: end for

4: for i 1 to m do

5: Masc[P[i]] M[P[i]] | 0j-110m-j;

6: end for

7: R 0m;

8: for i 1 to n do

9: R ((R >> 1) | 10m-1) & Masc[T[i]];

10: if R & 0m-11 != 0m then

11: print “Padrão encontrado em: “i-m+1;

12: end if

13: end for


Pré-Processamento

O( 𝛴 )

Emparelhamento

n vezes

O(1)


• Custo total do algoritmo

T(n) = O( 𝛴 ) + n * O(1)

T(n) = O(n)




T(n) = O( 𝛴 ) + n * O(1)

T(n) = O(n)


Desde que as

operações de

manipulação dos bits

sejam O(1)

Shift-And


O que fazer para o algoritmo suportar erros ?

Shift-And Aproximado

• Autômato com suporte a erros:


Shift-And Aproximado


SHIFT-AND-APROXIMADO(T,n,P,m,k)

1: Pré-Processamento (igual ao Shift-And Exato)

2: for j 0 to k do R[j] 1j0m-1; end for

3: for i 1 to n do

4: Rant R[0];

5: Rnovo ((Rant >> 1) | 10m-1) & Masc[T[i]];

6: R[0] Rnovo;

7: for j 1 to k do

9: Rnovo (R >> 1 & Masc[T[i]]) | Rant |

((Rant | Rnovo) >> 1);

10: Rant R[j];

11: R[j] Rnovo|10m-1;

12: end for

13: if Rnovo & 0m-11 != 0m; end if

13: end for

Análise do Shift-And Aproximado


SHIFT-AND-APROXIMADO(T,n,P,m,k)

1: Pré-Processamento (igual ao Shift-And Exato)

2: for j 0 to k do R[j] 1j0m-1; end for

3: for i 1 to n do

4: Rant R[0];

5: Rnovo ((Rant >> 1) | 10m-1) & Masc[T[i]];

6: R[0] Rnovo;

7: for j 1 to k do

9: Rnovo (R >> 1 & Masc[T[i]]) | Rant |

((Rant | Rnovo) >> 1);

10: Rant R[j];

11: R[j] Rnovo|10m-1;

12: end for

13: if Rnovo & 0m-11 != 0m; end if

13: end for

k vezes

O(1)

n vezes

k vezes

Análise do Shift-And Aproximado


T(n) = O( 𝛴 ) + k + nk

T(n) = O(nk)


casamento de padrões

Documents