Documente Academic
Documente Profesional
Documente Cultură
FACULTAD DE INGENIERIA DE
SISTEMAS
TUTORIAL
Algoritmos
Contenido
Introduccin............................................................................................................................................. 6
Marco Terico.......................................................................................................................................... 6
Introduccin al estudio de algoritmos ............................................................................................. 6
Metodologa para la creacin de algoritmos ........................................................................... 7
CONCLUSIONES:..................................................................................................................................... 71
Algoritmos Voraces ............................................................................................................................... 72
Elementos que participan en algoritmos voraces son: ..................................................................... 72
Pasos del algoritmo ........................................................................................................................... 72
Procedimiento ................................................................................................................................... 73
Divide y vencers ................................................................................................................................... 75
Definicin........................................................................................................................................... 75
Pasos de la tcnica divide y vencers ................................................................................................ 75
Algoritmo ........................................................................................................................................... 75
Divisin .............................................................................................................................................. 75
Puntualizaciones de divide y vencers .............................................................................................. 76
Ventajas ............................................................................................................................................. 76
Divide y vencers ............................................................................................................................... 76
Anlisis de complejidad ..................................................................................................................... 77
Aplicabilidad de los algoritmos DV .................................................................................................... 77
Algoritmos Expuestos ........................................................................................................................ 79
Programacin Dinmica ........................................................................................................................ 82
Concepto ........................................................................................................................................... 82
Caractersticas de los problemas en los cuales se pueden aplicar la programacin dinmica. ........ 83
Objetivos de la memorizacin ........................................................................................................... 83
Aplicaciones: ...................................................................................................................................... 83
Ejemplo 1: Clculo de los nmeros combinatorios: .......................................................................... 84
Alineamiento de secuencias globales. Bioinformtica ...................................................................... 84
Problema de las n reinas ................................................................................................................... 86
Branch and Bound (BB)(Ramificacin y poda)....................................................................................... 87
Descripcin general ........................................................................................................................... 87
Ramificacin ...................................................................................................................................... 87
Terminologa usada en la ramificacin y poda .................................................................................. 87
4
RP vs Backtracking ............................................................................................................................. 88
Procedimiento general ...................................................................................................................... 88
Gestin de los nodos vivos ................................................................................................................ 88
Problema de asignacin .................................................................................................................... 89
Transforma y vencers .......................................................................................................................... 91
Transforma y vencers: Presorting.................................................................................................... 91
Heapsort ............................................................................................................................................ 91
Teora de la complejidad ....................................................................................................................... 92
Introduccin ...................................................................................................................................... 92
Teora de la compatibilidad ............................................................................................................... 92
La complejidad computacional.......................................................................................................... 92
Problemas de decisin ...................................................................................................................... 92
Clasificacin de los problemas de decisin ....................................................................................... 93
Clase P (Tiempo polinomio)............................................................................................................... 93
Clase NP (Tiempo polinomial no determinstico) .............................................................................. 94
Bibliografa ............................................................................................................................................. 95
5
Introduccin
En este documento encontraremos informacin hacerca de la materia de Algoritmos, el cual nos
ser de mucha ayuda al momento de estudiar o buscar informacin hacerca de algn tema referente
a la materia, adems de darnos muchas facilidades que un cuaderno fsico no las tiene.
Marco Terico
Un algoritmo es una serie de pasos organizados que describe el proceso que se debe seguir, para
dar solucin a un problema especfico.
TIPOS DE ALGORITMOS?
Lenguajes Algortmicos
Un Lenguaje algortmico es una serie de smbolos y reglas que se utilizan para describir de manera
explcita un proceso.
6
No Grficos: Representa en forma descriptiva las operaciones que debe realizar un algoritmo
(pseudocodigo).
INICIO
Edad: Entero
ESCRIBA cul es tu edad?
Lea Edad
SI Edad >=18 entonces
ESCRIBA Eres mayor de Edad
FINSI
ESCRIBA fin del algoritmo
FIN
El computador es una mquina que por s sola no puede hacer nada, necesita ser programada, es
decir, introducirle instrucciones u rdenes que le digan lo que tiene que hacer. Un programa es la
solucin a un problema inicial, as que todo comienza all: en el Problema. El proceso de
programacin es el siguiente: Dado un determinado problema el programador debe idear una solucin
y expresarla usando un algoritmo (aqu es donde entra a jugar); luego de esto, debe codificarlo en un
determinado lenguaje de programacin y por ltimo ejecutar el programa en el computador el cual
refleja una solucin al problema inicial. Esto es a grandes rasgos lo que hace el programador de
computadores.
La parte que corresponde a este manual es la de: Dado un determinado problema debemos idear una
solucin y expresarla usando un ALGORITMO!
7
Metodologa para la solucin de problemas por medio de computadora
Esta fase est dada por el enunciado del problema, el cual requiere una definicin clara y precisa.
Es importante que se conozca lo que se desea que realice la computadora; mientras esto no se
conozca del todo no tiene mucho caso continuar con la siguiente etapa.
Se denomina prueba de escritorio a la comprobacin que se hace de un algoritmo para saber si est
bien hecho. Esta prueba consiste en tomar datos especficos como entrada y seguir la secuencia
indicada en el algoritmo hasta obtener un resultado, el anlisis de estos resultados indicar si el
algoritmo est correcto o si por el contrario hay necesidad de corregirlo o hacerle ajustes.
Los algoritmos conforman un conjunto de pasos que permiten llegar a la solucin del problema. Son
por naturaleza secuenciales, aunque varias tcnicas y herramientas aplicables a ellos ofrecen
mecanismos de repeticin. Son herramientas que tomamos prestadas de las matemticas para poder
dar soluciones computacionales a problemas cotidianos. En la prctica la solucin de un problema no
8
est compuesta por uno, sino por muchos algoritmos, cada uno encargado de resolver una porcin
del problema planteado.
Tiempo secuencial. Un algoritmo funciona en tiempo discretizado paso a paso, definiendo as una
secuencia de estados "computacionales" por cada entrada vlida (la entrada son los datos que se le
suministran al algoritmo antes de comenzar).
Estado abstracto. Cada estado computacional puede ser descrito formalmente utilizando
una estructura de primer orden y cada algoritmo es independiente de su implementacin (los
algoritmos son objetos abstractos) de manera que en un algoritmo las estructuras de primer orden
son invariantes bajo isomorfismo.
Robustez: Un algoritmo debe cubrir todos los casos posibles de acuerdo a las alternativas de
seleccin. Debe funcionar para todos los casos esperados y no esperados.
9
Los algoritmos pueden ser expresados de muchas maneras, incluyendo allenguaje
natural, pseudocdigo, diagramas de flujo y lenguajes de programacin entre otros. Las descripciones
en lenguaje natural tienden a ser ambiguas y extensas. El usar pseudocdigo y diagramas de flujo
evita muchas ambigedades del lenguaje natural. Dichas expresiones son formas ms estructuradas
para representar algoritmos; no obstante, se mantienen independientes de un lenguaje de
programacin especfico.
Diagramas de Flujo:
Los diagramas de flujo son descripciones grficas de algoritmos; usan smbolos conectados con
flechas para indicar la secuencia de instrucciones y estn regidos por ISO.
Los diagramas de flujo son usados para representar algoritmos pequeos, ya que abarcan mucho
espacio y su construccin es laboriosa. Por su facilidad de lectura son usados como introduccin a los
algoritmos, descripcin de un lenguaje y descripcin de procesos a personas ajenas a la
computacin.
Pseudocdigo:
El pseudocdigo (falso lenguaje, el prefijo pseudo significa falso) es una descripcin de alto nivel de
un algoritmo que emplea una mezcla de lenguaje natural con algunas convenciones sintcticas
10
propias de lenguajes de programacin, como asignaciones, ciclos y condicionales, aunque no est
regido por ningn estndar. Es utilizado para describir algoritmos en libros y publicaciones cientficas,
y como producto intermedio durante el desarrollo de un algoritmo, como los diagramas de flujo,
aunque presentan una ventaja importante sobre estos, y es que los algoritmos descritos en
pseudocdigo requieren menos espacio para representar instrucciones complejas.
El pseudocdigo est pensado para facilitar a las personas el entendimiento de un algoritmo, y por lo
tanto puede omitir detalles irrelevantes que son necesarios en una implementacin. Programadores
diferentes suelen utilizar convenciones distintas, que pueden estar basadas en la sintaxis de
lenguajes de programacin concretos. Sin embargo, el pseudocdigo, en general, es comprensible
sin necesidad de conocer o utilizar un entorno de programacin especfico, y es a la vez
suficientemente estructurado para que su implementacin se pueda hacer directamente a partir de l.
As el pseudodocdigo cumple con las funciones antes mencionadas para representar algo abstracto
los protocolos son los lenguajes para la programacin. Busque fuentes ms precisas para tener
mayor comprensin del tema
11
Fases de Desarrollo de un Algoritmo
Enlace: se establece una relacin entre el programa objeto con otras aplicaciones adicionales.
Prueba: se maneja la aplicacin y se revisa si existen errores que incumplan con la robustez y
eficiencia del programa.
ALGORITMO #1
ALGORITMO: Promedio
CONSTANTES: --------------------------------
INICIO
12
ALGORITMO #2
CONSTANTE: ----------------------------------
VARIABLE: Real: P1, P2, P3, Prom., Examen, TrabajoF, Prom. Final
INICIO
ALGORITMO #3
ALGORITMO: Sueldo
DESCRIPCCION: Calcular el sueldo de un empleado dados como datos de entrada: el nombre, hrs.
De trabajo y el pago en hr.
13
VARIABLE: Cadena: nombre Entero: hrs. Real: Sueldo
INICIO
1. Leer nombre
2. Leer hrs.
3. Sueldo= Pagohr*hrs
4. Escribir Sueldo, nombre
FIN
ALGORITMO #4
ALGORITMO: Evaluacin
Y= 3*X2 + 7X - 15
CONATANTE: ------------------
VARIABLE: Real: X, Y
INICIO
1. Leer X
2. Y= (3*X*X)+(7*x) -15
3. Escribir Y
FIN
14
ALGORITMO #5
ax + by= C
dx + dy= f
X= ce bf
ae bd
y= af cd
ae bd
Si ae bd 0
Elabore un algoritmo que lea los coeficientes a, b, c. e, f, y calcule los valores de x,, y.
CONSTANTE: ------------------------
VARIABLE: Real: a, b, c. d, e, f, x, y
INICIO
1. Leer a, b, c, d, e, f
2. x=(c*e) (b*f) /(a*e) (b*d)
3. y=(a*f) (c*d) / (a*e) (b*d)
4. Escribir x, y
FIN
ALGORITMO #6
x x Si x>0
-x Si x <o
15
CONSTANTES: ----------------------
VARIABLES: Entero: x
INICIO
1. Leer x
2. Si (x<0) entonces
X= x*(-1)
Fin_si
3. Escribir x
FIN
ALGORITMO #7
CONSTANTE: ---------------------------
VARIABLE: Entero: N
INICIO
1. Leer N
2. Si (N%2=0) entonces
Escribir N en par
Si no Escribir N es impar
Fin _ s
FIN
ALGORITMO #8
16
ALGORITMO: Nmeros
DESCRIPCCION: Elaborar un algoritmo para leer 3 nmeros y determinar s uno es la suma de los
otros dos.
CONSTANTES: -----------------------------
INICIO
Escribir N2 es la suma de N1 + N3
Fin _ s
Fin _ s
Fin _ s
FIN
ALGORITMO #9
ALGORITMO: Mltiplo de 3
CONSTANTE: -------------------
17
VARIABLE: Entero: N
INICIO
1. Leer N
2. S (N>=100 y N<=200) entonces
S (N%3=0) entonces
Fin _s
Fin _s
FIN
ALGORITMO #10
DESCRIPCCION: Elaborar un algoritmo para leer la fecha de nacimiento de una persona y muestre
su signo zodiacal.
CONTANTES: ------------------
INICIO
1. Leer x, y
2. S (x= marzo y w>= 21) y (x= abril y w<=20) entonces
Escribir Eres Aries
Fin _ s
18
Fin _ s
Fin _ s
Fin _ s
Fin _ s
Fin _ s
Fin _ s
Fin _ s
Fin _ s
Fin _ s
19
Fin _ s
Fin _ s
Fin _s
FIN
Definicin de rbol
Un rbol es una estructura de datos, que puede definirse de forma recursiva como:
20
Otra definicin nos da el rbol como un tipo de grafo (ver grafos): un rbol es un grafo acclico,
conexo y no dirigido. Es decir, es un grafo no dirigido en el que existe exactamente un camino entre
todo par de nodos. Esta definicin permite implementar un rbol y sus operaciones empleando las
representaciones que se utilizan para los grafos. Sin embargo, en esta seccin no se tratar esta
implementacin.
Formas de representacin
- Mediante un grafo:
Figura 1
En la computacin se utiliza mucho una estructura de datos, que son los rboles binarios. Estos
rboles tienen 0, 1 2 descendientes como mximo. El rbol de la figura anterior es un ejemplo vlido
de rbol binario.
Antecesor: un nodo X es es antecesor de un nodo Y si por alguna de las ramas de X se puede llegar
a Y.
21
Sucesor: un nodo X es sucesor de un nodo Y si por alguna de las ramas de Y se puede llegar a X.
- Grado de un nodo: el nmero de descendientes directos que tiene. Ejemplo: c tiene grado 2, d tiene
grado 0, a tiene grado 2.
- Hoja: nodo que no tiene descendientes: grado 0. Ejemplo: d
- Nodo interno: aquel que tiene al menos un descendiente.
- Nivel: nmero de ramas que hay que recorrer para llegar de la raz a un nodo. Ejemplo: el nivel del
nodo a es 1 (es un convenio), el nivel del nodo e es 3.
- Altura: el nivel ms alto del rbol. En el ejemplo de la figura 1 la altura es 3.
- Anchura: es el mayor valor del nmero de nodos que hay en un nivel. En la figura, la anchura es 3.
Aclaraciones: se ha denominado a a la raz, pero se puede observar segn la figura que cualquier
nodo podra ser considerado raz, basta con girar el rbol. Podra determinarse por ejemplo
que b fuera la raz, y a y d los sucesores inmediatos de la raz b. Sin embargo, en las
implementaciones sobre un computador que se realizan a continuacin es necesaria una jerarqua, es
decir, que haya una nica raz.
Se definir el rbol con una clave de tipo entero (puede ser cualquier otra tipo de datos) y dos hijos:
izquierdo (izq) y derecho (der). Para representar los enlaces con los hijos se utilizan punteros. El rbol
vaco se representar con un puntero nulo.
Otras declaraciones tambin aaden un enlace al nodo padre, pero no se estudiarn aqu.
22
Recorridos sobre rboles binarios
- Recorridos en profundidad:
* Recorrido en preorden: consiste en visitar el nodo actual (visitar puede ser simplemente mostrar la
clave del nodo por pantalla), y despus visitar el subrbol izquierdo y una vez visitado, visitar el
subrbol derecho. Es un proceso recursivo por naturaleza.
Si se hace el recorrido en preorden del rbol de la figura 1 las visitas seran en el orden siguiente:
a,b,d,c,e,f.
* Recorrido en inorden u orden central: se visita el subrbol izquierdo, el nodo actual, y despus se
visita el subrbol derecho. En el ejemplo de la figura 1 las visitas seran en este orden: b,d,a,e,c,f.
23
* Recorrido en postorden: se visitan primero el subrbol izquierdo, despus el subrbol derecho, y
por ltimo el nodo actual. En el ejemplo de la figura 1 el recorrido quedara as: d,b,e,f,c,a.
La ventaja del recorrido en postorden es que permite borrar el rbol de forma consistente. Es decir, si
visitar se traduce por borrar el nodo actual, al ejecutar este recorrido se borrar el rbol o subrbol
que se pasa como parmetro. La razn para hacer esto es que no se debe borrar un nodo y despus
sus subrboles, porque al borrarlo se pueden perder los enlaces, y aunque no se perdieran se rompe
con la regla de manipular una estructura de datos inexistente. Una alternativa es utilizar una variable
auxiliar, pero es innecesario aplicando este recorrido.
- Recorrido en amplitud:
Consiste en ir visitando el rbol por niveles. Primero se visitan los nodos de nivel 1 (como mucho hay
uno, la raz), despus los nodos de nivel 2, as hasta que ya no queden ms.
Si se hace el recorrido en amplitud del rbol de la figura una visitara los nodos en este orden:
a,b,c,d,e,f
En este caso el recorrido no se realizar de forma recursiva sino iterativa, utilizando una cola. El
procedimiento consiste en encolar (si no estn vacos) los subrboles izquierdo y derecho del nodo
extrado de la cola, y seguir desencolando y encolando hasta que la cola est vaca.
En la codificacin que viene a continuacin no se implementan las operaciones sobre colas.
if (a != NULL) {
CrearCola(cola);
encolar(cola, a);
24
while (!colavacia(cola)) {
desencolar(cola, aux);
visitar(aux);
if (aux->izq != NULL) encolar(cola, aux->izq);
if (aux->der != NULL) encolar(cola, aux->der);
}
}
}
Por ltimo, considrese la sustitucin de la cola por una pila en el recorrido en amplitud. Qu tipo de
recorrido se obtiene?
Antes de explicarlo se recomienda al lector que lo intente hacer por su cuenta, es sencillo cuando uno
es capaz de construir el rbol viendo sus recorridos pero sin haber visto el rbol terminado.
Partiendo de los recorridos preorden e inorden del rbol de la figura 1 puede determinarse que la raz
es el primer elemento del recorrido en preorden. Ese elemento se busca en el array inorden. Los
elementos en el array inorden entre izq y la raz forman el subrbol izquierdo. Asimismo los
elementos entre der y la raz forman el subrbol derecho. Por tanto se tiene este rbol:
25
A continuacin comienza un proceso recursivo. Se procede a crear el subrbol izquierdo, cuyo
tamao est limitado por los ndices izq y der. La siguiente posicin en el recorrido en preorden es la
raz de este subrbol. Queda esto:
El subrbol b tiene un subrbol derecho, que no tiene ningn descendiente, tal y como indican los
ndices izq y der. Se ha obtenido el subrbol izquierdo completo de la raz a, puesto queb no tiene
subrbol izquierdo:
26
Despus seguir construyndose el subrbol derecho a partir de la raz a.
* Todas las claves del subrbol izquierdo al nodo son menores que la clave del nodo.
* Todas las claves del subrbol derecho al nodo son mayores que la clave del nodo.
* Ambos subrboles son rboles binarios de bsqueda.
Figura 5
Al definir el tipo de datos que representa la clave de un nodo dentro de un rbol binario de bsqueda
es necesario que en dicho tipo se pueda establecer una relacin de orden. Por ejemplo, suponer que
el tipo de datos de la clave es un puntero (da igual a lo que apunte). Si se codifica el rbol en Pascal
no se puede establecer una relacin de orden para las claves, puesto que Pascal no admite
determinar si un puntero es mayor o menor que otro.
En el ejemplo de la figura 5 las claves son nmeros enteros. Dada la raz 4, las claves del subrbol
izquierdo son menores que 4, y las claves del subrbol derecho son mayores que 4. Esto se cumple
tambin para todos los subrboles. Si se hace el recorrido de este rbol en orden central se obtiene
una lista de los nmeros ordenada de menor a mayor.
Cuestin: Qu hay que hacer para obtener una lista de los nmeros ordenada de mayor a menor?
27
Una ventaja fundamental de los rboles de bsqueda es que son en general mucho ms rpidos para
localizar un elemento que una lista enlazada. Por tanto, son ms rpidos para insertar y borrar
elementos. Si el rbol est perfectamente equilibrado -esto es, la diferencia entre el nmero de
nodos del subrbol izquierdo y el nmero de nodos del subrbol derecho es a lo sumo 1, para todos
los nodos- entonces el nmero de comparaciones necesarias para localizar una clave es
aproximadamente de logN en el peor caso. Adems, el algoritmo de insercin en un rbol binario de
bsqueda tiene la ventaja -sobre los arrays ordenados, donde se empleara bsqueda dicotmica
para localizar un elemento- de que no necesita hacer una reubicacin de los elementos de la
estructura para que esta siga ordenada despus de la insercin. Dicho algoritmo funciona avanzando
por el rbol escogiendo la rama izquierda o derecha en funcin de la clave que se inserta y la clave
del nodo actual, hasta encontrar su ubicacin; por ejemplo, insertar la clave 7 en el rbol de la figura 5
requiere avanzar por el rbol hasta llegar a la clave 8, e introducir la nueva clave en el subrbol
izquierdo a 8.
El algoritmo de borrado en rboles es algo ms complejo, pero ms eficiente que el de borrado en un
array ordenado.
Ahora bien, suponer que se tiene un rbol vaco, que admite claves de tipo entero. Suponer que se
van a ir introduciendo las claves de forma ascendente. Ejemplo: 1,2,3,4,5,6
Se crea un rbol cuya raz tiene la clave 1. Se inserta la clave 2 en el subrbol derecho de 1. A
continuacin se inserta la clave 3 en el subrbol derecho de 2.
Continuando las inserciones se ve que el rbol degenera en una lista secuencial, reduciendo
drsticamente su eficacia para localizar un elemento. De todas formas es poco probable que se de un
caso de este tipo en la prctica. Si las claves a introducir llegan de forma ms o menos aleatoria
entonces la implementacin de operaciones sobre un rbol binario de bsqueda que vienen a
continuacin es en general suficiente.
Existen variaciones sobre estos rboles, como los AVL o Red-Black (no se tratan aqu), que sin llegar
a cumplir al 100% el criterio de rbol perfectamente equilibrado, evitan problemas como el de obtener
una lista degenerada.
- Bsqueda
Si el rbol no es de bsqueda, es necesario emplear uno de los recorridos anteriores sobre el rbol
para localizarlo. El resultado es idntico al de una bsqueda secuencial. Aprovechando las
propiedades del rbol de bsqueda se puede acelerar la localizacin. Simplemente hay que
descender a lo largo del rbol a izquierda o derecha dependiendo del elemento que se busca.
28
boolean buscar(tarbol *a, int elem)
{
if (a == NULL) return FALSE;
else if (a->clave < elem) return buscar(a->der, elem);
else if (a->clave > elem) return buscar(a->izq, elem);
else return TRUE;
}
- Insercin
- Borrado
La operacin de borrado si resulta ser algo ms complicada. Se recuerda que el rbol debe seguir
siendo de bsqueda tras el borrado. Pueden darse tres casos, una vez encontrado el nodo a borrar:
1) El nodo no tiene descendientes. Simplemente se borra.
2) El nodo tiene al menos un descendiente por una sola rama. Se borra dicho nodo, y su primer
descendiente se asigna como hijo del padre del nodo borrado. Ejemplo: en el rbol de la figura 5 se
borra el nodo cuya clave es -1. El rbol resultante es:
29
3) El nodo tiene al menos un descendiente por cada rama. Al borrar dicho nodo es necesario
mantener la coherencia de los enlaces, adems de seguir manteniendo la estructura como un rbol
binario de bsqueda. La solucin consiste en sustituir la informacin del nodo que se borra por el de
una de las hojas, y borrar a continuacin dicha hoja. Puede ser cualquier hoja? No, debe ser la que
contenga una de estas dos claves:
la mayor de las claves menores al nodo que se borra. Suponer que se quiere borrar el nodo 4 del
rbol de la figura 5. Se sustituir la clave 4 por la clave 2.
la menor de las claves mayores al nodo que se borra. Suponer que se quiere borrar el nodo 4 del
rbol de la figura 5. Se sustituir la clave 4 por la clave 5.
El algoritmo de borrado que se implementa a continuacin realiza la sustitucin por la mayor de las
claves menores, (aunque se puede escoger la otra opcin sin prdida de generalidad). Para lograr
esto es necesario descender primero a la izquierda del nodo que se va a borrar, y despus avanzar
siempre a la derecha hasta encontrar un nodo hoja. A continuacin se muestra grficamente el
proceso de borrar el nodo de clave 4:
Codificacin: el procedimiento sustituir es el que desciende por el rbol cuando se da el caso del nodo
con descencientes por ambas ramas.
30
void borrar(tarbol **a, int elem)
{
void sustituir(tarbol **a, tarbol **aux);
tarbol *aux;
free(aux);
}
}
1. CONCEPTOS BASICOS
31
Las secuencias de aristas forman caminos o ciclos. Un ciclo es un camino que termina
en el mismo nodo donde comenz. Si el camino recorre todos los nodos del grafo es
llamado tour. El nmero de aristas en un camino es la longitud del camino.
Se dice que un grafo es conexo si se puede llegar desde cualquier nodo hasta cualquier
otro mediante un camino. De lo contrario no es conexo, pero puede dividirse en componentes
conexas, que son subconjuntos de nodos y aristas del grafo original que si son conexos. Un grafo
conexo sin ciclos es llamado un rbol.
Estos son apenas unos cuantos conceptos de lo que se conoce como la Teora de Grafos. El
objetivo de estas notas no es cubrir por completo dicha teora sino enfocarnos en la
implementacin de este tipo de estructuras y las operaciones y algoritmos ms comunes e
importantes que se aplican sobre las mismas.
2. REPRESENTACION EN EL COMPUTADOR
Hay por lo menos dos maneras evidentes de representar un grafo en un computador, utilizando
la notacin pseudoformal propuesta en [2]. La primera utiliza lo que se conoce como una
matriz de adyacencia, a saber:
CLASE Grafo
Privado:
Un valor verdadero en la posicin (i,j) de la matriz indica que hay una arista que
conecta al nodo i con el nodo j. Para representar un grafo pesado se puede cambiar la matriz
de adyacencia de lgicos a una matriz de registros, siendo el peso un campo del registro.
32
Si no se cumple la primera de estas condiciones y el nmero de nodos en el grafo puede
variar drsticamente entonces se justifica el uso de estructuras dinmicas. En este caso, lo
ideal es utilizar una lista lineal de nodos conteniendo la informacin en <Tipo>. Por
supuesto, si el nmero de nodos va a cambiar entonces tampoco se justificas tener un
matriz estticas, por lo que debera utilizarse una matriz esparcida.
entero Id;
<Tipo> Info;
Nodo proximo;
#Operaciones aqu
FCLASE
#La declaracin de los nodos para las columnas (NodoC), filas (NodoF) y
#relativa.
CLASE Grafo
Privado:
Publico:
Sin embargo, puede que esta solucin no sea la ms conveniente por el hecho de que la
matriz esparcida ocupar ms memoria que su contraparte esttica a medida que el nmero
de conexiones entre los nodos sea mayor, ya que habr pocos elementos no nulos dentro de
la matriz. En ese caso, se debe utilizar otra implementacin.
33
CLASE Nodo #Nodo de la lista de <Tipo>
Publico:
entero Id;
<Tipo> Info;
Nodo proximo;
Ady ListaDeAdyacentes;
#Operaciones aqu
FCLASE
Publico:
Nodo AdyAeste;
Ady proximo;
#Operaciones aqu
FCLASE
CLASE Grafo
Privado:
Publico:
34
# Todas las operaciones aqu
FCLASE
35
Esta representacin ocupa menos memoria que la anterior sin importar si la matriz
esparcida est muy llena o no, pero puede incrementar la complejidad de algunas
peraciones, como por ejemplo saber cules nodos son adyacentes a un nodo en particular
(en caso de un grafo dirigido).
De nuevo, si las aristas tambin tienen algn tipo de informacin asociada bastara una
leve modificacin en la clase Ady estructura para agregarla.
Por supuesto, se deben implementar las operaciones ms comunes como agregar un nodo
al grafo, eliminar un nodo del grafo y conectar un nodo con otro. En adicin, se puede
implementar todo tipo de operaciones basadas en la teora de grafos, para resolver los
problemas que se describen a continuacin.
Los algoritmos que se tratan en este texto son fundamentales y son muy tiles en muchas
aplicaciones, pero solamente son una introduccin al tema de algoritmos de grafos. Existe
un gran variedad de problemas relacionados con grafos y una gran variedad de
algoritmos para procesamiento de grafos, pero claramente no todo problema de grafos es
sencillo de resolver y en muchas ocasiones tampoco es sencillo determinar que tan difcil
puede ser resolverlo.
Fciles: Un problema fcil de procesamiento de grafos es aquel que se puede resolver
utilizando un programa eficiente y elegante. Frecuentemente su tiempo de ejecucin es
lineal en el peor caso, o limitado por un polinomio de bajo grado en el nmero de nodos o el
nmero de aristas.
Generalmente, tambin podemos decir que el problema es fcil si podemos desarrollar un
algoritmos de fuerza bruta que aunque sea lento para grandes grafos, es til para grafos
pequeos e inclusive de tamao medio. Entonces, una vez que sabemos que el problema es
fcil, buscamos soluciones eficientes y escogemos la mejor de ellas.
Tratable: Un problema tratable de procesamiento de grafos es aquel para el que se conoce
un algoritmo que garantiza que sus requerimientos en tiempo y espacio estn limitados
por una funcin polinomial en el tamao del grafo (nmero de nodos + nmero de aristas).
Todo problema fcil es tratable, pero se hace la distincin debido a que el desarrollo de
una solucin eficiente para resolverlo es extremadamente difcil o imposible. Las soluciones a
algunos problemas intratables nunca han sido escritas en programas, o tiempo tiempos de
ejecucin tan altos que no puede contemplarse su utilizacin en la prctica.
36
Intratable: Un problema intratable de procesamiento de grafos es aquel para el que no se
conoce algoritmo que garantice obtener una s o l u c i n d e l p r o b l e m a e n u n a
c a n t i d a d r a z o n a b l e d e tiempo. Muchos de estos problemas tienen la
caracterstica de que podemos utilizar un mtodo de fuerza bruta para probar todas las
posibilidades de calcular la solucin, y se consideran intratables porque existen demasiadas
posibilidades a considerar.
Esta clase de problemas es extensa y muchos expertos piensan que no existen algoritmos
eficientes para solucionar estos problemas. El trmino NP-hard describe los
problemas de esta clase, el cual representa un altsimo nivel de dificultad.
Desconocida: Existen problemas de procesamiento de grafos cuya dificultad es desconocida.
No hay un algoritmo eficiente conocido para resolverlos, ni son conocidos como NP-hard. El
problema de isomorfismo de grafos pertenece a esta clase.
37
Clausura Transitiva: Consiste en tratar de encontrar un conjunto de vrtices que pueda ser
alcanzado siguiendo aristas dirigidas desde cada vrtice del dgrafo.
Caminos cortos a partir de un mismo origen: Consiste en encontrar cuales son los caminos
ms cortos conectando a un vrtice v cualquier con cada uno de los otros vrtices de un dgrafo
pesado. Este es un problema que por lo general se presenta en redes de computadores,
representadas como grafos.
Planaridad: Consiste en estudiar si un grafo puede ser dibujado sin que ninguna de las lneas
que representan las aristas se intercepten.
38
El camino ms largo: Consiste en encontrar cual es el camino ms largo que conecte a
dos nodos dados en el grafo. Aunque parece sencillo, este problema es una versin del
problema del tour de Hamilton y es NP-hard.
Colorabilidad: Consiste en estudiar si existe alguna manera de asignar k colores a cada uno
de los vrtices de un grafo, de tal forma de que ninguna arista conecte dos vrtices del
mismo color. Este problema clsico es fcil para k=2 pero es NP-hard para k=3.
Conjunto Independiente: Consiste en encontrar el tamao del mayor subconjunto
de nodos de un grafo con la propiedad de que no haya ningn par conectado por una arista. Este
problema es NP-hard.
Clique: Consiste en encontrar el tamao del clique (subgrafo completo) ms grande en un
grafo dado.
Isomorfismo de grafos: Consiste en estudiar la posibilidad de hacer dos grafos idnticos
con solo renombrar sus nodos. Se conocen algoritmos eficientes para solucionar este
problema, para varios clases particulares de grafos, pero no se tiene solucin para el
problema general. Este problema es NP-hard.
4. RECORRIDO DE GRAFOS
Lo que diferencia un algoritmo de recorrido de otro es, una vez ubicado en un nodo en
particular, la forma en que se visitan los nodos conectados a este. Por supuesto, estos algoritmos
pueden ser aplicados en grafos dirigidos o no dirigidos.
39
Recorrido en profundidad
Para efectuar un recorrido en profundidad de un grafo, se selecciona cualquier nodo como
punto de partida (por lo general el primer nodo del grafo) y se marcan todos los nodos
del grafo como no visitados. El nodo inicial se marca como visitado y si hay un nodo
adyacente a este que no haya sido visitado, se toma este nodo como nuevo punto de partida
del recorrido. El recorrido culmina cuando todos los nodos hayan sido visitados.
Se dice que el recorrido es en profundidad, porque para visitar otro nodo adyacente del
nodo inicial, primero se deben visitar TODOS los nodos adyacentes al que se eligi antes.
Es as, como el nmero de ambientes recursivos vara dependiendo de la profundidad que
alcance el algoritmo.
Ady aux;
#visitarlos
fsi
40
aux aux .proximo;
fmientras
FACCION
Publico:
Nodo aux;
aux primerNodo;
#ponentes conexas
DFS_R(aux);
fsi
fmientras
FACCION
Este algoritmo recorre todos los nodos del grafo pero fcilmente puede modificarse para
que sea una funcin que encuentre un nodo en particular dentro de grafo. Este algoritmo
se conoce como el algoritmo DFS (Depth-First Search).
41
Una bondad de este algoritmo es que los nodos solo se vistan una vez. Esto implica que si
se salvan en alguna estructura las aristas que se van recorriendo se obtiene un conjunto
de aristas de cubrimiento mnimo del grafo, lo cual se utiliza frecuentemente se utiliza para
reducir la complejidad del grafo cuando la perdida de informacin de algunas aristas no es
importante. Este resultado se conoce como rbol DFS (DFS Tree).
0 2 0 2
6 6
1 7 1 7
3 3
5 4 5 4
El DFS puede modificarse fcilmente y utilizarse para resolver problemas sencillos como
los de conectividad simple, deteccin de ciclos y camino simple. Por ejemplo, el nmero
de veces que se invoca a la accin DFS_R desde la accin DFS en el algoritmo anterior es
exactamente el nmero de componentes conexas del grafo, lo cual representa la solucin al
problema de conectividad simple.
Recorrido en anchura
En este algoritmo tambin se utiliza la estrategia de marcas los nodos como visitados
para detectar la culminacin del recorrido, pero los nodos se recorren de una manera
ligeramente distinta.
De nuevo, se selecciona cualquier nodo como punto de partida (por lo general el primer
nodo del grafo) y se marcan todos los nodos del grafo como no visitados. El nodo inicial se
marca como visitado y luego se visitan TODOS los nodos adyacentes a este, al finalizar este
42
proceso se busca visitar nodos ms lejanos visitando los nodos adyacentes a los nodos
adyacentes del nodo inicial.
Este algoritmo puede crear menos ambientes recursivos que el anterior porque visita ms
nodos en un mismo ambiente, pero esto depende de cmo este construido el grafo. El algoritmo
se conoce como el algoritmo de BFS (Breadth-First Search).
Este algoritmo tiene exactamente el mismo orden en tiempo de ejecucin del algoritmo de
recorrido en profundidad y tambin se puede obtener el conjunto de aristas de cubrimiento mnimo
del grafo.
Una diferencia notable entre el DFS y el BFS es que este ultimo necesita de una estructura
auxiliar, que por lo general es una cola, para el almacenamiento de las aristas que se van a
visitar durante el recorrido.
0 2 0 2 0 2
1 7 1 7 1 7
6 6 6
3 3 3
5 4 5 4 5 4
C: 0 -5 0-7 2-6 C: 0-7 2-6 5-3 5-4
C: 0 -2 0-5 0-7
0 2 0 2 0 2
6 6 6
1 7 1 7 1 7
3 3 3
5 4 5 4 5 4
C: 2 -6 5-3 5-4 7-1 7-4 C: 5-3 5-4 7-1 7-4 6-4 C: 5-4 7-1 7-4 6 -4 3 -4
43
0 2 0 2
6 6
1 7 1 7
3 3
5 4 5 4
0 2 0 2
6 6
1 7 1 7
3 3
5 4 5 4
44
Tambin puede modificarse fcilmente y utilizarse para resolver problemas sencillos
como los de conectividad simple, deteccin de ciclos y camino simple.
El BFS es el algoritmo clsico para encontrar el camino ms corto entre dos nodos especficos en
un grafo, mientras que DFS nos ofrece muy poca ayuda para esta tarea debido a que el
orden en el que se visitan los nodos no tiene absolutamente ninguna relacin con la longitud
de los caminos.
Todo camino en un dgrafo pesado tiene un peso asociado, el cual es la suma de los pesos de
las aristas del camino. Esta medida esencial nos permite formular problemas como el de
encontrar el camino con el menor peso entre dos vrtices. El tpico de esta seccin es el
clculo de este tipo de camino, donde la longitud del camino no se mide en base al
nmero de aristas del mismo, sino en base al peso del camino.
Con esto ltimo en mente, definiremos al camino ms corto entre dos nodos de un dgrafo
pesado, como el camino dirigido que tenga la propiedad de tener el peso mnimo entre
todos los caminos que existan entre dicho par de nodos.
45
El primero de estos problemas no es ms que un caso particular del segundo. En lo
que respecta al segundo, por ol general lo que se busca es tratar de obtener un rbol de
caminos ms cortos o el SPT (shortest-path tree), que consiste en un rbol dirigido que
tiene como raz al nodo origen y todo camino en el rbol en un camino corto en el grafo. El tercero
de los problemas se puede resolver obteniendo los SPT correspondientes a cada uno de los
nodos del grafo.
Algoritmo de Dijkstra
El algoritmo de Dijkstra resuelve el problema de encontrar los caminos ms cortos a partir de un
origen, en grafos pesados que no tengan pesos negativos.
entero i,w,v;
Arreglo D de real [1..N]; # arreglo auxiliar de costos
Arreglo P de entero [1..N]; # arreglo que guarda los caminos ms
# cortos
46
#el esbozo del algoritmo de Dijkstra
S.Agregar(w);
47
D[v] min (D[v], D[w]+C[w,v]);
Fpara
P[v] w;
Fpara
10 100
30
2
5
50 10
60
3
20
4
48
Al final de la ejecucin el arreglo P debe tener los valores P[2]=1, P[3]=4 , P[4]=1 y P[5]=3.
Para encontrar el camino ms corto del nodo 1 al nodo 5, por ejemplo, se siguen los
predecesores en orden inverso comenzando en 5. As, es sencillo encontrar que el camino
ms corto del nodo 1 al 5, es el 1, 4, 3, 5.
Usando el arreglo P, o bien mediante alguna otra heurstica, se puede construir fcilmente
un SPT, tomando el nodo inicial del recorrido como raz del rbol y luego aadiendo una
arista y un nodo a la vez, siempre tomando la prxima arista que pertenezca al camino ms
corto a un nodo que no est en el SPT.
Aunque se puede ejecutar Dijkstra N veces para resolver el problemas de caminos cortos
entre cada par de nodos, el Algoritmo de Floyd [5] tambin resuelve este problema, con una
complejidad en tiempo similar.
El problema de encontrar el MST de un grafo pesado no dirigido arbitrario tiene una gran
cantidad de aplicaciones importantes y se conocen algoritmos para encontrarlo al menos
49
desde 1920, pero la eficiencia de las implementaciones vara ampliamente y los investigadores
an buscan mejores mtodos. En esta seccin se examinan dos algoritmos clsicos para
resolver este problema.
Algoritmo de Prim
U U
0 5 0 0
1 3 3 1 3
5
1 2 1 1
4
2 2 2
0 U 0
1 3 1 3
1 1 2
50
4 4
2 2
0 5 0 5 0 5 0 5
1 3 1 3 1 3 1 3
5 5 5 5
1 2 1 2 1 2 1 2
4 4 4 4
2 2 2 2
51
Se comienza en el nodo 0 y se apilan las aristas adyacentes a este nodo, en
orden decreciente. La arista mnima es la que esta en el tope de la pila, as que se
desapila y se agrega al MST. Seguidamente se procede con el nodo 1 y se apilan sus
aristas adyacentes, con la diferencia de que hay que verificar si dichas aristas
representan un nuevo camino mnimo con respecto a las aristas que ya estn
introducidas en la pila. En este caso no se apila la arista 1-3 porque ya hay una arista
que lleve a 3 con el mismo costo en la pila. Se toma 1-2 porque esta en el tope y se
procede con el nodo 2. Cuando se va a apilar la arista
2-3, se encuentra que ya hay un camino que lleve a 3 pero de mayor costo, as que
se desapila 0-3 y luego se apila 2-3. Se agrega 2-3 al MST y termina el proceso, porque el
conjunto de nodos en el MST es igual al conjunto de vrtices del grafo original.
Algoritmo de Kruskal
El algoritmo de Prim construye un MST una arista a la vez, encontrando una nueva arista
que agregar a un MST que va creciendo en cada paso. El algoritmo de Kruskal
tambin construye el MST una arista a la vez, con la diferencia que este encuentra una
arista que conecte dos MST que van creciendo dentro de un bosque de MST
crecientes, formado de los nodos del grafo original.
Dada una lista de las aristas del grafo, el primer paso del algoritmo de Kruskal es ordenarlas
por peso (usando un quicksort por ejemplo). Luego se van procesando las aristas en el
orden de su peso, agregando aristas que no produzcan ciclos en el MST. El algoritmo de
Kruskal es de O(A*log2 A), donde A es el nmero de aristas del grafo. El siguiente ejemplo
ilustra el funcionamiento del algoritmo. La secuencia de ilustraciones va de izquierda a
derecha y de arriba hacia abajo.
52
0 0 0 0
3 1 3 1 3 1 3
1 1 1 2 1 2
4
2 2 2 2
ALGORITMOS DE ORDENACIN
Dado un conjunto de n elementos a1, a2,..., an y una relacin de orden total () sobre ellos, el
problema de la ordenacin consiste en encontrar una permutacin de esos elementos ordenada de
forma creciente.
Aunque tanto el tipo y tamao de los elementos como el dispositivo en donde se encuentran
almacenados pueden influir en el mtodo que utilicemos para ordenarlos, en este tema vamos a
solucionar el caso en que los elementos son nmeros enteros y se encuentran almacenados en un
vector.
Si bien existen distintos criterios para clasificar a los algoritmos de ordenacin, una posibilidad es
atendiendo a su eficiencia. De esta forma, en funcin de la complejidad que presentan en el caso
medio, podemos establecer la siguiente clasificacin:
53
a[i] en su sitio correcto, aprovechando el hecho de que el subvector a [1..i1] ya ha sido previamente
ordenado. Este mtodo puede ser implementado de forma iterativa como sigue:
Este mtodo se muestra muy adecuado para aquellas situaciones en donde necesitamos ordenar
un vector del que ya conocemos que est casi ordenado, como suele suceder en aquellas
aplicaciones de insercin de elementos en bancos de datos previamente ordenados cuya
ordenacin total se realiza peridicamente.
El mtodo de ordenacin por insercin es similar al proceso tpico de ordenar tarjetas de nombres
(cartas de una baraja) por orden alfabtico, que consiste en insertar un nombre en su posicin
correcta dentro de una lista o archivo que ya est ordenado. As el proceso en el caso de la lista de
enteros A = 50, 20, 40, 80, 30.
(novella.mhhe, n.d.)
En cada paso (i=1...n1) este mtodo busca el mnimo elemento del subvector a[i..n] y lo
intercambia con el elemento en la posicin i:
54
(Tecnicas de diseo de algoritmos)
Un ejemplo prctico ayudar a la comprensin del algoritmo. Consideremos un array A con 5 valores
enteros 51, 21, 39, 80, 36:
(novella.mhhe, n.d.)
ORDENACIN BURBUJA
55
Este mtodo de ordenacin consiste en recorrer los elementos siempre en la misma direccin,
intercambiando elementos adyacentes si fuera necesario:
Este algoritmo funciona de forma parecida al de Seleccin, pero haciendo ms trabajo para llevar
cada elemento a su posicin. De hecho es el peor de los tres vistos hasta ahora, no slo en cuanto
al tiempo de ejecucin, sino tambin respecto al nmero de comparaciones y de intercambios que
realiza.
Una posible mejora que puede admitir este algoritmo es el control de la existencia de una pasada
sin intercambios; en ese momento el vector estar ordenado.
56
(novella.mhhe, n.d.)
57
ORDENACIN POR MECLA (MERGESORT)
Este mtodo utiliza la tcnica de Divide y Vencers para realizar la ordenacin del vector a. Su
estrategia consiste en dividir el vector en dos subvectores, ordenarlos mediante llamadas recursivas,
y finalmente combinar los dos subvectores ya ordenados. Esta idea da lugar a la siguiente
implementacin:
El mtodo de ordenacin por Mezcla se adapta muy bien a distintas circunstancias, por lo que es
comnmente utilizado no slo para la ordenacin de vectores. Por ejemplo, el mtodo puede ser
tambin implementado de forma que el acceso a los datos se realice de forma secuencial, por lo
que hay diversas estructuras (como las listas enlazadas) para las que es especialmente apropiado.
Tambin se utiliza para realizar ordenacin externa, en donde el vector a ordenar reside en
dispositivos externos de acceso secuencial (i.e. ficheros).
(Hernndez, n.d.)
58
ORDENACIN RPIDA DE HOARE (QUICKSORT)
59
(novella.mhhe, n.d.)
El algoritmo quicksort requiere una estrategia de particin y la seleccin idnea del pivote. Las
etapas fundamentales del algoritmo dependen del pivote elegido aunque la estrategia de particin
suele ser similar.
ALGORITMOS DE BSQUEDA
Bsqueda:
Es un proceso para encontrar un elemento objetivo especfico dentro de un grupo de
elementos.
Comprobar que el elemento objetivo no existe dentro del grupo.
El equipo de elementos en el que se est buscando conjunto de bsqueda.
Esttica, Dinmica.
60
Segn donde se estn ubicando los datos Externos: Almacena en la memoria secundaria:
Discos, Hash.
Bsqueda Interna:
Lineal o secuencial, Binaria, Indirecta.
Por transformaciones de clave o funciones Hash.
Inicio Fin
1 . . . . . . . .
Bsqueda Binaria
Se da si el conjunto de elementos de la bsqueda esta ordenado, entonces la tcnica tiene ms
eficiencia que la anterior.
Este tipo de algoritmos elimina partes del conjunto de bsqueda en cada componente,
aprovechando que el conjunto de bsqueda est ordenado.
61
(Rosita Wachenchauzer, n.d.)
Con las funciones Hash los elementos se almacenan en una tabla de Hash, estando su ubicacin
dentro de la tabla determinada por la funcin Hash, donde cada ubicacin de la tabla se denominara
celda o franja.
Suponga que se quiere crear o almacenar una matriz que albergue 26 elementos:
Nombre --> CREAR FUNCION HASH que asigne a cada nombre una posicin dentro de la matriz que
estar asociada con la primera letra del nombre.
0 Ana
62
1 Brian
2 Carlos
3 David
4 Erika
5 Fabricio
6 Gabriela
7 Helena
.
.
.
. Maritza
.
.
.
. Tomas
.
. Walter
31 Yolanda
COLISIONES
Funcin Hash Perfecta
Es una funcin Hash que asigne a cada elemento a una posicin nica de la tabla.
Una funcin Hash que se limita a distribuir adecuadamente los elementos entre las distintas
posiciones de la tabla, tambin proporcionara los resultados.
63
Factor De Carga (Fc)
El factor de carga de una tabla Hash es el porcentaje de ocupacin de la tabla para la cual
deber procederse a redimensionar.
EJEMPLO:
Si el factor de carga fuera 0.50 la tabla se redimensionara cada vez que alcance el 50%
de ocupacin.
FUNCIONES HASH
El objetivo es encontrar una funcin que permita distribuir de forma razonable (buena) los
elementos dentro de la tabla de forma que se eviten las colisiones.
Una funcin Hash razonablemente segura procurando en tiempo de acceso constante (0, 1) al
conjunto de datos.
Para ello existen tcnicas para desarrollar una funcin Hash para un conjunto de datos concretos.
Utilizar nicamente una parte de la clave o del valor de elemento con el fin de calcular la
ubicacin en donde se debe almacenar el elemento.
Extraccin: Implica en utilizar nuevamente una parte del valor o de la clave del elemento
con el fin de calcular la ubicacin en la que se almacenar.
MTODO DE DIVISIN
Este mtodo consiste en tomar el resto de la divisin por m, el nmero de entradas de la tabla, asi
h (k) = ( k mod m).
Usar m = una potencia de 2, no es buena idea, ya que el valor de hash queda dependiendo de slo
los bits menos significativos de k.
Una forma de hacer hash (k) dependiente de todos los bits menos significativos es usar nmero
primos no muy cercanos a una potencia de dos.
Este mtodo opera en dos pasos. Primero, multiplicamos la clave por una constante A en el rango 0
< A < 1 y extraemos la parte fraccionaria de k*A. Segundo, Multiplicamos este valor por el nmero
de entradas de la tabla y tomamos el piso del (o truncamos el) resultado.
COLISIONES
Prueba lineal
Prueba cuadrtica
Doble direccionamiento
PRUEBA LINEAL
Consiste en que una vez que se detecta la colisin se recorre el arreglo secuencialmente a partir de
una colisin, buscando al elemento. El proceso de bsqueda concluye cuando el elemento es
hallado, o cuando se encuentra una posicin vaca. El arreglo se trata como una estructura circular.
64
PRUEBA CUADRATICA
Similar a la anterior se diferencia porque las direcciones en esta se obtienen con la frmula:
Permite una mejor distribucin de las claves que colisionan aunque tiene como desventaja que
pueden quedar casillas o celdas sin visitar.
25, 43, 56, 35, 54, 13, 80, 104, 55 y que son asignados segn la siguiente funcin hash.
1 80 K h(k)
D i Dx
2 55 25 6
1 7
3 43 4
6 2 10
4 43 56 7
5 54 35 9
6 25 54 5
7 56 13 4
8 13 104 5
9 104 55 6
10 35
Al aplicar la funcin Hash a la 35, se obtiene la direccin D=6 pero de esta posicin no est el valor
buscado, entonces se calcula Dx en la posicin como la suma D + (1*J), obtenindose la direccin 7,
en donde la bsqueda termine cuando se encuentre el valor deseado, en este caso en la posicin
10
DOBLE DIRECCIONAMIENTO
Es un mtodo que consiste en que una vez que se detecta la colisin, se genera otra direccin
aplicando la misma funcin Hash a la direccin previamente obtenida.
D J Dx
D(H(O)) 6 1 7
D'(H(O)) 2 10
D''(H(O)) 3 15
0 1
2
65
La funcin Hash que se aplica no necesariamente tiene que ser la misma que se utiliz
originalmente, si no que una vez detectada la colisin se debe generar otra colisin.
Por lo tanto, se puede deducir que no existe una regla que permita decidir cul es la mejor funcin
utilizada en el clculo de una sucesin de direcciones.
25, 43, 56, 35, 54, 13, 80, 104 h (k) = (k mod 10)+1.
1
2
3
4 41
5 54
6 25
7 56
8 35
9 104
10 13
Arreglos anidados
Este mtodo consiste en que cada elemento del arreglo tenga otro arreglo, en el cual se almacenan
los elementos que colisionan. Este mtodo resulta ser ineficiente ya que al trabajar con arreglos se
depende del espacio que se haya asignado a los mismos, lo cual resulta un nuevo problema, este
problema es saber el tamao de la segunda estructura que controla la segunda dimensin.
Encadenamiento
Consiste en que cada posicin de la estructura contenga una lista ligada, la cual crecer con cada
elemento que entre en la estructura, sobre todo con los elementos que generen una colisin. Este
es el mtodo ms eficiente debido a que las listas ligadas son dinmicas y evitan tener tantos lugares
libres como el mtodo arreglos anidados. Como desventaja se puede encontrar que cuando la lista
ligada crece demasiado se pierde la facilidad de acceso directo del mtodo hash.
66
Uno de los principales problemas que se aborda en este contexto es la bsqueda de patrones en un
texto. La aplicacin principal es la bsqueda de palabra en un fichero de texto o las bsquedas
relacionados con la biologa computacional, en donde se requiere buscar patrones dentro de una
secuencia de ADN, la cual puede ser modelada como una secuencia de caracteres.
Los algoritmos de coincidencia de cadenas son componentes bsicos utilizados en las
implementaciones prcticas de software existentes en la mayora de sistemas operativos. Por otra
parte, destacan los mtodos de programacin que sirven como paradigmas en otros campos de la
ciencia de la computacin (sistema o diseo de software). Tambin juegan un papel importante en
la informtica terica.
Aunque los datos se memorizan en diversas formas, el texto sigue siendo la forma principal para
intercambiar informacin. Esto es particularmente evidente en la literatura o la lingstica donde
los datos se componen de enorme corpus y diccionarios. Es aplicable donde se necesite almacena
una gran cantidad de datos en archivos lineales.
As, si se quisiera encontrar la ocurrencia de un patrn dentro de un determinado texto, tendramos
que conocer el tamao o longitud del texto donde se quiere buscar y el tamao o longitud del patrn
a buscar.
Suponiendo que n representa la longitud de la cadena de texto y m la longitud del patrn,
tendramos:
n representara el texto donde se quiere buscar, es decir texto = a1, a2, a3,an
m, la longitud del patrn a buscar, es decir patrn = b1, b2, b3,bn
Ejemplo:
En el texto = "anlisis de algoritmos", n=22
y el patrn a buscar: patrn = "algo", m= 4
Fortalezas y debilidades
Fortalezas
Amplia aplicabilidad
Simplicidad
Lleva a disear algoritmos que permiten resolver razonablemente algunos problemas
importantes (e.g., multiplicacin de matrices, ordenamiento, bsqueda de subcadenas,
etc.)
Pueden ser punto de referencia para desarrollar algoritmos ms efectivos
Debilidades
Raramente llevan a desarrollar algoritmos altamente eficientes
Algunos algoritmos de fuerza bruta son extremadamente lentos.
67
El algoritmo Knuth-Morris-Pratt (KMP)
Suponga que se est comparando el patrn y el texto en una posicin dada, cuando se encuentra
una discrepancia.
Sea X la parte del patrn que calza con el texto, e Y la correspondiente parte del texto, y suponga
que el largo de X es j. El algoritmo de fuerza bruta mueve el patrn una posicin hacia la derecha,
sin embargo, esto puede ser o no lo correcto en el sentido que los primeros j-1 caracteres de X
pueden o no pueden calzar los ltimos j-1 caracteres de Y.
La observacin clave que realiza el algoritmo Knuth-Morris-Pratt(en adelante KMP) es que X es igual
a Y, por lo que la pregunta planteada en el prrafo anterior puede ser respondida mirando
solamente el patrn de bsqueda, lo cual permite pre calcular la respuesta y almacenarla en una
tabla.
Por lo tanto, si deslizar el patrn en una posicin no funciona, se puede intentar deslizarlo en 2, 3,
..., hasta j posiciones.
Se define la funcin de fracaso (failurefunction) del patrn como:
()=max(<|1==+1
Intuitivamente, f(j) es el largo del mayor prefijo de X que adems es sufijo de X. note que j = 1 es un
caso especial, puesto que si hay una discrepancia en b1 el patrn se desliza en una posicin.
68
Si se detecta una discrepancia entre el patrn y el texto cuando se trata de calzar bj+1, se desliza
el patrn de manera que bf(j) se encuentre donde bj se encontraba, y se intenta calzar
nuevamente.
Suponiendo que se tiene f(j) precalculado, la implementacin del algoritmo KMP es la siguiente:
Algoritmo Boyer-Moore
Hasta el momento, los algoritmos de bsqueda en texto siempre comparan el patrn con el texto
de izquierda a derecha. Sin embargo, suponga que la comparacin ahora se realiza de derecha a
izquierda: si hay una discrepancia en el ltimo carcter del patrn y el carcter del texto no aparece
en todo el patrn, entonces ste se puede deslizar m posiciones sin realizar ninguna comparacin
extra. En particular, no fue necesario comparar los primeros m-1 caracteres del texto, lo cual indica
que podra realizarse una bsqueda en el texto con menos de n comparaciones; sin embargo, si el
carcter discrepante del texto se encuentra dentro del patrn, ste podra desplazarse en un
nmero menor de espacios.
El mtodo descrito es la base del algoritmo Boyer-Moore, del cual se estudiarn dos variantes:
Horspool y Sunday.
69
Boyer-Moore-Horspool (BMH)
El algoritmo BMH compara el patrn con el texto de derecha a izquierda, y se detiene cuando se
encuentra una discrepancia con el texto. Cuando esto sucede, se desliza el patrn de manera que la
letra del texto que estaba alineada con bm, denominada c, ahora se alinee con algn bj, con j<m, si
dicho calce es posible, o con b0, un carcter ficticio a la izquierda de b1, en caso contrario (este es el
mejor caso del algoritmo).
Para determinar el desplazamiento del patrn se define la funcin siguiente como:
0 si c no pertenece a los primeros m-1 caracteres del patrn (Por qu no se considera el carcter
bm?).
jsi c pertenece al patrn, donde j<m corresponde al mayor ndice tal que bj==c.
Esta funcin slo depende del patrn y se puede precalcular antes de realizar la bsqueda
Se puede demostrar que el tiempo promedio que toma el algoritmo BMH es:
70
dondec es el tamao del alfabeto (c<<n). Para un alfabeto razonablemente grande, el algoritmo es:
().
En el peor caso, BMH tiene el mismo tiempo de ejecucin que el algoritmo de fuerza bruta
Boyer-Moore-Sunday (BMS)
El algoritmo BMH desliza el patrn basado en el smbolo del texto que corresponde a la posicin del
ltimo carcter del patrn. Este siempre se desliza al menos una posicin si se encuentra una
discrepancia con el texto.
Es fcil ver que si se utiliza el carcter una posicin ms adelante en el texto como entrada de la
funcin siguiente el algoritmo tambin funciona, pero en este caso es necesario considerar el patrn
completo al momento de calcular los valores de la funcin siguiente. Esta variante del algoritmo es
conocida como Boyer-Moore-Sunday (BMS).
Es posible generalizar el argumento, es decir, se pueden utilizar caracteres ms adelante en el texto
como entrada de la funcin siguiente? La respuesta es no, dado que en ese caso puede ocurrir que
se salte un calce en el texto.
CONCLUSIONES:
El mtodo de bsqueda secuencial compara cada elemento del arreglo con el valor a
encontrar hasta que se consiga o hasta leer todo el arreglo.
La bsqueda secuencial examina el vector desde el primer elemento hasta llegar al ltimo.
El ordenamiento por burbuja consiste en llevar los elementos menores a la izquierda o a los
mayores a la derecha del conjunto de elementos en el arreglo.
El mtodo de la burbuja es la tcnica ms usada por su comprensin fcil, aunque en la
programacin este consume mucho tiempo de computadora.
El mtodo de bsqueda binaria se encarga de examinar primero el elemento central de la
lista, si este es el elemento buscado entonces la bsqueda termino.
La bsqueda binaria se utiliza en vectores ya ordenados.
El rendimiento del mtodo de ordenamiento quicksort depende de la buena eleccin de un
pivote, esto permite que este sea ms ptimo que el mtodo de ordenamiento mergesort.
Las colisiones se producen cuando, despus de implementar una funcin hash en dos entradas
distintas, se produce una misma salida, por lo tanto se obtienen dos datos en una misma salida.
La eleccin de un mtodo adecuado para resolver estas colisiones es tan importante como elegir
correctamente la funcin hash.
Hay tres mtodos importantes que son, Resignacin, Arreglos anidados, Encadenamiento
El mtodo de arreglos anidados, es un mtodo que presenta dificultades y no es muy
aconsejable utilizar por su gran costo en cuanto a memoria, ya que se desperdician demasiados
espacios.
71
Algoritmos Voraces
Tcnicas sencillas, dan solucin a varios problemas, especialmente problemas de optimizacin,
siguen una heurstica consistente en elegir la opcin optima en cada paso local con la esperanza
de llegar a una solucin general optima como por ejemplo contar la secuencia ptima para
procesar un conjunto de tareas automatizadas o el camino ms corto de un grafo.
Un algoritmo voraz recibe su nombre debido a que en cada paso el algoritmo escoge el mejor
trozo que es capaz de engullir sin preocuparse de lo que pueda pasar en el futuro.
Nunca desase una decisin ya tomada, una vez incorporado un candidato a la solucin, permanece
hasta el final y cada vez que un candidato es rechazado este no se puede recuperar
posteriormente.
Un algoritmo voraz llega a una solucin, donde una seleccin se hace en base a lo que es mejor en
cada momento, no obstante sin embargo un buen algoritmo voraz puede llegar de este modo a la
solucin global ms optima
Existe una entrada de tamao n, llamadas los candidatos tienen una parte de la solucin
Dado un conjunto de esos n candidatos que satisface ciertas condiciones (Solucin Factible)
Obtener la solucin factible que maximice o minimice una cierta funcin llamada la solucin
ptima.
Un funcin de seleccin que escoge el candidato no seleccionando (tiempo total del proceso, la
longitud del camino).
En cada paso intenta aadir al conjunto de los seleccionados "el mejor". De los no escogidos
orillando una funcin de seleccin basado en algn criterio de seleccin
72
Si el conjunto no es completable, se rechaza el ltimo candidato y no se vuelve a tomar en cuenta
en el futuro
Aplicabilidad
Ejemplo
monedas de 1 2 5 10 20 y 50 cntimos
Se quiere devolver 50 centollos
La funcin de seleccin consiste en coger la solucin en la caja entre las disponibles
Procedimiento
Al inicio la moneda mayor sera de 50 cntimos
Se elige y la cantidad que se dispone no es mayor que la solucin por lo que la moneda de 50 de
matin en la solucin
La siguiente moneda de mayor denominacin que se tiene ahora es de 1 euro, al ser mayor que la
cantidad a devolver la moneda de 50 cntimos no pasa a la solucin y se elimina de la lista de
candidatos.
En este punto, de elije la moneda de 20 cntimos pero la cantidad total es de 70 cntimos as que
no pasa a la solucin y se elimina de la lista de candidatos
Moneda 50 25 5 1 Monedas 6 4 1
Cantidad 3 4 1 6 Cantidad 3 4 1
73
74
Divide y vencers
1. Multiplexacion de matrices
Rpida
Algoritmo de Shassen
Algoritmo de Strassen
2. Ordenamiento
Quicksort
Mergesort
Definicin
Es una tcnica algortmica para resolver problemas grandes, dividindolo en subproblemas o
subproblemas ms pequeos, que se denomina divide y vencers (Los subproblemas son del
mismo tipo)
En los casos en que un subproblema sigue siendo grande se aplica nuevamente el proceso hasta
obtener un problema lo suficientemente pequeo para resolverlo directamente, esto utiliza
recursin
Algoritmo
PROCEDURE DV(x:TipoProblema):TipoSolucion;
VAR i,k:CARDINAL;
s:TipoSolucion;
subproblemas: ARRAY OF TipoProblema;
subsoluciones:ARRAY OF TipoSolucion;
BEGIN
IF EsCasobase(x) THEN
s:=ResuelveCasoBase(x)
ELSE
k:=Divide(x,subproblemas);
FOR i:=1 TO k DO
subsoluciones[i]:=DV(subproblemas[i])
END;
s:=Combina(subsoluciones)
END;
RETURN s
END DV;
Divisin
Resolver independiente todos los subproblemas en caso de que se pueda resolver directamente, o
aplicar recursividad, teniendo en cuenta que el tamao de los subproblemas sea estrictamente
menor que el tamao del problema original. Garantiza la convergencia a los casos
elementales CASO BASE
75
Combinar las soluciones obtenidas en el paso 2 para construir la solucin del problema original
Cuando el algoritmo D y V tiene slo una llamada recursiva con = 1 entonces se denomina
algoritmos de simplificacin, un ejemplo de esto es el clculo del factorial o la bsqueda binaria
Ventajas
Permite conseguir reducir el tamao del problema en cada paso por ello los tiempos de ejecucin
pueden ser de orden logartmico o lineal.
Pueden tambin ser candidatos para eliminar la recursin utilizando un bucle iterativo,
consiguiendo un menor tiempo de ejecucin y menor complejidad espacial
En estos algoritmos D y V Se debe conseguir que los subproblemas sean independientes, es decir
que no exista solapamiento entre cada uno de ellos, cada uno debe cumplir una tarea -> tiempo
de ejecucin exponencial en caso de que no se consiga
Divide y vencers
Buscar la eficiencia:
1 ,
() { 2
( ) , , > 0
Donde a, c y k son nmeros reales, n y b son nmeros naturales
76
Anlisis de complejidad
( ) <
() = { ( log()) =
(log( ) ) >
Las diferencias surgen de los distintos valores que pueden tomar a y b que los que determinan el
nmero de subproblemas y su tamao.
Lo importante radica en que en todos los casos la complejidad es de orden polinmico pero nunca
exponencial, si se ren en cuanto a los algoritmos recursivos que pueden alcanzar dicha
complejidad
77
Programacin dinmica determinstica y probabilstica
Distancia de Levenstein
Programacin dinmica
Procesamiento de imgenes
Ejemplo:
1. Divisin de un rbol de subproblemas
2. Niveles de recursin
1234 12 100 + 34
5678 56 100 + 78
1234 5678 = (12 100 + 34) (56 100 + 78)
1234 5678 = (12 56 + 10000) + (12 78 + 34 56) + 100 + (34 78)
Se reduce la multiplicacin de 4 cifras a 4 multiplicaciones de 2cifras ms 3 sumas y varios
desplazamientos
Divisin
= 12345678 = 104 +
= 24680135 = 104 +
Combinacin
78
= ( 104 + ) ( 104 + )
= 104 + ( + ) 104
Algoritmos Expuestos
Multiplicacin rpida de matrices
Aplicando divide y vencers, cada matriz es dividida en cuatro submatrices de tamao (n/2)x(n/2):
Aij, Bij y Cij
C =A B +A B
11 11 11 12 21
C =A B +A B
12 11 12 12 22
C21 = A21B11 + A22B21
C =A B +A B
22 21 12 22 22
Algoritmo de Strassen
Volker Strassen public el algoritmo de Strassen en 1969. Pese a que su algoritmo es slo
ligeramente ms rpido que el algoritmo estndar para la multiplicacin de matrices, fue el
primero en sealar que el enfoque estndar no es ptimo. Este algoritmo es til en la prctica para
matrices grandes.
En base a este enfoque se establece las siguientes operaciones de la matriz para poder establecer
solo 7 multiplicaciones
M = (A - A )(B +B )
1 1,2 2,2 2,1 2,2
M = (A + A )(B +B )
2 1,1 2,2 1,1 2,2
M = (A - A )(B +B )
3 1,1 2,1 1,1 2,1
M = (A + A )B
4 1,1 1,2 2,2
M = A (B -B )
5 1,1 1,2 2,2
M = A (B -B )
6 2,2 2,1 1,1
M = (A + A )B
7 2,1 2,2 1,1
79
C =M +M -M +M
1,1 1 2 4 6
C =M +M
1,2 4 5
C =M +M
2,1 6 7
C =M -M +M -M
2,2 2 3 5 7
2 log2(7) 2.81
El nuevo tiempo de ejecucin es de T(n) = 7T(n/2) + O(n ), es decir, de T(n) = O(n ) = O(n ).
Este algoritmo slo es mejor que el directo cuando n es muy grande, y es ms inestable cuando se
utiliza con nmeros reales, por lo que tiene una aplicabilidad limitada.
Para el caso general en el que n no es potencia de 2, se pueden rellenar las matrices con ceros
hasta que las dos matrices sean cuadradas y n sea una potencia de 2.
Se basa en la divisin en particiones de la lista a ordenar, por lo que se puede considerar que
aplica la tcnica "divide y vencers.
Ejemplo:
80
Mergesort
Analisis:
81
Programacin Dinmica
Algoritmo de Needleman Wush Alineacin de cadenas globales
Programacin dinmica determinstica y probabilstica
Distancia de Levenstein
Concepto
En Divide y Vencers para resolver un problema es te se divide en subproblemas independientes,
los cuales se resuelven de manera recursiva para combinar finalmente las soluciones + resolver el
problema original, pero el problema se presenta cuado los subproblemas obtenidos no son
independientes si no que existen solapamiento entre los mismos. Por ello surge la Programacin
dinmica.
Si se resuelve cada subproblema distinto una sola vez y se guarda el resultado, el algoritmo es ms
eficiente.
La eficiencia de esta tcnica consiste en resolver los subproblemas una sola vez guardando las
soluciones en una tabla de manera que se puedan utilizar posteriormente.
82
En una secuencia de deducciones ptimas, toda subsecuencia no ha de ser ptima. Pero no
siempre se cumple por lo tanto hay que verificar que se cumpla.
Estos algoritmos aplican el principio de memorizacin, el cual consiste en almacenar las soluciones
a los subproblemas en una estructura para ser usadas posteriormente.
Objetivos de la memorizacin
Evitar calcular un mismo su problema varias veces
Guardar la solucin obtenida
Hacer uso de una matriz la culpa se va rellenando conforme a las soluciones de los subproblemas
(espacio vs tiempo)
Aplicaciones:
Distancia entre dos series temporales: (2 )
DTW (dynamic time warpine)
Anlisis sintctico: (3 )
83
Algoritmo de Cucle Kasami Younges
Algoritmos de Earley
Algoritmo de Viterloi (arena ocultas de marcas)
Decodificacin de seales (mdem, wifi, etc)
Procesamiento de lenguaje natural
Bioinformtica
Optimizacin de consultas BDDR
Comparacin de ficheros
Algoritmo de Needleman
Determinacin dinmica determinstica y probabilstica
Distancia de edicin de cadenas (Levenstein)
p=0 p=1 p=2 p=3 p=4 p=5 p=6 p=7 p=8 p=9
n=0 1
n=1 1 1
n=2 1 2 1
n=3 1 3 3 1
n=4 1 4 6 4 1
n=5 1 5 10 10 5 1
n=6 1 6 15 20 15 6 1
n=7 1 7 21 35 35 21 7 1
n=8 1 8 28 56 70 56 28 8 1
n=9 1 9 36 84 126 126 84 36 9 1
Dicho alineamiento se lleva a cabo desde el principio hasta el final de ambas secuencias para
encontrar el mayor animen sobro posible a travs de la longitud entre las dos secuencias.
Secuencia 1 G T A C G C T T A A G G T T A A
84
Secuencia 2 T A C _ _ _ _ _ A _ _ T _ A _
El programa determina el alineamiento ptimo haciendo coincidir dos secuencias para todos los
posibles pares de caracteres entre las dos secuencias.
La PD primero construye la matriz bidimensional en cuyos ejes esta las secuencias a comparar, el
emparejamiento de un residuo se har segn la matriz de puntuacin.
Las puntuaciones se calculan fila por fila, se comienza por la primera de una se las secuencia la
cual es utilizada para barrer o escanear a travs de toda la longitud de la otra secuencia
continuando con la exploracin de la segunda fila, de esta manera la puntuacin de
emparejamiento se obtiene.
85
Problema de las n reinas
No deben estar en la misma fila ni en la misma columna, una representacin mediante una matriz
gasta demasiada memoria y recursos, por lo tanto lo representamos como un vector rellenando en
cada cuadro la posicin vertical que ocupa una de las reinas
0 0 1 0
1 0 0 0
0 0 0 1
0 1 0 0
2 4 1 3
: {2,4,1,3}
Backtracking (!)
0 0 2 0
1 0 0 0
0 0 0 4
0 3 0 0
7 5 3 4 6 8 2 4
86
Branch and Bound (BB)(Ramificacin y poda)
Descripcin general
Branch and Bound (BB) es un mtodo general de bsqueda que se aplica de la siguiente forma:
Nodo Muerto: Aquel nodo del cual no se van a generar ms hijos porque:
No hay ms nodos
No es completable
No generara mejores soluciones que las conocidas hasta el momento
Nodo en curso o en expansin: Es aquel que se elige para ramificarlo
Estrategias de Exploracin
La estrategia de RP es un proceso iterativo que utiliza una estructura en la que se almacena los
nodos vivos
87
La generacin de la estructura auxiliar depende de la estrategia de ramificacin
RP vs Backtracking
En cuanto a nodo en curso:
RP Backtracking
En cuanto a nodo en curso
Se generan todos los hijos del nodo en curso
Segn se genere un hijo este pasa a ser el
antes de decidir cul va a ser el siguiente nodo
nodo en curso
en curso
Con respecto a los nodos vivos
Los nicos nodos vivos son los que estn en el
Puede haber ms nodos vivos
camino de la raz al nodo en curso
Procedimiento general
Seleccin: Se selecciona el nodo que ser ramificado segn la estrategia utilizada
Ramificacin: Se generan los hijos del nodo seleccionado teniendo en cuenta solo las tuplas
prometedoras
Calculo de las cuotas: Para cada nodo se calcula una cota del posible mejor valor alcanzado desde
ese nodo
Poda: Se podan los nodos generados en la etapa anterior que no van a conducir a una mejor
solucin que la que ya se tiene hasta ahora
En RP nos podemos encontrar que todo camino desde la raz acaba en un nodo vivo o en un nodo
cortado (podado), pasando entre medias por nodos ya visitados
Adems los descendientes de un nodo vivo o podado deben ser siempre nodos sin explorar
Observacin: Cada vez que se crea un rbol de bsqueda de forma explcita en la prctica,
simplemente se mantienen los nodos vivos en una estructura, se va eligiendo el ms prometedor y
se ramifica o se poda
Ramificacin
Se escoge entre la lista de nodos vivos aquellos con ms probabilidades de llegar a una solucin.
En caso de problemas de minimizacin que vele a elegir el nodo si tiene el mejor coste estimado
LA estructura de datos que permite elegir el mnimo (o el mximo) con una sola operacin y de
forma eficiente
88
Cola de prioridad: Esta estructura permite implementar montculos, arboles binarios
semicompletos en los que las raz de cada subrbol contiene el menor de todos los elemento
Problema de asignacin
Dadas n tareas y n personas, asignar a cada persona una tarea minimizando el coste de asignacin
total
Para resolver el problema se debe construir una matriz de que determina el coste de asignar a
cada persona una tarea.
1 2 3
A 4 7 3
B 2 6 1
C 3 9 4
3
1 => 3 + 2 + 9 = 14
2
1
2 => 2 + 7 + 4 = 14
3
2
3 => 7 + 1 + 3 = 14 =>
1
Matriz de costes para el problema
1 2 3 4
A 11 12 18 40
B 14 15 13 22
C 11 17 19 23
D 17 14 20 28
89
Obtener la cota superior del coste, la obtenemos a partir de la primera solucin. Por ejemplo:
1
2 => 11 + 15 + 19 + 28 = 73
3
4
rbol de expansin:
En este problema. Para calcular la cota en el nivel k se considera las cotas con menor coste de las
disponibles
90
Transforma y vencers
Transforma y vencers: Presorting
Muchas preguntas sobre una lista
Ejemplo 2
Calcular la moda
5, 2, 5, 7, 6, 5, 7 -> La moda es 5
Por fuerza bruta: explora la lista y calcula las frecuencias de todos los elementos
Heapsort
Otro algoritmo de ordenamiento ( lg())
91
Teora de la complejidad
Introduccin
Se trata de dar respuestas a una serie de preguntas:
Teora de la compatibilidad
Es una teora muy relacionada con el teorema de la complejidad, ya que combina varios de los
conceptos que esta rea utiliza
La complejidad computacional
Estudia el orden de complejidad de un algoritmo que resuelve un problema decidible
Por ello considera los tipos de recursos durante el cmputo para resolver un problema:
As, la complejidad de un algoritmo se expresa como funcin del tamao de la entrada del
problema, lo cual hace referencia al ratio de crecimiento respecto a n.
Antes de utilizar un algoritmo se debe estimar el tiempo que este va a tardar en solucionar el
problema, y evaluar el si este tiempo es razonable. Pero Cunto tiempo es razonable?
Problemas de decisin
Son aquellos que permiten decidir si se puede saber siempre si una afirmacin (desde el punto de
vista matemtico) es verdadera o falsa, o por el contrario existen afirmaciones que no se pueden
determinar.
Ejemplo:
92
1. Una ecuacin tiene soluciones con en un intervalo cerrado [a,b]?
2. Contiene un grafo cualquiera algn ciclo?
3. Contiene algn grafo algn ciclo Hamiltoniano?
Para el tercer problema no sabemos a priori si se pueda encontrar algn algoritmo polinmico
Decidibles
Parcialmente decidible
No decidible
Conjunto de clase
- Clase L
- Clase NL
- P completo
- NP
- NP completo
- NP duro
En este curso solo vamos a considerar los problemas de Clase P, NP, y NP completo
Los problemas de complejidad polinmico son tratables, o dicho de otro modo, en la prctica
estos se pueden resolver en un tiempo razonable
93
Clase NP (Tiempo polinomial no determinstico)
Son todos los problemas que una mquina de Turing no determinstica puede resolver en un
tiempo polinmico. Un ejemplo de este tipo de problema es el ejemplo 3 anteriormente
mencionado.
Es NP
Todos los dems problemas de NP se pueden reducir a este en tiempo polinmico.
Suponiendo que un viajero tiene que visitar 5 ciudades en un viaje de negocios, y se conocen todas
las distancias. Diga cul es el viaje ms corto que se puede realizar volviendo al punto de partida.
ABCDEA? ADECBA?
Nota: Como solucin clara es comprobar todas las posibilidades. Pero esta solucin solo
funcionara bien si el problema es pequeo. Ya que si se aade una nueva ciudad habra que
probar nuevamente todas las combinaciones posibles. Por lo tanto este mtodo nos llevara un
tiempo factorial: t=n!
CLASE P
Multiplicacin matricial
Quicksort
Camino Mnimo
Ciclo Euleriano
Clase NP
NP Complejos
94
Suma de subconjuntos
De parada
Satisfacibilidad
a11 a12
a21 a22
b11 b12
b21 b22
for (i=0;i<=n;i++){
for (j=1;j<=i;j++){
for (k=1;k<=j;k++){
cij=aik*bkj
}
}
}
F
() = 7( 1) + 14
(2.87 ) r2
1 3 1 A D
a[ ]2*3
2 1 0
r1 r4
1 3 1
a [2 1 0]3*3
0 0 0
B C
r1
E
Bibliografa
[1] Aho, Alfred V.; Hopcroft, Jhon E. ; Ullman, Jeffrey D. Data Estructures and
Algorithms. Addison-Wesley. Massachusetts, EUA. 1983.
[2] Coto, Ernesto. Lenguaje Pseudoformal para la Construccin de Algoritmos. ND 2002-
08. Laboratorio de Computacin Grfica. Universidad Central de Venezuela. Caracas,
Venezuela. Octubre, 2002.
[3] Chvtal, V. Linear Programming. W.H. Freeman and Co., New York, NY, 1983.
95
[4] Ford Jr., L. R. ; Fulkerson, D. R. Flows in Networks. Princeton University Press,
Princeton, NJ, 1962.
[5] Sedgewick, Robert. Algorithms in C++, Third Edition, Part 5: Graph Algorithms.
Addison-Wesley. 2002.
Hernndez, E. G. (s.f.). punto com no es un lenguaje. Obtenido de Tutorial Java. Aprende a
programar con Java desde cero.:
http://puntocomnoesunlenguaje.blogspot.com/2014/10/java-mergesort.html
96