You are on page 1of 10

UNIVERSIDAD NACIONAL DE SAN AGUSTN

FACULTAD DE INGENIERIA DE PRODUCCION Y SERVICIOS

ESCUELA PROFESIONAL INGENIERA DE SISTEMAS

STRING MATCHING WITH FINITE


AUTOMATA

PROYECTO FINAL

CURSO: ANLISIS Y DISEO DE ALGORITMOS

DOCENTE: Carlo Corrales

Alumnos:

Medina Coaquira, Miguel


Miranda Cosi, Jesus
Uraccahua Barrios, Heber

Arequipa-Per
Contenido
INTRODUCCION ........................................................................................................................ 2
AUTOMATA FINITO .................................................................................................................. 3
AUTOMATA DE STRING MATCHING........................................................................................... 4
PSEUDOCODIGO DE STRING MATCHING USANDO UN AUTOMATA FINITO: ............................... 5
FUNCION DE TRANSICION: ........................................................................................................ 6
Seguimiento String Matching basado en Autmatas Finitos ...................................................... 6
COMPLEJIDAD TEMPORAL ........................................................................................................ 6
CODIGO AUTOMATA MATCHER EN JAVA .................................................................................. 7
BIBLIOGRAFIA ........................................................................................................................... 9

1
CONCORDANCIA DE CADENAS

INTRODUCCION

Los programas de edicin de texto frecuentemente necesitan encontrar todas las


ocurrencias de un patrn en el texto. Normalmente, el texto es un documento que se est
editando y el patrn buscado es una palabra particular suministrada por el usuario. Los
algoritmos eficientes para este problema, llamados "String matching", pueden ayudar
en gran medida a la capacidad de respuesta del programa de edicin de texto.

Entre sus muchas otras aplicaciones, los algoritmos de comparacin de cadenas buscan
patrones particulares en las secuencias de ADN. Los motores de bsqueda de Internet
tambin los utilizan para encontrar pginas web relevantes para las consultas.

Formalizamos el problema de concordancia de cadenas de la siguiente manera:

Suponemos que el texto es una matriz de longitud y que el patrn es una matriz
de longitud < . Asumimos adems que los elementos de y son caracteres
extrados de un alfabeto finito .

Por ejemplo, podemos tener = {0,1} o = {, , . . . , }. Las matrices de caracteres


y se llaman frecuentemente cadenas de caracteres.

Texto

Patron

Haciendo referencia a la figura, decimos que el patrn ocurre con el desplazamiento


en el texto (o, equivalentemente, que el patrn comienza a partir de la posicin
+ 1 en el texto ) si 0 < < y { + 1, . . . , + } = [1, , ] (es decir,
si [ + ]? = [], para 1 < < ). Si ocurre con el cambio , entonces
llamamos un cambio vlido; De lo contrario, llamamos un cambio no vlido.

El problema de concordancia de cadenas es el problema de encontrar todos los turnos


vlidos con los que se produce un patrn dado en un texto dado .

Cuadro comparativo entre distintos algoritmos:

Algoritmo Tiempo de procesamiento Tiempo de Matching


Naive 0 (( + 1) )
Rabin-Karp ( ) (( + 1) )
Automata finito (||) ()
KNP ( ) ( )

2
Muchos algoritmos de comparacin de cadenas construyen un autmata finito, una
mquina simple para procesar informacin, que explora la cadena de texto para todas
las ocurrencias del patrn . Esta seccin presenta un mtodo para construir tal
autmata.

Estos autmatas de String matching son muy eficientes: examinan cada carcter de texto
exactamente una vez, tomando un tiempo constante por carcter de texto. El tiempo de
matching utilizado (despus de pre procesar el patrn para construir el autmata) es
( ). El tiempo para construir el autmata, sin embargo, puede ser grande si es
grande.

Comenzamos con la definicin de un autmata finito. A continuacin, examinamos un


autmata especial de adaptacin de cadenas y mostramos cmo usarlo para encontrar
ocurrencias de un patrn en un texto. Finalmente, mostraremos cmo construir el
autmata de String matching para un patrn de entrada dado.

AUTOMATA FINITO

Un autmata finito es una 5 : (, 0 , , , ), donde:

: .
0 : , 0 .
: , .
: .
: Qx Q,


a b
0 1 0
1 0 0

El autmata finito comienza en estado 0 y lee los caracteres de su cadena de entrada


uno a la vez. Si el autmata est en estado y lee el carcter de entrada , se mueve
("hace una transicin") desde el estado al estado (, ) . Siempre que su estado
actual sea un miembro de , el autmata ha aceptado la cadena leda hasta ahora.
Se rechaza una entrada que no se acepta.

Un autmata finito induce una funcin , llamada funcin de estado final, de a


tal que () es el estado que termina despus de escanear la cadena . As,
acepta una cadena si y slo si () . Definimos la funcin recursivamente,
usando la funcin de transicin:

() = 0
() = (() , ) ,

3
AUTOMATA DE STRING MATCHING

Para un patrn dado , construimos un autmata de concordancia de cadenas en un paso


de pre procesamiento antes de usarlo para buscar la cadena de texto. La figura muestra
cmo construimos el autmata para el patrn = . A partir de ahora,
asumiremos que es una cadena de patrones fijos dada; no indicaremos la dependencia
de en nuestra notacin.

Con el fin de especificar el autmata de String matching correspondiente a un patrn


dado [1, , ], definimos primero una funcin auxiliar , llamada la funcin de sufijo
correspondiente a . La funcin mapea a {0, 1, , } tal que () es la longitud
del prefijo ms largo de que es tambin un sufijo de :

( ) = max {: }

Un diagrama de transicin de estado para el autmata de String matching que acepta


todas las cadenas que terminan en la cadena . El estado es el estado inicial y
el estado (mostrado ennegrecido) es el nico estado aceptable. Una arista dirigida
desde el estado al estado con etiqueta se representa como (, ) = .

Las aristas a la derecha que forman la "espina" del autmata, mostrados resaltados en la
figura, corresponden a coincidencias exitosas entre los caracteres de patrn y de entrada.

Las aristas a la izquierda corresponden a las coincidencias fallidas. Algunas aristas


correspondientes a coincidencias fallidas se omiten, por convencin, si un estado no
tiene una arista saliente etiquetado con para algn , entonces (, ) = .

entradas
estado a b c
0 1 0 0 a
1 1 2 0 b
2 3 0 0 a
3 1 4 0 b
4 5 0 0 a
5 1 4 6 c
6 7 0 0 a
7 1 2 0

4
La funcin de transicin correspondiente , y la cadena de patrones = . Las
entradas correspondientes a coincidencias exitosas entre patrn y caracteres de entrada
se muestran sombreadas.

1 2 3 4 5 6 7 8 9 10 11
[ ] a b a b a b a c a b a
( ) 0 1 2 3 4 5 4 5 6 7 2 3

El funcionamiento del autmata en el texto = . Bajo cada carcter de


texto [] aparece el estado ( ) en que el autmata est despus de procesar el
prefijo []. El autmata encuentra una ocurrencia del patrn, terminando en la posicin
9.

PSEUDOCODIGO DE STRING MATCHING USANDO UN


AUTOMATA FINITO:

Para aclarar el funcionamiento de un autmata de String matching, ahora damos un


programa simple y eficiente para simular el comportamiento de tal autmata
(representado por su funcin de transicin ). Para encontrar ocurrencias de un patrn
de longitud en un texto de entrada [, , ].

Como para cualquier autmata de String matching para un patrn de longitud , el


conjunto de estados es {0, 1, , }, el estado de inicio es , y el nico estado de
aceptacin es el estado .

5
FUNCION DE TRANSICION:

Seguimiento String Matching basado en Autmatas Finitos

COMPLEJIDAD TEMPORAL

6
CODIGO AUTOMATA MATCHER EN JAVA

public static final class AutomatonMatcher {

/**
* This static method implements the algorithm for exact string matching
* that constructs a finite automaton, and uses it in order to detect
* a pattern. The running time is {@code n + sm}, where {@code n} is the
* length of the text to search, {@code m} is the length of the pattern,
* and {@code s} is the amount of distinct characters in the pattern.
*
* @param text the text to search in.
* @param pattern the pattern to search for.
* @param startIndex the character index from which to start matching.
* @return the smallest index no less than {@code startIndex} of the
* position where the pattern occurs if there is a match, or
* {@code NOT_FOUND_INDEX} if there is no match.
*/
public static int match(String text, String pattern, int startIndex) {
if (pattern.isEmpty()) {
return 0;
}

int n = text.length();
Integer m = pattern.length();

if (m > n) {
return NOT_FOUND_INDEX;
}

TransitionFunction transitionFunction =
computeTransitionFunction(pattern);

Integer j = 0;

for (int i = Math.max(0, startIndex); i < n; ++i) {


if (j == null) {
j = 0;
}

j = transitionFunction.getState(j, text.charAt(i));

if (m.equals(j)) {
return i - m + 1;
}
}

return NOT_FOUND_INDEX;
}

7
public static int match(String text, String pattern) {
return match(text, pattern, 0);
}

private static TransitionFunction


computeTransitionFunction(String pattern) {
return new TransitionFunction(pattern);
}

private static final class TransitionFunction {

private final Map<Character, Integer>[] function;

TransitionFunction(String pattern) {
int m = pattern.length();
this.function = new HashMap[m + 1];

Set<Character> filter = new HashSet(m);

for (Character c : pattern.toCharArray()) {


filter.add(c);
}

int numberOfCharacters = filter.size();


Character[] characterArray = new Character[numberOfCharacters];
filter.toArray(characterArray);

for (int i = 0; i < function.length; ++i) {


function[i] = new HashMap<>(numberOfCharacters);
}

for (int i = 0; i < numberOfCharacters; ++i) {


function[0].put(characterArray[i], 0);
}

function[0].put(pattern.charAt(0), 1);

for (int i = 1, lps = 0; i <= m; ++i) {


for (int x = 0; x < numberOfCharacters; ++x) {
function[i].put(characterArray[x],
function[lps].get(characterArray[x]));
}

if (i < m) {
function[i].put(pattern.charAt(i), i + 1);
lps = function[lps].get(pattern.charAt(i));
}
}
}

8
Integer getState(int currentState, char character) {
return function[currentState].get(character);
}

@Override
public String toString() {
StringBuilder sb = new StringBuilder();
Set<Character> alphabet = new TreeSet<>(function[0].keySet());
Character[] array = new Character[alphabet.size()];
alphabet.toArray(array);

for (Map<Character, Integer> map : function) {


for (Character c : array) {
sb.append(map.get(c)).append(' ');
}

sb.append('\n');
}

return sb.toString();
}
}
}

BIBLIOGRAFIA

1. https://www.ics.uci.edu/~eppstein/161/960222.html
2. D. Gusfield: Algorithms on Strings, Trees, and Sequences. Cambridge University Press,
1997.
3. T.H. Cormen, C.E. Leiserson, R.L. Rivest, C. Stein: Introduction to Algorithms (3rd ed.).
MIT Press, 2009.
4. http://web.cs.mun.ca/~wang/courses/cs6783-13f
5. http://stackoverflow.com/questions/36820916/finite-automata-string-matcher
6. http://codereview.stackexchange.com/questions/110097/collection-of-exact-string-
matching-algorithms-in-java