Algoritmo KMP

CAPITULO 2: ESTRATEGIAS ALGORTIMICAS
MsC. Marco Sánchez

Contenido
• Algoritmos de Fuerza-bruta
• Algoritmos Voraces
• Algoritmos Divide y vencerás
• Backtracking (vuelta atrás) recursivo.
• Programación Dinámica
Objetivos de la Clase
Aplicar los conocimientos que le permitan plantear una

metodología para la solución de problemas, utilizando la
computadora a través del diseño de algoritmos.
Introducción
Según la Real Academia Español la algoritmia es la ciencia del

cálculo aritmético y algebraico y su objetivo es la búsqueda
de operaciones que permitan hallar la solución de un
problema. Por tanto, se denomina algoritmo a la solución
encontrada para resolver una problemática dada.
Introducción
A lo largo de la historia, diversos autores han desarrollado

algoritmos para la búsqueda de patrones. Al día de hoy, no
existe un único algoritmo para tal fin, puesto que cada uno
cuenta con un rendimiento que dependerá de unas
condiciones dadas. Estas condiciones pueden ser el número
de patrones a buscar, la longitud de dichos patrones o las
características del texto contra el que se busca.
Búsqueda en texto
La búsqueda de patrones, como su propio nombre indica, consiste en

encontrar en un determinado texto un conjunto de P patrones, donde P
va desde 1 hasta un número finito. No se tendrá en cuenta el caso de las
expresiones regulares, en el que dicho conjunto puede alcanzar un
tamaño infinito.
“Una expresión regular, o expresión racional, es una secuencia de

caracteres que conforma un patrón de búsqueda. También son conocidas
como regex o regexp, por su contracción de las palabras inglesas regular
expression.”
Búsqueda en texto
En general estos algoritmos consisten en buscar las

apariciones de un cierto patrón P en un texto T. Pudiendo
tanto el patrón como el texto ser cadenas numéricas de
números enteros.
Búsqueda en texto
En este capítulo se considerará el problema de buscar la

ocurrencia de un patrón dentro de un texto. Se utilizarán las
siguientes convenciones:
n denotará el largo del texto en donde se buscará el patrón,
es decir, texto = a1 a2 ... an.
m denotará el largo del patrón a buscar, es decir, patrón = b1
b2 ... bm.
Algoritmo Knuth-Morris-Pratt (KMP)
El algoritmo Knuth-Morris-Pratt, también conocido como KMP, fue

creado en 1974 por Donald Knuth, James Hiram Morris y Vaughan
Pratt. Sigue la línea del anterior algoritmo, pero durante el
proceso de búsqueda de patrones realiza una observación
detallada, es decir no sólo compara un carácter con otro, sino que
memoriza lo que sucede previamente y cuando se produce un
fallo en la comparación no desplaza solamente una posición el
patrón respecto al texto, sino que avanza tantas posiciones como
sea necesario, siempre y cuando conozca de antemano que no se
producirá coincidencia alguna en las posiciones anteriores.
Veamos primero las razones de la ineficiencia del método directo con un ejemplo:
T = ‘xyxxyxyxyyxyxyxyyxyxyxx’ P = ‘xyxyyxyxyxx’
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
x y x x y x y x y y x y x y x y y x y x y x x
1 x y x y
2 x
3 x y
4 x y x y y
5 x
6 x y x y y x y x y x x
7 x
8 x y x
9 x
10 x
11 x y x y y
12 x
• Por ejemplo, verificamos dos veces que la subcadena ‘xyxy’ está

en la posición 11 de S (en las líneas 6 y 11).
• En la aplicación de buscar una palabra en un fichero de texto, el
método directo no es muy malo porque las discrepancias
ocurren enseguida y, por tanto, los retrocesos son pequeños.
• Sin embargo, en otras aplicaciones (por ejemplo, biología
molecular) el alfabeto es muy pequeño y hay muchas
repeticiones, por tanto, los retrocesos son mayores.
Otro ejemplo:
T = ‘yyyyyyyyyyyyx’ P = ‘yyyyyx’
• Con el algoritmo de fuerza bruta, las cinco ‘y’ del patrón se comparan con la
cadena madre, se encuentra la discrepancia de la ‘x’, se “desplaza” el patrón un
lugar a la derecha y se hacen cuatro comparaciones redundantes:
• ¡las cuatro primeras ‘y’ ya sabemos que están ahí!
• Se desplaza el patrón un lugar más a la derecha y ¡de nuevo cuatro
comparaciones redundantes !Etcétera.
Un ejemplo más:
T = ‘xyyyyxyyxyyyyy’ P = ‘xyyyyy’
• Buscamos la ocurrencia de una ‘x’ seguida de cinco ‘y’.
• Si el número de ‘y’ no es suficiente, no hay necesidad de volver atrás y
desplazar una posición a la derecha.
• Las cuatro ‘y’ encontradas no valen para nada y hay que buscar una nueva ‘x’.
Volviendo al ejemplo inicial: T = ‘xyxxyxyxyyxyxyxyyxyxyxx’ P = ‘xyxyyxyxyxx’
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
1 x y x y
2 x
3 x y
4 x y x y y
5 x
• Ocurre una discrepancia en p5 (con t8 , la línea 4).
• Los dos caracteres precedentes de T han tenido que ser ‘xy’ (es decir, p3 p4 , porque hasta p4
hubo coincidencia).
• Pero los dos primeros caracteres de P también son ‘xy’, luego no hace falta volverlos a comparar
con p3 p4 .
• Lo ideal sería desplazar P a la derecha el máximo número posible de posiciones (para ahorrar
comparaciones) pero sin perder ninguna posibilidad de encontrar el patrón en T.
• En el ejemplo, hay que desplazar P dos posiciones y continuar comparando s8 con p3
(ahorramos tres comparaciones).
Notar que la discusión anterior es independiente de la cadena madre T.
Conocemos los últimos caracteres de T porque han coincidido con los anteriores del patrón P.
Sigamos con el ejemplo...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
. . . . . . . . . . . . . . . . . . . . . . .
6 x y x y y x y x y x xx
7 x
8 x y x
9 x
10 x
11 x y x y y
12 x
La discrepancia en la línea 6 es en p11

Ahora podemos ahorrarnos 15 comparaciones...
• La discrepancia fue entre p11 y s16 .
• Consideremos el subpatrón p1 p2 ...p10.
• Sabemos que p1 p2 ...p10 = t6 t7 ...t15
• Queremos saber cuántas posiciones hay que desplazar P hacia la derecha hasta que vuelva a existir la
posibilidad de que coincida con una subcadena de T.
• Nos fijamos en el máximo sufijo de p1 p2 ...p10 que coincide con un prefijo de P
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
. . . . . . . . . . . . . . . . . . . . . . .
• En este caso, el sufijo es de longitud 3: ‘xyx’.

• Luego se puede continuar comparando t16 con p4.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
. . . . . . . . . . . . . . . . . . . . . . .
.
• Notar, de nuevo, que toda la información necesaria para saber cuánto hay que
desplazar a la derecha el patrón está incluida en el propio patrón.
• Se puede “preprocesar” (o precondicionar) el patrón para acelerar el algoritmo
de fuerza bruta.
• La idea es la siguiente:
• La cadena madre S siempre se recorre hacia la derecha (no hay retrocesos), aunque un
mismo carácter de S puede compararse con varios del patrón P (cuando haya
discrepancias).
• Cuando haya una discrepancia se consultará una tabla para saber cuánto hay que
retroceder en el patrón o, dicho de otra forma, cuántos desplazamientos del patrón hacia la
derecha pueden hacerse.
• En la tabla hay un entero por cada carácter de P, e indica cuántos desplazamientos hacia la
derecha deben hacerse cuando ese carácter discrepe con uno de la cadena madre.
• Función de fallo de KMP
• Para cada pi de P, hay que calcular el sufijo más largo 𝑝𝑖−𝑗 𝑝𝑖−𝑗+1 … 𝑝𝑖−1 que es
igual al prefijo de P:
• f(i) = max { j | 0<j<i-1, 𝑝𝑖−𝑗 𝑝𝑖−𝑗+1 … 𝑝𝑖−1 = 𝑝1 𝑝2 … 𝑝𝑗 } 0 si no existe tal j
• Reto hallar tabla de fallo:
i 1 2 3 4 5 6 7 8 9 10 11
P x y x y y x y x y x X
f
• Ejemplo
• P=XYXYYXYXYXX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y X X Y X Y Y X Y X Y X Y
P= X Y X Y Y
• Ejemplo
• P=XYXYYXYXYXX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
P= X Y X Y Y
• Ejemplo
• P=XYXYYXYXYXX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
P= X Y X Y Y
• Ejemplo
• P=XYXYYXYXYXX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
P= X Y X Y Y
X Y X Y
• Caso 1: Sin patrón y la letra de fallo del patrón es la misma

que la inicial
• P=ABCA
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= A B C Z ? ? ?
P= A B C A

que la inicial
• P=ABCA
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= A B C Z ? ? ?
P= A B C A
A B C A

que la inicial
• P=ABCA
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= A B C Z ? ? ?
P= A B C A
A B C A

que la inicial
• P=ABCA
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= A B C Z ? ? ?
P= A B C A
A B C A
que la inicial
• P=ABCA
• Situar el inicio del patrón tras el carácter de fallo
• Se representa con -1 en la tabla siguiente de KMP
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= A B C Z ? ? ?
P= A B C A
A B C A
• Caso 2: Sin patrón y la letra de fallo del patrón es distinta
que la inicial
• P=ABCD
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= A B C ? ? ? ?
P= A B C D
que la inicial
• P=ABCD
No es una D, pero puede ser una A
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= A B C ? ? ? ?
P= A B C D
que la inicial
• P=ABCD
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= A B C ? ? ? ?
P= A B C D
A B C D
que la inicial
• P=ABCD
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= A B C ? ? ? ?
P= A B C D
A B C D
que la inicial
• P=ABCD
• Situar el inicio del patrón en el carácter de fallo y volver a comparar desde ese
nuevo inicio.
• Se representa con 0 en la tabla siguiente de KMP
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= A B C ? ? ? ?
P= A B C D
A B C D
• Caso 3: Hay patrón y la letra siguiente al de la izquierda es
distinta al carácter de fallo.
• P=XYXYY
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y Y
• X≠Y
• P=XYXYY
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y Y
• X≠Y
• P=XYXYY
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y Y
• X≠Y
• P=XYXYY
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y Y
• X≠Y
• P=XYXYY
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y Y
• X≠Y
• P=XYXYY
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y Y
• X≠Y X Y X Y
• P=XYXYY
• Situar el inicio del patrón m posiciones a la izquierda del carácter del fallo,
donde m es el tamaño del patrón (m=2 en este ejemplo).
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y Y
• X≠Y X Y X Y
• P=XYXYX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y X
• X=X
• P=XYXYX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y X
• X=X
• P=XYXYX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y X
• X=X
• P=XYXYX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y X
• X=X
• P=XYXYX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y X
X Y X Y
• X=X
• P=XYXYX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y X
X Y X Y
• X=X
• P=XYXYX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y X
X Y X Y
• X=X
• P=XYXYX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y X
X Y X Y
• X=X
• P=XYXYX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y X
• X=X
• P=XYXYX
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y X
• X=X
X Y X Y
• P=XYXYX
• Situar el inicio del patrón donde lo situaría la letra siguiente al patrón de la
izquierda.
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
S= X Y X Y ? ? ?
P= X Y X Y X
• X=X X Y X Y
Calculo tabla siguiente o de fallo
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
P X Y X Y Y X Y X Y X X
Sgte -1
• P=XYXYYXYXYXX
• Para buscar patrones: Se debe buscar el patrón mas largo tal que el patrón
de la izquierda debe empezar en la posición 0 y el patrón de la derecha
debe acabar en la posición anterior al carácter de fallo.
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0
• P=XYXYYXYXYXX
• No hay patrón. X(fallo) igual X(inicial) Caso 1
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0
• P=XYXYYXYXYXX
• No hay patrón. X(fallo) igual X(inicial) Caso 1
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1
• P=XYXYYXYXYXX
• Hay patrón! P[0] == P[2], pero
• Siguiente patrón izquierda (P[1]== carácter fallo (P[3]) Caso 4
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1
• P=XYXYYXYXYXX
• Hay patrón! P[0] == P[2], pero
• Siguiente patrón izquierda (P[1]== carácter fallo (P[3]) Caso 4
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0
• P=XYXYYXYXYXX
Hay patrón! P[0] P[1] == P[2] P[3], y
siguiente patrón izquierda (P[2] ≠ carácter fallo (P[4]) Caso 3
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0
• P=XYXYYXYXYXX
Hay patrón! P[0] P[1] == P[2] P[3], y
siguiente patrón izquierda (P[2] ≠ carácter fallo (P[4]) Caso 3
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2
• P=XYXYYXYXYXX
No hay patrón…. X (fallo) igual X (inicial) Caso 1
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2
• P=XYXYYXYXYXX
No hay patrón…. X (fallo) igual X (inicial) Caso 1
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1
• P=XYXYYXYXYXX
P[6] se comporta como P[1]
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1
• P=XYXYYXYXYXX
P[6] se comporta como P[1]
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0
• P=XYXYYXYXYXX
Hay patrón tamaño 2, pero P[2] igual a carácter de fallo Caso 4
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1 0
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1 0
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1 0
• P=XYXYYXYXYXX
• Hay patrón! P[0]P[1]P[2]P[3] = P[5]P[6]P[7]P[8] y
• Siguiente oatrón izquierda (P[4] ≠ carácter fallo P[9]) Caso 3. Tamaño patrón 4
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1 0
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1 0
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1 0
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1 0 4
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1 0 4
• P=XYXYYXYXYXX
Hay patrón! P[0]P[1]P[2] = P[7]P[8]P[9] y
siguiente patrón izquierda (P[3] ≠ carácter fallo P[10]) Caso 3. Tamaño patrón 3
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1 0 4
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1 0 4
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1 0 4
• P=XYXYYXYXYXX
Pos 0 1 2 3 4 5 6 7 8 9 10
Sgte -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
T x y x x y x y x y y x y x y x y y x y x y x x
P x y x y y x y x y x x
Tabla siguiente (Prefix):

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
x y x y y x y x y x x

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

i 1 2 3 4 5 6 7 8 9 10 11
f -1 0 -1 0 2 -1 0 -1 0 4 3
• P=ABCABCACAB
Pos 0 1 2 3 4 5 6 7 8 9
P A B C A B C A C A B
Sgte
• P=ABCABCACAB
Pos 0 1 2 3 4 5 6 7 8 9
P A B C A B C A C A B
Sgte -1 0 0 -1 0 0 -1 4 -1 0
Codificar algoritmo KMP
• P=xyxyyxyxyxx
i pat[0:i] lps[i] Matching Prefix/Suffix
0 x 0
1 xy 0
2 xyx 1 x
3 xyxy 2 xy
4 xyxyy 0
5 xyxyyx 1 x
6 xyxyyxy 2 xy
7 xyxyyxyx 3 xyx
8 xyxyyxyxy 4 xyxy
9 xyxyyxyxyx 3 xyx
10 xyxyyxyxyxx 1 x
Análisis de la función KMP:
• La cadena madre T se recorre sólo una vez, aunque un carácter 𝑠𝑖 de S puede
que haya que compararlo con varios de P
• ¿Cuántas veces se puede llegar a comparar un carácter 𝑠𝑖 de S con otros de P?
• Supongamos que la primera comparación de si se hace con pk . Por tanto,
en particular, se ha avanzado k veces en P hasta hacer esa comparación y sin
retroceder ninguna vez.
• Si 𝑠𝑖 ≠ 𝑝𝑘 , se retrocede en P (usando la tabla f). Sólo se puede retroceder un
máximo de k veces.
• Si se suma el coste de los retrocesos al de los movimientos de avance,
únicamente se dobla el coste de los avances .Pero el nº de avances en P
coincide con el nº de avances en T y es n. Luego el número de
comparaciones es O(n).
• Con similares argumentos se demuestra que el coste del cálculo de la tabla f es
O(m), luego el coste total es O(n).
Ventajas de KMP
• KMP funciona en el tiempo óptimo: O(m+n) “muy
rápido”
• El algoritmo nunca necesita moverse hacia atrás en el
texto de entrada, T
• esto hace que el algoritmo sea bueno para
procesar archivos muy grandes que se leen desde
dispositivos externos o a través de una secuencia
de red
Desventajas de KMP
• KMP no funciona muy bien como el tamaño del
alfabeto aumenta
• Más posibilidades de un desajuste (más
posibles desajustes)
• Las discrepancias tienden a ocurrir al principio
del patrón, pero KMP es más rápido cuando las
discordancias ocurren más tarde

Algoritmo KMP

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Algoritmo KMP

Cargado por

Copyright:

Formatos disponibles

CAPITULO 2: ESTRATEGIAS ALGORTIMICAS

MsC. Marco Sánchez

Aplicar los conocimientos que le permitan plantear una

Según la Real Academia Español la algoritmia es la ciencia del

A lo largo de la historia, diversos autores han desarrollado

La búsqueda de patrones, como su propio nombre indica, consiste en

“Una expresión regular, o expresión racional,​​ es una secuencia de

En general estos algoritmos consisten en buscar las

En este capítulo se considerará el problema de buscar la

El algoritmo Knuth-Morris-Pratt, también conocido como KMP, fue

• Por ejemplo, verificamos dos veces que la subcadena ‘xyxy’ está

La discrepancia en la línea 6 es en p11

• En este caso, el sufijo es de longitud 3: ‘xyx’.

• Reto hallar tabla de fallo:

• Caso 1: Sin patrón y la letra de fallo del patrón es la misma

• Caso 1: Sin patrón y la letra de fallo del patrón es la misma

• Caso 1: Sin patrón y la letra de fallo del patrón es la misma

• Caso 1: Sin patrón y la letra de fallo del patrón es la misma

No es una D, pero puede ser una A

No es una D, pero puede ser una A

No es una D, pero puede ser una A

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

Tabla siguiente (Prefix):

También podría gustarte

“Una expresión regular, o expresión racional, es una secuencia de