05 - Strings

Strings
Leopoldo Taravilse1
1 Facultad
de Ciencias Exactas y Naturales

Universidad de Buenos Aires
Training Camp 2014
Leopoldo Taravilse (UBA)
Strings
TC 2014
1 / 51
Contenidos
1
String Matching
String Matching
Bordes
Knuth-Morris-Pratt
Tries
Tries
Suffix Array
Suffix Array
Longest Common Prefix
Bonus Track (Palndromos)

Algoritmo de Manacher
Strings
TC 2014
2 / 51
String Matching
String Matching
Contenidos
1
String Matching
String Matching
Bordes
Knuth-Morris-Pratt
Tries
Tries
Suffix Array
Suffix Array

Strings
TC 2014
3 / 51
String Matching
String Matching
Qu es String Matching?
Definicin del problema

El problema de String Matching consiste en, dados dos strigns S y T,
con |S| < |T |, decidir si S es un substring de T , es decir, si existe un
ndice i tal que
S[0] = T [i], S[1] = T [i + 1], . . . , S[|S| 1] = T [i + |S| 1]
Strings
TC 2014
4 / 51
String Matching
String Matching
Solucin Trivial
Existe una solucin O(|S||T |) que consiste en evaluar cada

substring de T de longitud |S| y compararlo con S caracter por
caracter.
Strings
TC 2014
5 / 51
String Matching
String Matching
Solucin Trivial

caracter.
Esta solucin no reutiliza ningn tipo de informacin sobre S o
sobre T .
Strings
TC 2014
5 / 51
String Matching
String Matching
Solucin Trivial

caracter.
Esta solucin no reutiliza ningn tipo de informacin sobre S o
sobre T .
Existen soluciones que reutilizan informacin y as nos evitan
tener que hacer O(|S||T |) comparaciones.
Strings
TC 2014
5 / 51
String Matching
Bordes
Contenidos
1
String Matching
String Matching
Bordes
Knuth-Morris-Pratt
Tries
Tries
Suffix Array
Suffix Array

Strings
TC 2014
6 / 51
String Matching
Bordes
Bordes de un String
Definicin de borde
Un borde de un string S es un string B (|B| < |S|) que es a su vez
prefijo y sufijo de S.
Strings
TC 2014
7 / 51
String Matching
Bordes
Bordes de un String
Definicin de borde
Un borde de un string S es un string B (|B| < |S|) que es a su vez
prefijo y sufijo de S.
Por ejemplo, a y abra son bordes de abracadabra.
Strings
TC 2014
7 / 51
String Matching
Bordes
Deteccin de bordes
Un problema muy comn es querer encontrar el borde ms largo

de un string.
Strings
TC 2014
8 / 51
String Matching
Bordes
Deteccin de bordes

de un string.
Nuevamente podramos comparar cada prefijo con el sufijo
correspondiente, lo que nos llevara a una solucin cuadrtica.
Strings
TC 2014
8 / 51
String Matching
Bordes
Deteccin de bordes

de un string.
Existe una solucin lineal para el clculo del mximo borde de un
string.
Strings
TC 2014
8 / 51
String Matching
Bordes
Deteccin de bordes

de un string.
Existe una solucin lineal para el clculo del mximo borde de un
string.
Esta solucin se basa en encontrar el mayor borde de todos los
prefijos del string uno por uno.
Strings
TC 2014
8 / 51
String Matching
Bordes
Deteccin de bordes
Lema 1
Si S 0 es borde de S y S 00 es borde de S 0 entonces S 00 es borde de S.
Al ser S 00 prefijo de S 0 y S 0 prefijo de S, entonces S 00 es prefijo de S, y
anlogamente es sufijo de S.
Strings
TC 2014
9 / 51
String Matching
Bordes
Deteccin de bordes
Lema 1
Lema 2
Si S 0 y S 00 son bordes de S y |S 00 | < |S 0 |, entonces S 00 es borde de S 0 .
Como S 00 es prefijo de S y S 0 tambin, entonces S 00 es prefijo de S 0 .
Anlogamente S 00 es sufijo de S 0 .
Strings
TC 2014
9 / 51
String Matching
Bordes
Deteccin de bordes
Lema 1
Lema 2
Si S 0 y S 00 son bordes de S y |S 00 | < |S 0 |, entonces S 00 es borde de S 0 .
Como S 00 es prefijo de S y S 0 tambin, entonces S 00 es prefijo de S 0 .
Anlogamente S 00 es sufijo de S 0 .
Lema 3
Si S 0 y S 00 son bordes de S y el mayor borde de S 0 es S 00 , entonces S 00
es el mayor borde de S de longitud menor a |S 0 |.
Strings
TC 2014
9 / 51
String Matching
Bordes
Solucin lineal al problema de deteccin de bordes
Empezamos con el prefijo de longitud 1. Su mayor borde tiene

longitud 0. (Recordemos que no consideramos al string entero
como su propio borde).
Strings
TC 2014
10 / 51
String Matching
Bordes

A partir del prefijo de longitud 1, si al borde ms largo del prefijo
de longitud i le sacamos el ltimo caracter, nos queda un borde
del prefijo de longitud i 1.
Strings
TC 2014
10 / 51
String Matching
Bordes

A partir del prefijo de longitud 1, si al borde ms largo del prefijo
de longitud i le sacamos el ltimo caracter, nos queda un borde
del prefijo de longitud i 1.
Luego probamos con todos los bordes del prefijo de longitud i 1
de mayor a menor, hasta que uno de esos bordes se pueda
extender a un borde del prefijo de longitud i. Si ninguno se puede
extender a un borde del prefijo de longitud i (ni siquiera el borde
vaco), entonces el borde de dicho prefijo es vaco.
Strings
TC 2014
10 / 51
String Matching
Bordes
Algoritmo de deteccin de bordes

1
2
3
4
5
6
7
8
9
10
int i =1, j =0;

bordes[0] = 0;
while( i <n)
{
while( j>0 && st [ i ] != st [ j ] )
j = bordes[ j 1];
i f ( st [ i ] == st [ j ] )
j ++;
bordes[ i ++] = j ;
}
Este es el cdigo del algoritmo de deteccin de bordes siendo st el

string y n su longitud.
Strings
TC 2014
11 / 51
String Matching
Bordes
Algoritmo de deteccin de bordes

1
2
3
4
5
6
7
8
9
10
int i =1, j =0;

bordes[0] = 0;
while( i <n)
{
while( j>0 && st [ i ] != st [ j ] )
j = bordes[ j 1];
i f ( st [ i ] == st [ j ] )
j ++;
bordes[ i ++] = j ;
}
Este es el cdigo del algoritmo de deteccin de bordes siendo st el

string y n su longitud.
En bordes[i] queda guardada la longitud del mximo borde del prefijo
de st de longitud i. Luego en bordes[n 1] queda guardada la longitud
del mximo borde de st.
Strings
TC 2014
11 / 51
String Matching
Bordes
Correctitud del Algoritmo
1
2
while( j>0 && st [ i ] != st [ j ] )

j = bordes[ j 1];
En estas dos lneas comparamos el mayor borde del prefijo de

longitud i con el mayor borde del prefijo de longitud i 1. Si dicho
borde no se puede extender, entonces probamos con el mayor borde
de ese borde, y as sucesivamente.
1
2
3
i f ( st [ i ] == st [ j ] )
j ++;
bordes[ i ++] = j ;
En estas lneas comparamos a ver si el borde efectivamente se puede

extender (o si es el borde vaco y no se puede extender) y guardamos
el borde en el arreglo bordes.
Strings
TC 2014
12 / 51
String Matching
Bordes
Complejidad del Algoritmo
El nico lugar donde decrementamos j es en la lnea

1
j = bordes[ j 1];
Adems, j, que empieza inicializado en 0, se incrementa a lo sumo n

veces, y nunca es menor que 0, por lo que decrementamos j a lo
sumo n veces, luego la complejidad del algoritmo es lineal en el
tamao del string.
Strings
TC 2014
13 / 51
String Matching
Knuth-Morris-Pratt
Contenidos
1
String Matching
String Matching
Bordes
Knuth-Morris-Pratt
Tries
Tries
Suffix Array
Suffix Array

Strings
TC 2014
14 / 51
String Matching
Knuth-Morris-Pratt
String Matching
Habamos visto que existen soluciones ms eficientes que

O(|S||T |) para el problema de String Matching.
Strings
TC 2014
15 / 51
String Matching
Knuth-Morris-Pratt
String Matching

Knuth-Morris-Pratt (tambin conocido como KMP) es una de ellas
y su complejidad es O(|T |)
Strings
TC 2014
15 / 51
String Matching
Knuth-Morris-Pratt
String Matching

Knuth-Morris-Pratt (tambin conocido como KMP) es una de ellas
y su complejidad es O(|T |)
KMP se basa en una tabla muy parecida a la de bordes. La idea
es que si el string viene matcheando y de repente no matchea, no
empezamos de cero sino que empezamos del borde. Por ejemplo,
si matche hasta abracadabra y luego no matchea, podemos ver
qu pasa matcheando con el borde abra.
Strings
TC 2014
15 / 51
String Matching
Knuth-Morris-Pratt
Cdigo de KMP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
string s, t ;
void fill_table ()
{
int pos = 2, cnd = 0;
kmp_table[0] = 1;
kmp_table[1] = 0;
while(pos<s. size () )
{
i f (s[pos1] == s[cnd] )
kmp_table[pos++] = ++cnd;
else i f (cnd>0)
cnd = kmp_table[cnd] ;
else
kmp_table[pos++] = 0;
}
}
As llenamos la tabla de KMP.

Strings
TC 2014
16 / 51
String Matching
Knuth-Morris-Pratt
Cdigo de KMP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int kmp() {
fill_table () ;
int m=0, i =0;
while(m +i <t . size () ) {
i f (s[ i ] == t [m+i ] ) {
i f ( i==s. size ()1)
return m;
i ++;
}
else{
m = m +ikmp_table[ i ] ;
i f (kmp_table[ i]>1)
i = kmp_table[ i ] ;
else
i = 0;
}
}
return 1;
}
Strings
TC 2014
17 / 51
String Matching
Knuth-Morris-Pratt
String matching con bordes
Acabamos de ver que el problema de string matching se puede

resolver con KMP.
Otra forma de resolver el problema de string matching en tiempo lineal
es concatenando los dos strings T + S y calculando los bordes.
Siempre que el borde sea mayor a |S| y menor a |T | quiere decir que
hay un sufijo de T + S (que tiene como sufijo a S) que tambin es
prefijo de T + S, y por lo tanto es prefijo de T y tiene como sufijo a S,
luego S es substring de T .
Strings
TC 2014
18 / 51
Tries
Tries
Contenidos
1
String Matching
String Matching
Bordes
Knuth-Morris-Pratt
Tries
Tries
Suffix Array
Suffix Array

Strings
TC 2014
19 / 51
Tries
Tries
Qu es un Trie?
Definicin de Trie
Los tries sirven para representar diccionarios de palabras. Un trie es
un rbol de caracteres en el que cada camino de la raiz a un nodo final
(no necesariamente una hoja) es una palabra de dicho diccionario.
Strings
TC 2014
20 / 51
Tries
Tries
Qu es un Trie?
Definicin de Trie
Los tries sirven para representar diccionarios de palabras. Un trie es
un rbol de caracteres en el que cada camino de la raiz a un nodo final
(no necesariamente una hoja) es una palabra de dicho diccionario.
Veamos un ejemplo de un Trie con las palabras hola, holamundo,
mundo y mundial.
Strings
TC 2014
20 / 51
Tries
Tries
Ejemplo de un Trie
root
h
d
o
Strings
TC 2014
21 / 51
Tries
Tries
Cdigo del Trie
1
2
3
4
5
6
7
8
9
10
11
12
13
struct trie {
map <char, int> sig ;
bool final ;
/ /puede ser map <int , int> si el alfabeto son enteros
};
trie t [MAXN] ;
int n;
void i n i t ()
{
n = 1;
t [0]. sig . clear () ;
t [0]. final = false ;
}
MAXN en este caso es una constante que determina el mximo

tamao del trie.
Strings
TC 2014
22 / 51
Tries
Tries
Cdigo del Trie
1
2
3
4
5
6
7
8
9
10
11
12
13
void insertar ( string st ) {

int pos = 0;
for ( int i =0;i <st . size () ; i ++){
i f ( trie [pos] . sig . find ( st [ i ] )==trie [pos] . sig .end() ) {
trie [pos] . sig [ st [ i ] ] = n;
trie [n] . sig . clear () ;
trie [n] . final = false ;
n++;
}
pos = trie [pos] . sig [ st [ i ] ] ;
}
trie [pos] . final = true ;
}
Strings
TC 2014
23 / 51
Tries
Tries
Ejemplo
Diseo de Camisetas
Dados dos equipos de rugby con n jugadores cada uno, quieren
compartir las camisetas (un jugador de cada equipo por cada
camiseta) de modo tal que cada camiseta tenga un prefijo comn
entre los apellidos de los dos jugadores que la usan (es vlido el
prefijo vaco), y entre todas las camisetas usen la mayor cantidad de
letras posibles.
Problema D - TAP 2012. Link a la prueba: http://goo.gl/ypdYS
Strings
TC 2014
24 / 51
Tries
Tries
Diseo de Camisetas
La solucin al problema consiste en:

Probar que los dos jugadores (de distintos equipos) con el prefijo
comn ms largo usan la misma camiseta. (Esta parte queda
como ejercicio).
Strings
TC 2014
25 / 51
Tries
Tries
Diseo de Camisetas

como ejercicio).
Insertar todos los apellidos en un trie.
Strings
TC 2014
25 / 51
Tries
Tries
Diseo de Camisetas

como ejercicio).
Insertar todos los apellidos en un trie.
Cada nodo del trie que es parte de a apellidos del equipo 1 y b
apellidos del equipo 2 aporta min(a, b) letras a las camisetas.
Strings
TC 2014
25 / 51
Tries
Tries
Problemas
http://goo.gl/gQOSG
http://goo.gl/KTVKd
Strings
TC 2014
26 / 51
Suffix Array
Suffix Array
Contenidos
1
String Matching
String Matching
Bordes
Knuth-Morris-Pratt
Tries
Tries
Suffix Array
Suffix Array

Strings
TC 2014
27 / 51
Suffix Array
Suffix Array
Motivacin
Problema
Dado un string calcular la cantidad de substrings distintos que tiene
dicho string.
Strings
TC 2014
28 / 51
Suffix Array
Suffix Array
Motivacin
Problema
Dado un string calcular la cantidad de substrings distintos que tiene
dicho string.
Veremos a continuacin dos algoritmos que nos sirven para resolver
este problema eficientemente.
Strings
TC 2014
28 / 51
Suffix Array
Suffix Array
Sufijos de un string
Muchas veces puede interesarnos ordenar los sufijos de un string
lexicogrficamente.
Strings
TC 2014
29 / 51
Suffix Array
Suffix Array
lexicogrficamente.
En principio un string de longitud n tiene n + 1 sufijos (contando el
string completo y el sufijo vaco), y la suma de la cantidad de
caracteres de todos esos sufijos es O(n2 ), por lo que tan slo leer
los sufijos para compararlos tomara una cantidad de tiempo
cuadrtica en la cantidad de caracteres del string.
Strings
TC 2014
29 / 51
Suffix Array
Suffix Array
lexicogrficamente.
En principio un string de longitud n tiene n + 1 sufijos (contando el
string completo y el sufijo vaco), y la suma de la cantidad de
caracteres de todos esos sufijos es O(n2 ), por lo que tan slo leer
los sufijos para compararlos tomara una cantidad de tiempo
cuadrtica en la cantidad de caracteres del string.
Una forma de implementar Suffix Array en O(n2 ) es con un Trie.
Insertando todos los sufijos y luego recorriendo el trie en orden
lexicogrfico podemos listar los sufijos en dicho orden.
Strings
TC 2014
29 / 51
Suffix Array
Suffix Array
Suffix Array
Qu es un Suffix Array?
A veces queremos tener ordenados lexicogrficamente los sufijos de
un string. Un Suffix Array es un arreglo que tiene los ndices de las
posiciones del string donde empiezan los sufijos, ordenados
lexicogrficamente.
Strings
TC 2014
30 / 51
Suffix Array
Suffix Array
Ejemplo de Suffix Array

Por ejemplo, para el string abracadabra el Suffix Array es:
a
2
b r
6 10
a
3
c
7
a
4
d
8
a
1
b
5
r
9
a
0
Y los sufijos ordenados son

a
abra
abracadabra
acadabra
adabra
bra
bracadabra
cadabra
dabra
ra
racadabra
Strings
TC 2014
31 / 51
Suffix Array
Suffix Array
Suffix Array
Al igual que con KMP, el algoritmo que calcula el Suffix Array
reutiliza informacin para ahorrar tiempo.
Strings
TC 2014
32 / 51
Suffix Array
Suffix Array
Suffix Array
Si sabemos que chau viene antes que hola, entonces sabemos
que chaupibe viene antes que holapepe y no necesitamos
comparar pibe con pepe.
Strings
TC 2014
32 / 51
Suffix Array
Suffix Array
Suffix Array
Para saber que chau viene antes que hola, no tuvimos que
comparar todo el string chau con el string hola, sino que slo
comparamos ch con ho, y para saber que ch viene antes que ho
comparamos c con h.
Strings
TC 2014
32 / 51
Suffix Array
Suffix Array
Suffix Array
Para saber que chau viene antes que hola, no tuvimos que
comparar todo el string chau con el string hola, sino que slo
comparamos ch con ho, y para saber que ch viene antes que ho
comparamos c con h.
La idea del Suffix Array pasa por ir comparando prefijos de los
sufijos de longitud 2t , e ir ordenando para cada t hasta que t sea
mayor o igual que la longitud del string.
Strings
TC 2014
32 / 51
Suffix Array
Suffix Array
Cdigo del Suffix Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
string st ;
vector<int> sa[18];
vector<int> bucket[18];
int t , n;
void i n i t () {
n = st . size () ;
for ( int i =0;(1<< i )<2n; i ++){
sa[ i ] . resize(n) ;
bucket[ i ] . resize(n) ;
for ( int j =0;j <n; j ++)
sa[ i ] [ j ] = j ;
}
sort (sa[0].begin() ;sa[0].end() ,comp1) ;
initBuckets () ;
for ( t=0;(1<<t )<n; t++){
sort (sa[ t +1].begin() ;sa[ t +1].end() ;comp2) ;
sortBuckets() ;
}
}
Strings
TC 2014
33 / 51
Suffix Array
Suffix Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
bool comp1( int a, int b)

{
i f ( st [a] != st [b] )
return st [a] < st [b] ;
return a<b;
}
bool comp2( int a, int b)
{
i f (bucket[ t ] [a]!=bucket[ t ] [b] )
return bucket[ t ] [a] < bucket[ t ] [b] ;
int d = (1<<t ) ;
i f (a+d >= n)
return true ;
i f (b+d >= n)
return false ;
i f (bucket[ t ] [a+d] != bucket[ t ] [b+d] )
return bucket[ t ] [a+d] != bucket[ t ] [b+d] ;
return a<b;
}
Strings
TC 2014
34 / 51
Suffix Array
Suffix Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void initBuckets () {
bucket[0][sa[0][0]] = 0;
for ( int i =1;i <n; i ++)
i f ( st [sa[0][ i ] ] == st [sa[0][ i 1]])
bucket[0][sa[0][ i ] ] = bucket[0][sa[0][ i 1]];
else
bucket[0][sa[0][ i ] ] = i ;
}
void sortBuckets() {
bucket[ t +1][sa[ t +1][0]] = 0;
int d = (1<<t ) ;
for ( int i =1;i <n; i ++)
i f (bucket[ t ] [sa[ t +1][ i ] ] == bucket[ t ] [sa[ t +1][ i 1]]
&& sa[ t +1][ i ]+d < n && sa[ t +1][ i 1] < n
&& bucket[ t ] [sa[ t +1][ i ]+d] == bucket[ t ] [sa[ t +1][ i1]+d] )
bucket[ t +1][sa[ t +1][ i ] ] = bucket[ t +1][sa[ t +1][ i 1]];
else
bucket[ t +1][sa[ t +1][ i ] ] = i ;
}
Strings
TC 2014
35 / 51
Suffix Array
Suffix Array
Correctitud y Complejidad de Suffix Array

Lo primero que hacemos es ordenar sa[0] segn el criterio de
comparacin comp1. Esto ordena a los sufijos segn sus prefijos
de longitud 1, es decir, el caracter con el que empiezan.
Strings
TC 2014
36 / 51
Suffix Array
Suffix Array

Luego dividimos a los sufijos en buckets. Un bucket es como un
paquete. En este caso los buckets contienen los sufijos que hasta
el momento son indistinguibles porque los prefijos por los cuales
los comparamos son iguales.
Strings
TC 2014
36 / 51
Suffix Array
Suffix Array

Luego vamos ordenando los sufijos segn sus prefijos de longitud
2, 4, 8,... y los ponemos en buckets segn estos prefijos. Notemos
que este paso es O(n log n) ya que la comparacin entre dos
sufijos segn el prefijo que corresponda en este caso es O(1).
Strings
TC 2014
36 / 51
Suffix Array
Suffix Array

Luego vamos ordenando los sufijos segn sus prefijos de longitud
2, 4, 8,... y los ponemos en buckets segn estos prefijos. Notemos
que este paso es O(n log n) ya que la comparacin entre dos
sufijos segn el prefijo que corresponda en este caso es O(1).
Podemos afirmar entonces que el algoritmo tiene una complejidad
de O(n log2 n).
Strings
TC 2014
36 / 51
Suffix Array
Suffix Array
Versiones ms eficientes de Suffix Array

Existen versiones ms eficientes de Suffix Array, que se puede
hacer en O(n log n).
Strings
TC 2014
37 / 51
Suffix Array
Suffix Array

Para calcular el Suffix Array en O(n log n) se ordenan los
caracteres del string en el primer paso usando counting sort.
Luego ordenamos cada bucket por separado haciendo tambin
counting sort.
Strings
TC 2014
37 / 51
Suffix Array
Suffix Array

counting sort.
Incluso si el alfabeto no es acotado se puede mapear a un
alfabeto acotado por la longitud del string utilizando slo los
caracteres que aparecen en el string para que el counting sort
inicial sea O(n). Luego los counting sort se pueden hacer tambin
porque hay a lo sumo n buckets.
Strings
TC 2014
37 / 51
Suffix Array
Suffix Array

counting sort.
Incluso si el alfabeto no es acotado se puede mapear a un
alfabeto acotado por la longitud del string utilizando slo los
caracteres que aparecen en el string para que el counting sort
inicial sea O(n). Luego los counting sort se pueden hacer tambin
porque hay a lo sumo n buckets.
Esta optimizacin es bastante complicada y suele ser suficiente
con la versin O(n log2 n).
Strings
TC 2014
37 / 51
Suffix Array
Contenidos
1
String Matching
String Matching
Bordes
Knuth-Morris-Pratt
Tries
Tries
Suffix Array
Suffix Array

Strings
TC 2014
38 / 51
Suffix Array
LCP
Longest Common Prefix (LCP)

El Longest Common Prefix (LCP) entre dos strings es el prefijo comn
ms largo que comparten ambos strings. Comunmente se conoce
como LCP al problema que consiste en obtener el prefijo comn ms
largo entre los pares de sufijos consecutivos lexicogrficamente de un
string. Para poder obtener los pares de sufijos consecutivos es
necesario primero calcular el Suffix Array.
Strings
TC 2014
39 / 51
Suffix Array
LCP
Longest Common Prefix (LCP)

El Longest Common Prefix (LCP) entre dos strings es el prefijo comn
ms largo que comparten ambos strings. Comunmente se conoce
como LCP al problema que consiste en obtener el prefijo comn ms
largo entre los pares de sufijos consecutivos lexicogrficamente de un
string. Para poder obtener los pares de sufijos consecutivos es
necesario primero calcular el Suffix Array.
Este problema puede ser resuelto en tiempo lineal.
Strings
TC 2014
39 / 51
Suffix Array
Ejemplo de LCP
SA
0
1
2
3
4
5
6
7
8
9
10
S = abracadabra
a
abra
abracadabra
acadabra
adabra
bra
bracadabra
cadabra
dabra
ra
racadabra
LCP
0
1
4
1
1
0
3
0
0
0
2
a
abra
a
a
bra
ra
Strings
TC 2014
40 / 51
Suffix Array
Cdigo del LCP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
vector<int> lcp ;
void llenarLCP()
{
int n = st . size () ;
lcp . resize(n1);
int q=0, j ;
for ( int i =0;i <n; i ++)
i f (bucket[ t ] [ i ]!=0)
{
j = sa[ t ] [ bucket[ t ] [ i ]1];
while(q+max( i , j ) < n && st [ i+q] == st [ j+q] )
q++;
lcp [bucket[ t ] [ i ]1] = q;
i f (q>0)
q;
}
}
Strings
TC 2014
41 / 51
Suffix Array
Correctitud del algoritmo de LCP
En bucket vamos a tener la posicin del i-simo sufijo en el Suffix

Array, es decir bucket[t][sa[t][i]] = i (el t viene de la implementacin
que dimos antes del Suffix Array). Para calcular el LCP comenzamos
por el primer sufijo. Si el sufijo que estamos analizando no es el
primero lexicogrficamente, nos fijamos cul es el sufijo anterior y
vamos comparando caracter por caracter contando cuntos caracteres
hay en comn.
Strings
TC 2014
42 / 51
Suffix Array
Correctitud del algoritmo de LCP
Si por ejemplo abracadabra tiene 4 caracteres en comn con abra,

entonces sabemos que bracadabra va a tener 3 caracteres en comn
con bra. Esto se ve reflejado en la lnea
1
2
i f (q>0)
q;
que decrementa q slo en 1 en lugar de resetearlo a 0.

En la siguiente iteracin arrancamos ya con q en 3 por lo que a partir
de la segunda iteracin del for ya no comparamos siempre todos los
caracteres. Esto hace que el algoritmo sea ms eficiente y una forma
de convencerse de la correctitud de no resetear q a 0 es con el
ejemplo de LCP(abracadabra,abra) = 4 LCP(bracadabra,bra) 3.
Strings
TC 2014
43 / 51
Suffix Array
Complejidad del LCP
El for corre n veces, y el while interno corre a lo sumo 2n veces en

total (entre todas las iteraciones del for), ya que q empieza en 0, se
decrementa a lo sumo una vez por cada iteracin del for, y nunca es
mayor a n, luego el algoritmo es lineal.
Strings
TC 2014
44 / 51
Suffix Array
Cantidad de substrings distintos
Recuerdan el problema que habamos visto al principio de esta

seccin? La solucin a este problema es con Suffix Array y LCP.
La cantidad de substrings distintos es n(n+1)
menos la suma de los
2
valores del LCP. Porqu?
Strings
TC 2014
45 / 51
Contenidos
1
String Matching
String Matching
Bordes
Knuth-Morris-Pratt
Tries
Tries
Suffix Array
Suffix Array

Strings
TC 2014
46 / 51
Qu es un palndromo
Definicin
Un palndromo es un string que se lee igual de atrs para adelante y
de adelante para atrs. Algunos ejemplos de palndromos son
Neuquen, Anitalavalatina o el apellido de un famoso ex presidente
argentino.
Strings
TC 2014
47 / 51
Longest Palindromic Substring
Problema
Un problema muy comn es el de buscar el palndromo ms largo que
es substring de un string dado. Este problema tiene una solucin lineal
y es con el algoritmo de Manacher.
Strings
TC 2014
48 / 51
El algoritmo consiste en los siguientes pasos:

Primero transformamos el string de la siguiente manera: Por
ejemplo si el string es abracadabra lo transformamos
en %#a#b#r#a#c#a#d#a#b#r#a#$. Es decir, le agregamos un #
antes y despus de cada letra, y dos caracteres distintos que no
aparecen en el string uno al principio y otro al final.
Strings
TC 2014
49 / 51

En un arreglo P guardamos el mayor palndromo de este nuevo
string transformado centrado en cada posicin del string.
Strings
TC 2014
49 / 51

En un arreglo P guardamos el mayor palndromo de este nuevo
string transformado centrado en cada posicin del string.
En una variable R guardamos donde termina el palndromo que
ms adelante termina, y en una variable C guardamos el centro
de dicho palndromo.
Strings
TC 2014
49 / 51
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
vector<int> manacher( string S) {

int n = S. size () ;
vector<int> P(n,0) ;
int C = 0, R = 0;
for ( int i = 1; i < n1; i ++) {
int j = C ( iC) ;
i f (R>i )
P[ i ] = min(Ri , P[ j ] ) ;
while (S[ i + 1 + P[ i ] ] == S[ i 1 P[ i ] ] )
P[ i ]++;
i f ( i + P[ i ] > R) {
C = i;
R = i + P[ i ] ;
}
}
}
Strings
TC 2014
50 / 51
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
vector<int> manacher( string S) {

int n = S. size () ;
vector<int> P(n,0) ;
int C = 0, R = 0;
for ( int i = 1; i < n1; i ++) {
int j = C ( iC) ;
i f (R>i )
P[ i ] = min(Ri , P[ j ] ) ;
while (S[ i + 1 + P[ i ] ] == S[ i 1 P[ i ] ] )
P[ i ]++;
i f ( i + P[ i ] > R) {
C = i;
R = i + P[ i ] ;
}
}
}
Recordemos que S es el string transformado con la transformacin

previamente definida.
Strings
TC 2014
50 / 51
Complejidad del algoritmo de Manacher
La complejidad del algoritmo es lineal en la longitud del string.
Strings
TC 2014
51 / 51
Complejidad del algoritmo de Manacher
La complejidad del algoritmo es lineal en la longitud del string.

Probar esto queda como ejercicio.
Strings
TC 2014
51 / 51

05 - Strings

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

05 - Strings

Uploaded by

Copyright:

Available Formats

Strings

de Ciencias Exactas y Naturales

Training Camp 2014

Leopoldo Taravilse (UBA)

Bonus Track (Palndromos)

Leopoldo Taravilse (UBA)

Bonus Track (Palndromos)

Leopoldo Taravilse (UBA)

Definicin del problema

Leopoldo Taravilse (UBA)

Existe una solucin O(|S||T |) que consiste en evaluar cada

Leopoldo Taravilse (UBA)

Existe una solucin O(|S||T |) que consiste en evaluar cada

Leopoldo Taravilse (UBA)

Existe una solucin O(|S||T |) que consiste en evaluar cada

Leopoldo Taravilse (UBA)

Bonus Track (Palndromos)

Leopoldo Taravilse (UBA)

Leopoldo Taravilse (UBA)

Leopoldo Taravilse (UBA)

Un problema muy comn es querer encontrar el borde ms largo

Leopoldo Taravilse (UBA)

Un problema muy comn es querer encontrar el borde ms largo

Leopoldo Taravilse (UBA)

Un problema muy comn es querer encontrar el borde ms largo

Leopoldo Taravilse (UBA)

Un problema muy comn es querer encontrar el borde ms largo

Leopoldo Taravilse (UBA)

Leopoldo Taravilse (UBA)

Leopoldo Taravilse (UBA)

Solucin lineal al problema de deteccin de bordes

Empezamos con el prefijo de longitud 1. Su mayor borde tiene

Leopoldo Taravilse (UBA)

Solucin lineal al problema de deteccin de bordes

Empezamos con el prefijo de longitud 1. Su mayor borde tiene

Leopoldo Taravilse (UBA)

Solucin lineal al problema de deteccin de bordes

Empezamos con el prefijo de longitud 1. Su mayor borde tiene

Leopoldo Taravilse (UBA)

Algoritmo de deteccin de bordes

int i =1, j =0;

Este es el cdigo del algoritmo de deteccin de bordes siendo st el

Leopoldo Taravilse (UBA)

Algoritmo de deteccin de bordes

int i =1, j =0;

Este es el cdigo del algoritmo de deteccin de bordes siendo st el

Correctitud del Algoritmo

while( j>0 && st [ i ] != st [ j ] )

En estas dos lneas comparamos el mayor borde del prefijo de

En estas lneas comparamos a ver si el borde efectivamente se puede

Leopoldo Taravilse (UBA)

Complejidad del Algoritmo

El nico lugar donde decrementamos j es en la lnea

Adems, j, que empieza inicializado en 0, se incrementa a lo sumo n

Leopoldo Taravilse (UBA)

Bonus Track (Palndromos)

Leopoldo Taravilse (UBA)

Habamos visto que existen soluciones ms eficientes que

Leopoldo Taravilse (UBA)

Habamos visto que existen soluciones ms eficientes que

Leopoldo Taravilse (UBA)

Habamos visto que existen soluciones ms eficientes que

Leopoldo Taravilse (UBA)

As llenamos la tabla de KMP.