A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

Cin – UFPE Danielle Nathália Gomes da Silva Anderson Paulo da Silva {dngs, Recife, Junho de 2008 1.

Apresentações semelhantes


Apresentação em tema: "Cin – UFPE Danielle Nathália Gomes da Silva Anderson Paulo da Silva {dngs, Recife, Junho de 2008 1."— Transcrição da apresentação:

1 Cin – UFPE Danielle Nathália Gomes da Silva Anderson Paulo da Silva {dngs, aps3} @cin.ufpe.br Recife, Junho de 2008 1

2 1. Motivação 2. Definição 3. Notação e Terminologia 4. Algoritmos 1. Força Bruta Simples 2. Rabin-Karp 3. Emparelhamento por Autômato Finito 4. Knuth-Moris Pratt. 2

3 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

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

5 1. 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

6 6 AlgoritmoTempo de pré- processamento Tempo de Emparelhamento Simples0 Ο ((n-m+1)m) Rabin-Karp Θ (m) Ο ((n-m+1)m) Autômato Finito Ο (m 3 ||) Θ (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.

7 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 7 abbaacbc caa

8 Quando o padrão P ocorre? Quando temos um deslocamento valido? 1. Se 0 s n - m 2. T [s+1... s+m] = P [1... m] 3. T [s+j] = P [j], para 1 j m 8

9 1. Se 0 s n - m (Possíveis valores de s) s=0 s=1 s=2 s=3 s=4 s=5 9 abcaabbc ccc ccc ccc ccc ccc ccc

10 2. T [s+1... s+m] = P [1... m] T n = 8 P s=2 m = 3 T [2+1... 2+3] = P [1... 3] T [3, 4, 5] = P [1, 2, 3] 10 abcaabbc ccc

11 3. 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] 11 abcaabbc ccc Verifica para todos os valores de j

12 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 12

13 1. 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 w x, se x=yw para y *. Então se w x, |w| |x|. Ex.: cca abcca 13

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

15 15 b. Se |x| |y|, então, y x. X Z Y X Y

16 16 c. Se |x| |y|, então, y x. X Z Y X Y

17 Trazendo para nosso contexto: 1. Denotaremos o prefixo de k caracteres P[1...k] do padrão P[1...m] por P k. 2. Então, P 0 = ε e P m =P=P[1...m]. 3. Também denota-se para k caracteres do texto T como T k. Objetivo: Encontrar s válidos tal que P T s+m. 17

18 T 1...n T k 1...k P 1...m P k 1...k Ilustrando: T n = 6 P s=0 m = 3, P T s+m -> P T 3 s=1 P T 4 s=2 P T 5 s=3 P T 6 18 aabacbaa acb c aa aabacbaa acb c aa aabac acbaa acbaa a aaa aaa aaa aa a

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

20 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ção de igualdade

21 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 bcaabbcbcaabbc aabbc aabbc aabbc aabbc Se m = n/2, Então O (n/2 x n) O (n 2 /2) 1/2 O(n 2 ) O(n 2 )

22 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 22 000010001010001 0001 0001 0001 0001 0001 0001 0001

23 23 Exemplo de busca em texto Textodeexemploparaumabuscadireta Exem exem exem exem exem exem exem exem exem exem

24 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

25 Cada caractere será um dígito decimal 31415 corresponde ao nº decimal 31.415......... 25 235902314152673 9921 893 11 017845 1011 79 Os padrões podem ser texto Por isso precisamos verifica a condição de igualdade

26 Acrescentando notação: p – número correspondente de P; t s – 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 = t s. Como calcular p e t s ? 26

27 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]) )) 27 1991 = alfabeto || = tamanho de Dado um caractere, a representação numérica deste será sua posição no alfabeto

28 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 t 0 pode ser calculado de modo semelhante, mas os t 1... t n-m ? 28 2359023141526739921 2359

29 Para calcular os t s, com s = 1... n-m. Temos s=6. t s+1 = 10(t s – 10 m-1 T[s+1]) + T[s+m+1] t s+1 = 10(31415 – 30000) + 2 t s+1 = 10(1415) + 2 t s+1 = 14152......... 29 2359023141526739921 893 11 017845 1011 79 Remove o dígito de mais alta ordem de t s.

30 10 m-1 T[s+1] – Remover dígito de mais alta ordem. 1991 – 10 m-1 1991 – 1000 991 991 x 10 9910 + 0 = 9910 30 1991020141526739921 1990 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)

31 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(t s – 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 d m-1 31 314152 78

32 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) 32 Processar o texto e fazer comparações entre dos nº entre as chaves

33 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) 33 2222222222222222222 2222 Se m = n/2, Então O (n/2 x n) O (n 2 /2) 1/2 O(n 2 ) O(n 2 )

34 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 (n 2 ) 34

35 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 t 0 0 6 for i 1 to m \\ Pré-processamento 7 do p (dp + P[i]) mod q 8 t 0 (t 0 + T[i]) mod q 9 for s 0 to n-m \\ Emparelhamento 10 do if p = t s 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(t s – 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

36 36

37 37

38 Notação: Um autômato finito é uma 5-tupla (Q, q 0, A,, ) Onde: Q – Conjunto de estados q 0 - Estado Inicial (q 0 Q) A – Conjunto de estados de aceitação (A Q) - Alfabeto de entrada finito - Função de transição

39 Autômato que aceita a string ababaca. 01256347 a b abaac b, ca c c a a b c b a

40 40 100 120 300 140 500 146 700 120 a b c Entrada Estado 0123456701234567 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

41 1. (w) – Função de Estado Final ( ) = q 0 (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: P k x} P = ab ( ) = 0 (ccaca) = 1 (ccab) = 2 Para um padrão P de comprimento m, temos (x) = m P x

42 1. A função de transição é definida pela seguinte equação, para qualquer estado q e caractere a: (q, a) = (P q a). 2. Uma boa razão intuitiva para a definição anterior é: (T i ) = (T i )

43 43 T[i ] = a b a b a b a c a b a P = a b a b a c a 01256347 a b abaac b, ca c c a a b c b a

44 44 T[i ] = a b a b a b a c a b a P = a b a b a c a 01256347 a b abaac b, ca c c a a b c b a

45 45 T[i ] = a b a b a b a c a b a P = a b a b a c a 01256347 a b abaac b, ca c c a a b c b a

46 46 T[i ] = a b a b a b a c a b a P = a b a b a c a 01256347 a b abaac b, ca c c a a b c b a

47 47 T[i ] = a b a b a b a c a b a P = a b a b a c a 01256347 a b abaac b, ca c c a a b c b a

48 48 T[i ] = a b a b a b a c a b a P = a b a b a c a 01256347 a b abaac b, ca c c a a b c b a

49 49 T[i ] = a b a b a b a c a b a P = a b a b a c a 01256347 a b abaac b, ca c c a a b c b a

50 50 T[i ] = a b a b a b a c a b a P = a b a b a c a 01256347 a b abaac b, ca c c a a b c b a

51 51 T[i ] = a b a b a b a c a b a P = a b a b a c a 01256347 a b abaac b, ca c c a a b c b a

52 52 T[i ] = a b a b a b a c a b a P = a b a b a c a 01256347 a b abaac b, ca c c a a b c b a

53 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)

54 COMPUTE-TRANSITION-FUNCTION(P, ) m comprimento[P] for q 0 to m do for cada caractere a do k min(m+1, q+2) repeat k k-1 until P k P q a (q, a) k return m* m* m*| | = O(m 3 | |)

55 Algoritmo de emparelhamento em tempo linear; Evita por completo o cálculo da função de transição; Evita testes de deslocamento inúteis;

56 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 { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.com.br/5/1594246/slides/slide_56.jpg", "name": "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

57 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 57 Ôba!

58 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 58 Ôba!

59 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 59 Êpa! Antes do erro a string 10foi lida no texto. Logo o padrão não precisa ser comparado com a segunda posição do texto.

60 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 60 Êpa!

61 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 61 Ôba!

62 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 62 Ôba!

63 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 63 Ôba!

64 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 64 Êpa! A última substring lida foi 101. Logo o padrão pode avançar 2 posições a direita

65 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 65 Ôba!

66 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 66 Êpa!

67 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 67 Ôba!

68 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 68 Ôba!

69 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 69 Ôba!

70 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 70 Ôba!

71 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 71 Êpa!

72 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 72 Ôba!

73 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 73 Ôba!

74 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 74 Ôba!

75 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 75 Ôba!

76 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 76 Ôba!

77 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 77 Ôba!

78 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 78 Ôba!

79 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 79

80 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 12345678910 P[i] ababababca [i ] 0

81 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 12345678910 P[i] ababababca [i ] 00

82 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 12345678910 P[i] ababababca [i ] 001

83 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 12345678910 P[i] ababababca [i ] 0012

84 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 12345678910 P[i] ababababca [i ] 00123

85 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 12345678910 P[i] ababababca [i ] 001234

86 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 12345678910 P[i] ababababca [i ] 0012345

87 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 12345678910 P[i] ababababca [i ] 00123456

88 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 12345678910 P[i] ababababca [i ] 001234560

89 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 12345678910 P[i] ababababca [i ] 0012345601

90 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 i123456789101112131415 P[i]ababababca T[i]ababababababcaa [i ] 0012345601

91 91 Exemplo de busca em texto

92 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);

93 93 Exemplo de busca em texto HooLa-HoolagirlslikeHooligans HooLigan Hooligan Hooligan Hooligan Hooligan

94 94 Exemplo de busca em texto AsTring exampleconsistingof... stiNg sting sting sting sting sting sting

95 http://en.wikipedia.org/wiki/String_searching_algorithm http://dalton.dsc.ufcg.edu.br/edados/index.php/Casament o_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


Carregar ppt "Cin – UFPE Danielle Nathália Gomes da Silva Anderson Paulo da Silva {dngs, Recife, Junho de 2008 1."

Apresentações semelhantes


Anúncios Google