Capitulo 22

22
Algoritmos sobre grafos
Contenido
Objetivos del captulo
22.1 Introduccin ..................................................................602
los principales problemas que pueden

ser representados mediante el uso de
grafos y estudiar los algoritmos que los
resuelven: Dijkstra, Prim, Kruskal.
Comparar las implementaciones
greddy y dinmica de algunos de
estos algoritmos.
22.3 El problema de los caminos mnimos ...........................617

22.4 rbol de cubrimiento mnimo (MST) .............................626
22.5 Resumen .......................................................................634
22.6 Contenido de la pgina Web de apoyo ........................634
Competencias especficas
Analizar y resolver problemas de la vida real que pueden ser representados con grafos.
Algoritmos a fondo / pag. 605
606
22. Algoritmos sobre grafos
22.1 Introduccin
Leonhard Euler (1707 - 1783). Fue un

matemtico y fsico suizo.
Es reconocido como uno de los matemticos ms importantes de su
poca, realiz descubrimientos muy
importantes en diversas reas como
el clculo o la Teora de grafos.
Konigsberg, antiguo nombre de la
actual Kaliningrado, es una ciudad
portuaria de Rusia. Est situada en
la desembocadura del ro Pregel, que
desemboca en el Lago del Vstula que,
a su vez, desemboca en el Mar Bltico
por el estrecho de Baltiysk.
En la Web de apoyo, encontrar el vnculo a Google Maps para ver los siete
puentes de Kaliningrado.
La teora de Grafos fue desarrollada en 1736 por el matemtico ruso Leonhard Euler para
resolver el problema de los 7 puentes de la ciudad de Knigsberg.
El problema consista en determinar la existencia de algn camino que, partiendo desde
un punto de la ciudad, permitiera recorrer los 7 puentes pasando solo una vez por cada
uno y regresar al mismo punto de inicio.
Como vemos en la siguiente figura, la ciudad es atravesada por un ro y entre costa y
costa hay dos islas que, en aquella poca, estaban unidas entre s y, tambin, entre las
dos costas mediante 7 puentes.
Fig. 22.1 Los 7 puentes de la ciudad de Knigsberg.
Para solucionar el problema, Euler utiliz una simplificacin del mapa representando a las
regiones terrestres con puntos o crculos y a los puentes con lneas.
Fig. 22.2 Representacin del problema de los 7 puentes mediante un grafo.
En esta abstraccin Euler pudo observar que los puntos por los que el recorrido fuese
a pasar deberan estar conectados por una cantidad par de lneas ya que, si llegamos a
ese punto a travs de un puente entonces, necesariamente, para retirarnos tendremos
que utilizar un puente diferente.
Dado que en este problema todos los puntos estn conectados con una cantidad impar
de lneas, la conclusin a la que lleg fue que no existe un camino con las caractersticas
del que buscamos. Luego, en este caso el problema no tiene solucin.
Sin embargo, la abstraccin desarrollada por Euler dio origen a la idea de grafo que, en
la actualizad, tiene aplicacin en diversos campos, como ser: fsica, qumica, arquitectura, ingeniera e informtica.
Con un grafo podemos representar una red de carreteras que unen diferentes ciudades y
analizar, por ejemplo, cul es el camino ms corto para llegar desde una ciudad hasta otra.
Algortmos a fondo - Ing. Pablo A. Sznajdleder
22.2 Definicin de grafo
607
En este captulo, adems de estudiar conceptos tericos, analizaremos algunos de los

principales problemas que se representan mediante el uso de grafos y desarrollaremos
los algoritmos para resolverlos.

Llamamos grafo a un conjunto de nodos o vrtices que pueden estar o no conectados
por lneas a las que denominaremos aristas.
0
2
3
6
Fig. 22.3 Grafo.
Cada vrtice del grafo se identifica con una etiqueta numrica o alfanumrica que lo diferencia de todos los dems. Por ejemplo, en el grafo de la figura anterior, los vrtices estn
etiquetados con valores numricos consecutivos, comenzando desde cero.
22.2.1 Grafos conexos y no conexos

Si, partiendo desde un vrtice y desplazndonos a travs de las aristas podemos llegar
a cualquier otro vrtice del grafo decimos que el grafo es conexo. En cambio, si existe
al menos un vrtice al que no se puede llegar ser porque est desconectado. En este
caso, diremos que el grafo es no conexo.
22.2.2 Grafos dirigidos y no dirigidos

Cuando las aristas estn representadas con flechas, que indican una determinada direccin, decimos que se trata de un grafo dirigido o dgrafo. En cambio, si las aristas no
especifican un sentido en particular tendremos un grafo no dirigido.
1
0
2
3
6
Fig. 22.4 Grafo no dirigido.
6
Fig. 22.5 Grafo dirigido.
608
22.2.3 El camino entre dos vrtices

Sean a y b dos vrtices de un grafo, diremos que el camino entre a y b es el trayecto o
conjunto de aristas que debemos recorrer para llegar desde a hasta b. Si el grafo tiene
ciclos entonces es probable que exista ms de un camino posible para unirlos.
En un grafo dirigido debemos respetar la direccin de las aristas. As, en el dgrafo de la
figura anterior, el camino que une los vrtices 5 y 0 es nico. Partiendo desde 5 llegamos
hasta 0 pasando por los siguientes vrtices: c = {5, 4, 1, 0}. Este camino tambin podemos expresarlo como el conjunto de aristas por el que nos tendremos que desplazar:
c = {(5,4), (4,1), (1,0)}
En el caso del grafo no dirigido que vemos en la parte izquierda de la figura, podemos
encontrar varios caminos que nos permiten unir los vrtices 5 y 0. Como las aristas no
especifican ninguna direccin, entonces, podemos transitarlas en cualquier sentido. Algunos de estos caminos son:
c1 = {5, 2, 1, 0}
c2 = {5, 2, 3, 0}
c3 = {5, 3, 0}
22.2.4 Ciclos
Llamamos ciclo a un camino que, sin pasar dos veces por la misma arista, comienza y
finaliza en el mismo vrtice. Por ejemplo, en el dgrafo de la figura anterior algunos de los
ciclos que podemos identificar son:
c1 = {0, 3, 6, 5, 4, 1, 0}
c2 = {0, 3, 5, 4, 1, 0}
c3 = {3, 6, 5, 2, 3}
c4 = {5, 4, 1, 2, 3, 5}
Y en el grafo no dirigido ubicado a la izquierda podemos destacar los siguientes ciclos:
c1 = {0, 1, 4, 2, 3, 0}
c2 = {2, 1, 0, 3, 2}
c3 = {6, 5, 4, 2, 1, 0, 3, 6}
22.2.5 rboles
Un rbol es un grafo conexo y sin ciclos.
En la siguiente figura, a la izquierda, vemos el grafo con el que hemos estado trabajando
desde el principio del captulo. Luego, a la derecha, observamos cmo quedara el grafo
si suprimimos, arbitrriamente, algunas de sus aristas para eliminar la existencia de ciclos. Por ejemplo, suprimimos las aristas: (0, 3), (1, 4), (4, 5), (2, 3), (3, 6).
0
2
3
6
Fig. 22.6 Grafo conexo con ciclos.
Fig. 22.7 Grafo conexo sin ciclos.
609
Luego, simplemente reacomodamos los vrtices para poder visualizar el grafo con el
formato natural de los rboles.
2
1
5
4
0
6
Fig. 22.8 rbol: grafo conexo sin ciclos.
22.2.6 Grafos ponderados

Sobre las aristas de un grafo, dirigido o no, se puede indicar un determinado valor para
representar, por ejemplo, un costo, una ponderacin o una distancia. En este caso, decimos que el grafo est ponderado.
4
4
6
6
4
6
4
5
2
4
6
Fig. 22.9 Grafo ponderado no dirigido.
Por ejemplo, si los nodos del grafo representan ciudades entonces los valores de las
aristas podran representar las distancias que existen entre estas. O tambin podran
representar el costo que implicara trasladarnos desde una ciudad hacia otra.
22.2.7 Vrtices adyacentes y matriz de adyacencias

Cuando dos vrtices estn unidos por una arista decimos que son vrtices adyacentes.
Luego, utilizando una matriz, podemos representar las adyacencias entre los vrtices de
un grafo dirigido, no dirigido, ponderado o no ponderado.
La matriz de adyacencias es una matriz cuadrada, con tantas filas y columnas como vrtices tenga el grafo que representa. Cada celda que se origina en la interseccin de una
fila i con una columna j representa la relacin de adyacencia existente entre los vrtices
homlogos.
Para representar un grafo no dirigido ni ponderado, utilizaremos una matriz booleana. Las
celdas de esta matriz tendrn el valor 1 (o true) para indicar que los vrtices representados por la interseccin fila/columna son adyacentes o 0 (o false) para indicar que ese par
de vrtices no lo son. Veamos:
610
4
0
1
2
3
4
5
6
0
2
0
0
1
0
1
0
0
0
1
1
0
1
0
1
0
0
2
0
1
0
1
1
1
0
3
1
0
1
0
0
1
1
4
0
1
1
0
0
1
0
5
0
0
1
1
1
0
1
6
0
0
0
1
0
1
0
6
Fig. 22.10 Matriz de adyacencias de un grafo no dirigido ni ponderado.
La matriz de adyacencias de un grafo no dirigido es simtrica ya que, para todo par de

vrtices a y b, si se verifica que a es adyacente con b entonces b ser adyacente con a.
Veamos ahora la matriz de adyacencias de un grafo no dirigido y ponderado.
4
4
6
6
4
6
4
5
2
4
6
0
1
2
3
4
5
6
0
0
6
0
6
0
0
0
1
6
0
2
0
4
0
0
2
0
2
0
4
6
4
0
3
6
0
4
0
0
2
6
4
0
4
6
0
0
6
0
5
0
0
4
2
6
0
4
6
0
0
0
6
0
4
0
Fig. 22.11 Matriz de adyacencias de un grafo no dirigido y ponderado
En Java, los wrappers de todos los tipos

de datos numricos primitivos proveen
una constante que representa el mayor
valor que las variables de ese tipo pueden contener. Por ejemplo:
Integer.MAX_VALUE,
Long.MAX_VALUE,
Float.MAX_VALUE,
Double.MAX_VALUE, etc.
En este caso, la relacin de adyacencia entre dos vrtices a y b se reflejada cuando en la

celda que surge como interseccin de la fila a y la columna b existe un valor mayor que
cero, que coincide con el valor de la arista que los une.
La no adyacencia de a con b puede representarse con el valor 0 en la celda interseccin
de la fila a con la columna b o con el valor infinito que, en Java, podemos implementar con: Integer.MAX_VALUE, siempre y cuando el tipo de datos de la matriz sea:
int[][].
En Java, los wrappers de todos los tipos de datos numricos primitivos proveen una
constante que representa el mayor valor que las variables de ese tipo pueden contener. Por ejemplo: Integer.MAX_VALUE, Long.MAX_VALUE, Float.MAX_VALUE,
Double.MAX_VALUE, etc.
En un grafo no dirigido, cada arista puede transitarse en cualquier direccin. Por esto,
su matriz de adyacencias ser simtrica ya que, si una arista conecta al vrtice a con el
vrtice b entonces la misma arista conectar al vrtice b con el vrtice a,
Por ltimo, en la matriz de adyacencias de un grafo dirigido las filas representan el vrtice origen y las columnas representan al vrtice destino. Luego, si el grafo es ponderado, en la interseccin de cada fila/columna se coloca el valor de la arista que conecta
al par de vrtices homlogos. Si no lo es, simplemente la celda interseccin se completa
con 1 o 0 o true o false.
6
4
4
6
611
4
2
0
1
2
3
4
5
6
3
6
2
4
4
6
4
6
4
Fig. 22.12 Matriz de adyacencias de un grafo dirigido y ponderado.
22.2.8 La clase Grafo

Para facilitar la comprensin de los algoritmos que estudiaremos ms adelante, vamos a desarrollar la clase Grafo que nos permitir representar grafos no dirigidos y
ponderados.
Tambin, con el objetivo de no desviar la atencin y podernos concentrar en la lgica
de estos algoritmos, que no son para nada simples, aceptaremos que los vrtices de los
grafos que la clase podr representar debern ser numricos, consecutivos y comenzar
desde 0.
La clase tendr una variable de instancia de tipo int[][] para guardar la matriz de
adyacencias del grafo, que deber ser provista como argumento en el constructor. La no
adyacencia entre dos vrtices ser representada con infinito.
package libro.cap22;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
public class Grafo
{
// matriz de adyacencias
private int matriz[][];

// constructor, recibe la matriz de adyacencias
public Grafo(int mat[][])

{
this.matriz = mat;
}
// sigue mas abajo
// :
Agregaremos los mtodos triviales getDistancia y size. El primero retornar la

distancia que existe entre dos vrtices del grafo. El segundo retornar la dimensin de la
matriz de adyacencias que, como ya sabemos, es cuadrada.
612
// :
// viene de mas arriba
// retorna la longitud de la matriz de adyacencias
public int size()
{
return matriz.length;
}
// retorna el valor de matriz[a][b]
public int getDistancia(int a, int b)
{
return matriz[a][b];
}
// sigue mas abajo
// :
Ahora agregaremos dos constructores alternativos. El primero solo recibir un valor entero indicando la dimensin de la matriz de adyacencias. Luego instanciar e inicializar la
variable de instancia matriz asignando valores infinito en cada una de sus celdas. El
segundo constructor alternativo permitir construir un grafo con n nodos y especificar las
adyacencias mediante un conjunto de aristas, cada una de las cuales estar determinada
por dos vrtices y una distancia. Las aristas las representaremos con instancias de la clase
Arista cuyo cdigo veremos a continuacin.
package libro.cap22;
public class Arista
{
private int n1;
private int n2;
private int distancia;
// constructor
public Arista(int n1,int n2, int dist)
{
this.n1 = n1;
this.n2 = n2;
this.distancia = dist;
}
// determinar si "yo", que soy una arista, soy igual a otra
public boolean equals(Object a)
{
Arista otra = (Arista)a;
return (n1==otra.n2 && n2==otra.n1)

|| (n1==otra.n1 && n2==otra.n2);
public String toString()

{
return "Desde: "+n1+", Hasta: "+n2+" Distancia: "+distancia;
}
// :
// settters y getters
// :
613
Adems del constructor y el mtodo toString, en la clase Arista sobrescribimos el

mtodo equals para determinar si los valores de las variables de instancia coinciden
con los de la arista que recibimos como parmetro. El criterio que utilizamos para comparar dos aristas es simple: son iguales si coinciden sus extremos directos u opuestos.
Agreguemos a la clase Grafo el cdigo de los constructores alternativos.
// :
// recibe la dimension de la matriz, la instancia
// y le asigna "infinito" a cada celda
public Grafo(int n)
{
// matriz cuadrada de n filas y n columnas
matriz = new int[n][n];

// inicializo la matriz
for(int i=0;i<n; i++)

{
for(int j=0; j<n; j++)
{
matriz[i][j] = Integer.MAX_VALUE;
}
}
// recibe la dimension de la matriz, y un conjunto de aristas

// los nodos no afectados por las aristas no seran adyacentes
public Grafo(int n, Arista[] arr)

{
// invoco al otro constructor para inicializar la matriz
this(n);
for(Arista a:arr)
{
addArista(a);
}
// agregar una arista implica asignar la distancia

// en las celdas correspondientes
public void addArista(Arista a)

{
matriz[a.getN1()][a.getN2()]=a.getDistancia();
matriz[a.getN2()][a.getN1()]=a.getDistancia();
}
// sigue mas abajo
// :
Por ltimo, incluiremos un mtodo llamado getVecinos que retornar los vrtices adyacentes de un determinado nodo que recibir como parmetro.
614
// :
// retorna los nodos adyacentes
public ArrayList<Integer> getVecinos(int n)

{
ArrayList<Integer> a = new ArrayList<Integer>();
for( int i=0; i<matriz.length; i++ )
{
if( matriz[n][i]!=Integer.MAX_VALUE )
{
a.add(i);
}
}
return a;
22.2.10 Determinar la existencia de un ciclo

Como introduccin a los algoritmos que estudiaremos ms adelante, analizaremos un
pequeo programa para determinar si la accin de agregar una nueva arista a un grafo
har que este pase a tener ciclos.
Enunciado
Dado un grafo G de n vrtices y un conjunto de aristas, se pide determinar si, al agregar
una arista adicional esta posibilitar o no la existencia de un ciclo. La cantidad de nodos,
las aristas iniciales y la arista que debemos analizar se ingresarn por consola.
Anlisis
Observemos el grafo de la siguiente figura:
Como podemos ver, el grafo es no conexo ya que los vrtices 0, 1, y 2 estn

desconectados de los vrtices 3, 4, 5 y 6.
Lo representaremos con la clase Grafo.
// 7 nodos etiquetados entre 0 y 6
0
2
3
6
Grafo g = new Grafo(7);

g.addArista(new Arista(0,1));
Fcilmente, podemos observar que si agregamos una arista conectando los vrtices 3
y 6 se formar un ciclo. Lo mismo sucedera si agregsemos una arista que conecte los
vrtices 0 con 2, 3 con 4 o 4 con 6. Cualquier otra arista que agreguemos unir los dos
pequeos rboles, pero no formar ningn ciclo.
Agreguemos, por ejemplo, una conexin entre los vrtices 4 y 1:
615
Ahora, cualquier arista que vayamos a agregar indefectiblemente formar un ciclo. La

1
lnea punteada muestra cmo quedara el
4
grafo si adems agregsemos la arista (2,5).
0
El algoritmo para determinar si esta arista
formar un ciclo debe emprender un re2
corrido a travs de los nodos del grafo y,
5
comenzando desde alguno de los extremos
de la arista, debe controlar que en el cami3
no no pasemos por el otro extremo.
Por ejemplo, si partiendo desde 2 podemos
6
llegar a 5 ser porque estos nodos ya estaban conectados entonces la arista formar
una nueva conexin: un ciclo. Como el grafo no est dirigido, podemos iniciar el recorrido
por cualquiera de los extremos de la arista. Por esto, arbitrriamente comenzaremos el
anlisis partiendo desde el nodo 2.
La estrategia consiste en procesar el vrtice 2 (nodo inicial) y verificar si entre sus vecinos
se encuentra 5 (nodo final). Veamos:
Nodo en proceso: 2
vecinos(2) = {1}
Como 5 (el nodo final de la arista) no es vecino de 2, repetiremos la operacin procesando a cada uno de sus vecinos.
Nodo en proceso: 1
vecinos(1) = {0, 2, 4}
Como 5 tampoco est entre los vecinos de 1 repetiremos el proceso con cada uno de sus
vecinos comenzando, arbitrriamente, por el primero: 0.
Nodo en proceso: 0
vecinos(0) = {1}
Evidentemente, la estrategia nos condujo a un loop del cual no podremos salir ya que el
vecino de 0 es 1 y el primero de los vecinos de 1 es 0. La misma situacin se dar entre
los vrtices 2 y 1 ya que 1 es vecino de 2 y 2 es vecino de 1.
La solucin a este problema ser recordar los nodos que ya hemos procesado para no
volverlos a considerar. Siendo as, repetiremos el anlisis evaluando, nuevamente, a los
vecinos de 2, que es el vrtice inicial de la arista en cuestin.
Nodo en proceso: 2
vecinos(2) = {1}
Procesados = {2}
Ya procesamos al nodo 2. Como 5 no est entre sus vecinos, repetiremos la operacin

procesando a cada uno de ellos:
Nodo en proceso: 1
vecinos(1) = {0, 2, 4}
Procesados = {2,1}
Ignoramos a 2 porque recordamos que este nodo ya fue procesado. Como 5 no est
entre los vecinos de 1, nuevamente repetimos la operacin con cada uno de ellos.
Nodo en proceso: 0
vecinos(0) = {1}
Procesados = {0,2,1}
El nico vecino de 0 es 1 pero como ya lo hemos procesado lo descartamos y continuamos con el nodo 4 que, como vecino de 1, estaba pendiente de ser procesado.
Nodo en proceso: 4
vecinos(4) = {1,5}
Procesados = {0,2,1,4}
Como 1 ya fue procesado lo descartamos. Luego, el nico vecino de 4 es 5.
616
Podemos ver que partiendo desde 2, vrtice inicial de la arista que estamos analizando,
pudimos llegar hasta 5, el vrtice final. Esto nos permite determinar que, de agregarla al
grafo, estaremos formando un ciclo.
Para implementar el algoritmo utilizaremos un arraylist y una cola. El arraylist nos permitir recordar los nodos que ya hemos procesado. La cola nos permitir encolar los
vecinos de cada uno de los nodos a medida que los vayamos procesando.
Veamos el programa principal:
package libro.cap22.ciclos;
import libro.cap22.Arista;
import libro.cap22.Grafo;
import java.util.Scanner;
public class VerificaCiclos
{
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);
// ingresa x consola los valores del grafo
Grafo g = ingresaGrafo(scanner);
// ingresa x consola los valores de la arista
Arista a = ingresaAristaAVerificar(scanner);
if( hayCiclo(g,a) )
{
System.out.println("La arista forma un ciclo");
}
else
{
System.out.println("La arista no forma ciclo");
}
// sigue mas abajo

// :
Veamos ahora el mtodo hayCiclo donde verificaremos si la arista a forma un ciclo

entre los vrtices del grafo g.
// :
private static boolean hayCiclo(Grafo g, Arista a)

{
// arraylist para recordar los nodos procesados
ArrayList<Integer> procesados = new ArrayList<Integer>();

// cola de nodos pendientes de proceso
Queue<Integer> q = new LinkedList<Integer>();
617
// extremos de la arista
int nInicio = a.getN1();

int nFin = a.getN2();
// encolamos el extremo inicial
q.add(nInicio);
while( !q.isEmpty() )
{
// desencolo y proceso un nodo
int n = q.poll();
// llegamos al extremo final?
if( n==nFin )
{
return true; // HAY CICLO
}
// agrego el nodo a la lista de nodos procesados...
procesados.add(n);
// pido sus vecinos...
ArrayList<Integer> vecinos = g.getVecinos(n);

// encolo a sus vecinos, salvo los que ya fueron procesados
for(int v:vecinos)
{
if( !procesados.contains(v) )
{
q.add(v);
}
}
// si llegamos hasta aqui sera porque la arista no forma ciclo
return false;
// sigue mas abajo

// :
Por ltimo, solo para completar el programa, veamos los mtodos que permiten el ingreso de datos por consola.
// :
private static Grafo ingresaGrafo(Scanner scanner)

{
System.out.println("--Ingreso del grafo --");
System.out.print("Cantidad de vertices: ");
int n = scanner.nextInt();
Grafo g = new Grafo(n);
618
System.out.print("Cantidad de aristas: ");

int a = scanner.nextInt();
System.out.println("- Ingrese "+a+" aristas -");
for( int i=0; i<a; i++ )
{
g.addArista( ingresaArista(scanner) );
}
}
return g;
private static Arista ingresaAristaAVerificar(Scanner scanner)

{
System.out.println("-- Ingrese la arista a verificar --");
return ingresaArista(scanner);
}
private static Arista ingresaArista(Scanner scanner)
{
System.out.print("Extremo inicial: ");
int n1 = scanner.nextInt();
System.out.print("Extremo final: ");
int n2 = scanner.nextInt();
System.out.print("Distancia: ");
int d = scanner.nextInt();
Arista a = new Arista(n1, n2, d);
System.out.println("Arista ingresada: "+a);
return a;
22.2.11 Los nodos vecinos

Como vimos en el ejemplo anterior, el concepto de nodo vecino es un poco ms amplio
que el concepto de nodo adyacente ya que, generalmente, no estaremos interesados
en procesar un mismo nodo ms de una vez. Por esto, extenderemos el concepto de
vecinos de un vrtice de la siguiente manera:
Sea s un vrtice de un grafo, entonces llamaremos vecinos(s) a todos sus nodos adyacentes que an no hayan sido procesados.
Para aplicar este concepto al mtodo getVecinos de la clase Grafo tendremos que
agregar una variable de instancia de tipo ArrayList que nos permita recordar cuales
nodos han sido procesados. Tambin agregaremos los mtodos setProcesado para que
el usuario pueda marcar como procesado a un vrtice determinado, isProcesado que,
dado un vrtice, indicar si el mismo previamente fue o no marcado como procesado y
resetProcesados que permitir olvidar todos los nodos marcados.
619
// :
public class Grafo

{
private int matriz[][];
private ArrayList<Integer> procesados = new ArrayList<Integer>();
// :
public void setProcesado(int n)

{
procesados.add(n);
}
public boolean isProcesado(int n)
{
return procesados.contains(n);
}
public void resetProcesados()
{
procesados.clear();
}
}
// :
Ahora s, modifiquemos el mtodo getVecinos para retornar solo aquellos nodos adyacentes que previamente no hayan sido marcados como procesados.
// :
// retorna los adyacentes que no han sido procesados
public ArrayList<Integer> getVecinos(int n)

{
ArrayList<Integer> a = new ArrayList<Integer>();
{
if(matriz[n][i]!= Integer.MAX_VALUE)
{
// lo agrego solo si no fue procesado
}
}
if(!procesados.contains(i))
{
a.add(i);
}
return a;
// :
Ahora agregaremos el mtodo hayCiclo en la clase Grafo. Notemos que antes de

tocar el arraylist procesados resguardamos su estado inicial y lo restauramos antes
620
de finalizar el algoritmo.
// :
public boolean hayCiclo(int nInicio, int nFin)

{
// resguardo el estado actual de los nodos procesados
ArrayList<Integer> bkpProcesados = (ArrayList<Integer>) procesados.clone();

resetProcesados();
// encolo b y veo si llego hasta a

q.add(nInicio);
while( !q.isEmpty() )
{
int n = q.poll();
if( n==nFin )
{
return true;
}
setProcesado(n);
// obtengo los vecinos
ArrayList<Integer> vecinos = getVecinos(n);
for(int x: vecinos)
{
q.add(x);
}
// restauro el estado de nodos procesados que el grafo tenia al inicio
procesados = bkpProcesados;
}
return false;
// :
Al resguardar el conjunto de nodos procesados nos aseguramos de no alterar el estado

que el grafo tena antes de ejecutar el mtodo hayCiclo.
Observemos bien la siguiente lnea:
ArrayList<Integer> bkpProcesados = (ArrayList<Integer>) procesados.clone();

Si hubiramos asignado directamente procesados a bkpProcesados, este objeto
sera una referencia al primero. Luego, no podramos restaurar el arraylist original ya que
durante todo el proceso solo existira un nico arraylist y una referencia a este.
El mtodo clone crea una nueva instancia con los mismos valores que el objeto original. Luego de aplicarlo existirn dos arraylists, cada uno de estos referenciado por los
objetos procesados y bkpProcesados respectivamente.
22.3 El problema de los caminos mnimos
621

Dado un grafo ponderado y uno de sus vrtices, al que llamaremos vrtice de origen,
se requiere hallar las menores distancias existentes entre este vrtice y todos los dems.
Es decir, sea s el vrtice de origen e i cualquier otro nodo del grafo entonces la menor
distancia entre s e i ser la menor de las sumatoria de los valores de las aristas que
componen cada uno de los caminos que conectan a s con i.
Repasemos nuestro grafo ponderado.
4
6
6
4
6
4
5
2
4
6
Considerando como vrtice de origen al

nodo 0 entonces, para llegar desde 0
hasta 5 podemos tomar varios caminos:
c1 = {0, 1, 4, 5}, distancia = 16
c2 = {0, 1, 2, 5}, distancia = 12
c3 = {0, 1, 4, 2, 5}, distancia = 20
c4 = {0, 1, 2, 4, 5}, distancia = 20
c5 = {0, 3, 2, 1, 4, 5}, distancia = 20
c6 = {0, 3, 2, 4, 5}, distancia = 22
c7 = {0, 3, 2, 5}, distancia = 14
c8 = {0, 3, 5}, distancia = 8
c9 = {0, 3, 6, 5}, distancia = 16
Como vemos, de todos los caminos que conectan al nodo 0 con el nodo 5, el menos
costoso o el ms corto es: c8 = {0, 3, 5}.
22.3.1 Algoritmo de Dijkstra

El algoritmo de Dijkstra ofrece una solucin al problema de hallar los caminos mnimos
proveyendo las menores distancias existentes entre un vrtice y todos los dems.
Como analizaremos dos implementaciones diferentes desarrollaremos una interface que
nos permita desacoplar el programa y la implementacin.
La interface Dijkstra definir un nico mtodo tal como lo vemos a continuacin.
Edsger Wybe Dijkstra (1930 - 2002).

Estudi fsica terica en la Universidad
de Leiden.
La solucin del problema del camino
ms corto fue una de sus contribuciones a la informtica, tambin conocido como el algoritmo de Dijkstra.
En la Web de apoyo, encontrar el
vnculo a la pgina Web personal de
Edsger Dijkstra.
package libro.cap22.dijkstra;
import java.util.Hashtable;
public interface Dijkstra
{
public Hashtable<Integer, Integer> procesar(Grafo g, int s);
}
El mtodo procesar recibe como parmetros el grafo, el vrtice de origen s y retorna

un conjunto solucin montado sobre una hashtable tal que sus keys sean los vrtices del
grafo y los values sean las distancias mnimas que existen entre s y cada uno de estos vrtices.
22.3.2 Dijkstra, enfoque greddy

Antes de comenzar analizaremos algunos casos concretos sobre nuestro grafo modelo
para lo cual vamos a considerar como vrtice de origen al nodo 4.
622
Siendo as, queremos obtener las menores distancias existentes entre el nodo 4
y cada uno de los otros nodos del grafo.
4
6
5
2
Algoritmo de Dijkstra por greddy
4
6
Fig. 22.13 Grafo ponderado.
Comenzaremos analizando sus vecinos, que son: {1, 2, 5}. Las distancias
que existen entre 4 y cada uno de estos nodos son, respectivamente: 4, 6 y
6. Por el momento consideraremos que
estas distancias son mnimas y, mientras no puedan ser mejoradas, formarn
parte del conjunto solucin. Luego procesaremos cada uno de los vecinos de
4 comenzando, arbitrriamente, por 5.
Los vecinos de 5, obviando a 4 que ya fue procesado, son: {2, 3, 6} y sus distancias son,
respectivamente, 4, 2 y 4. Sin embargo, para llegar a 5 desde 4 pagamos un costo inicial de 6. Por esto, momentneamente, las mnimas distancias que existen entre 4 y cada
uno de los vecinos de 5 son 6+4, 6+2 y 6+4.
Sean a y b dos nodos adyacentes de un grafo, llamaremos d(a,b) a la distancia directa
entre a y b, que coincide con el valor expresado en la arista que los une.
Veamos: pasando por 5, la distancia entre 4 y 3 es 8 ya que d(4,5)=6+d(5,3)=2. En algn
momento procesaremos el vrtice 2, vecino de 4, desde donde tambin podemos llegar
a 3. Sin embargo, para llegar a 3 desde el nodo de origen 4, pasando por 2, la distancia
total es 10 y se obtiene sumando: d(4,2)=6+d(2,3)=4. Este valor es peor que el costo de
llegar a 3 a travs de 5, razn por la cual lo descartaremos.
El algoritmo de Dijkstra consiste en procesar cada uno de los vecinos de s, el vrtice de
origen, luego los vecinos de los vecinos de s y as sucesivamente hasta llegar a procesar
todos los nodos del grafo.
Como los nodos deben procesarse solo una vez, utilizaremos la funcionalidad provista
por la clase Grafo, desarrollada ms arriba, cuyo mtodo getVecinos retorna todos
los nodos adyacentes a un vrtice obviando aquellos que previamente hayan sido marcados como procesados mediante el mtodo setProcesado.
Veamos cmo crear una instancia de Grafo en funcin de su matriz de adyacencias.
Recordemos que la matriz debe contener la distancia que existe entre dos nodos adyacentes o el valor Integer.MAX_VALUE para aquellos nodos que no lo son.

{
int i = Integer.MAX_VALUE;
int[][] mAdy= { {i, 6, i, 6, i, i, i}
,{6, i, 2, i, 4, i, i}
,{i, 2, i, 4, 6, 4, i}
,{6, i, 4, i, i, 2, 6}
,{i, 4, 6, i, i, 6, i}
,{i, i, 4, 2, 6, i, 4}
,{i, i, i, 6, i, 4, i} };
// instancio el grafo a partir de su matriz de adyacencias
Grafo g = new Grafo(mAdy);

// :
Esta implementacin del algoritmo de Dijkstra utilizar dos hashtables: una para componer el conjunto solucin (distMin) y otra para mantener las distancias acumuladas
(distAcum). Las keys de estas tablas sern las etiquetas de todos los nodos del grafo y
los valores iniciales deben ser infinito para el conjunto solucin ya que, en definitiva, se
trata de hallar las distancias mnimas y 0 para las distancias acumuladas que no son otra
cosa que acumuladores.
Trabajaremos con una cola donde, inicialmente, encolaremos al vrtice de origen. Luego
iteraremos mientras que la cola no est vaca y en cada una de estas iteraciones desencolaremos un nodo, lo procesaremos y encolaremos a todos sus vecinos.
623
Nota: recordemos que para simplificar la lgica del algoritmo hemos aceptado la restriccin de que los vrtices
del grafo solo podrn estar etiquetados
con valores numricos, consecutivos y
comenzando desde cero.
package libro.cap22.dijkstra.imple;
import
import
import
import
java.util.ArrayList;
java.util.Hashtable;
java.util.LinkedList;
java.util.Queue;
import libro.cap22.dijkstra.Dijkstra;
public class DijkstraImpleGreddy implements Dijkstra
{
public Hashtable<Integer, Integer> procesar(Grafo g, int s)
{
// asigno "infinito" a cada posicion de distMin
Hashtable<Integer, Integer> distMin = new Hashtable<Integer, Integer>();

inicializar(distMin, g.size(), Integer.MAX_VALUE);
// asigno 0 a cada posicion de distAcum
Hashtable<Integer, Integer> distAcum = new Hashtable<Integer, Integer>();

inicializar(distAcum, g.size(), 0);
q.add(s);
// continua mas abajo
// :
Luego, dentro del while tomamos un elemento de la cola y lo procesamos. El proceso

consiste en marcarlo como procesado y analizar la distancia que existe entre este y
cada uno de sus vecinos.
624
// :
while(!q.isEmpty())
{
// tomo el primero
int n = q.poll();
// lo marco como visitado
g.setProcesado(n);
int acum = distAcum.get(n);

// :
Al inicio, la distancia acumulada de cada nodo ser cero. Si sumamos la distancia acumulada del nodo n, que acabamos de desencolar, con la distancia existente entre este
y cada uno de sus vecinos podremos determinar si esta suma es menor a la distancia
que, hasta ahora, considerbamos mnima. Si as fuese entonces actualizaremos distMin.
Luego ingresamos a un for para comparar la distancia que existe entre n y cada uno
de sus vecinos.
// :
// obtengo los vecinos de n
// pido sus vecinos
ArrayList<Integer> vecinos = g.getVecinos(n);

for(int i = 0; i<vecinos.size(); i++)
{
// tomo el i-esimo vecino y su distancia
int t = vecinos.get(i);
int dist = g.getDistancia(n, t) + acum;
int min = distMin.get(t);
if( dist<min )
{
distMin.put(t, dist);
distAcum.put(t, dist);
}
}
}
if(!q.contains(t))
{
q.add(t);
}
return distMin;

// :
625
Dentro del for tomamos el i-simo vecino de n y calculamos la distancia que existe
entre estos nodos sumando la distancia directa ms la distancia que acumula n. Luego
comparamos esta suma con el valor que, por el momento, consideramos como la distancia mnima. Si la nueva distancia mejora a la anterior entonces la guardamos.
Solo queda pendiente el cdigo del mtodo inicializar que utilizamos para asignar
valores iniciales a las hashtables.
// :
private void inicializar(Hashtable<Integer, Integer> tdist, int size, int val)

{
for(int i=0; i<size;i++)
{
tdist.put(i,val);
}
}
Veamos ahora un programa que reciba por lnea de comandos al vrtice de origen y
muestre por pantalla las menores distancias que existen entre este vrtice y todos los dems.
package libro.cap22.dijkstra;
public class TestDijkstra
{
{
int[][] mAdy= { {i,
,{6,
,{i,
,{6,
,{i,
,{i,
,{i,
6,
i,
2,
i,
4,
i,
i,
i,
2,
i,
4,
6,
4,
i,
6,
i,
4,
i,
i,
2,
6,
i,
4,
6,
i,
i,
6,
i,
i,
i,
4,
2,
6,
i,
4,
i}
i}
i}
6}
i}
4}
i} };

// defino el nodo de origen
int origen = Integer.parseInt(Integer.parseInt(args[0]);

Dijkstra d = new DijkstraImpleGreddy();
Hashtable<Integer, Integer> minimos = d.procesar(g, origen);
// muestro los resultados
System.out.println(minimos);
626
Esta implementacin del algoritmo coincide con un enfoque voraz o greddy. Veamos:
El conjunto de candidatos: los vrtices del grafo, excepto el nodo origen.

El mtodo de seleccin: ser quin determine el menor costo desde el origen.
La funcin de factibilidad determinar si, luego de seleccionar un nodo, conviene utilizarlo como puente para mejorar el costo entre el origen y cada uno de sus vecinos.
La complejidad del algoritmo es cuadrtica y est determinada por los dos ciclos anidados: un for dentro del while.
22.3.3 Dijkstra, implementacin por programacin dinmica

La programacin dinmica ofrece una tcnica simple y eficiente para los problemas que,
adems de cumplir con el principio de ptimalidad, puedan ser planteados de manera
recursiva. Veamos entonces si podemos plantear el algoritmo de Dijkstra como un problema de programacin dinmica.
Existe el principio de ptimalidad ya que, si entre dos vrtices a y c, encontramos al vrtice b entonces los caminos parciales que van de a a b y de b a c sern mnimos.
Algoritmo de Dijkstra por dinmica
Para formular un planteamiento recursivo del problema, pensaremos en un arraylist solu

(solucin) tal que sus elementos coincidirn con las distancias mnimas que existen entre
los nodos del grafo, representados en las posiciones homlogas del array, y el nodo de
origen. Esto es: en la i-sima posicin del arraylist tendremos la mnima distancia existente entre el nodo i y el nodo de origen. Esta tabla ser inicializada con las distancias
directas entre el nodo de origen y cada uno de sus nodos adyacentes o infinito para los
nodos que no son adyacentes al origen.
Para simplificar, en el siguiente anlisis nos referiremos a este arraylist como S, y aceptaremos que S(j) representa la distancia existente entre el nodo de origen y el nodo j.
Tambin, con el objetivo de reducir la notacin diremos que M es la matriz de adyacencias y aceptaremos que M(i,j) representa la distancia directa existente entre los nodos i y
j o infinito si estos nodos no son adyacentes.
Luego, considerando un nodo j tal que j>=0 y j<n, debemos asignar en la j-sima posicin de S el resultado de la siguiente expresin:
min( S(j), S(k)+M(k,j) ), siendo k>=0 y k<n, y n la cantidad de nodos del grafo.
Veamos el algoritmo:
package libro.cap22.dijkstra.imple;
public class DijkstraImpleDinamica implements Dijkstra
{
public Hashtable<Integer, Integer> procesar(Grafo g, int s)
{
// tabla con la solucion del problema
Hashtable<Integer, Integer> solu = new Hashtable<Integer, Integer>();
627
// inicializo la solucion de la siguiente manera:

// * las distancias a los nodos adyacentes o
// * INFINITO para los nodos no adyacentes
for(int i = 0; i<g.size(); i++)

{
int d = g.getDistancia(s, i);
solu.put(i, d);
}
// seteo como "procesado" al nodo de origen
g.setProcesado(s);
// comparo todos contra todos
for( int i = 0; i<g.size()-1; i++ )

{
// retorna la posicion del menor valor contenido en la tabla
int posMin = menor(g, solu);

// lo marco como visitado
g.setProcesado(posMin);
for( int j=0; j<g.size(); j++ )
{
if( !g.isProcesado(j) )
{
// veo si puedo mejorar las distancias
}
}
int x = sumar(solu.get(posMin), g.getDistancia(posMin, j));

solu.put(j, Math.min(solu.get(j), x));
return solu;
// sigue mas abajo

// :
Probablemente, el lector se haya sorprendido al ver que utilic el mtodo sumar para
obtener la suma entre los valores solu.get(posMin) y g.getDist(posMin, j).
Pues bien, analicemos la siguiente lnea:
int x = sumar(solu.get(posMin), g.getDist(posMin, j));

Como g.getDist(posMin, j) podra llegar a ser Integer.MAX_VALUE entonces
este es el mayor valor que una variable de tipo int puede contener. Si a esto le sumamos cualquier otro valor estaremos desbordando la capacidad de la variable x y el
resultado ser impredecible.
El mtodo sumar, cuyo cdigo veremos a continuacin, suma ambos valores manteniendo el concepto de infinito. Es decir: infinito es un valor tan grande que al sumarle
cualquier otro valor continuar siendo infinito. Decimos que es absorbente para la suma.
628
// :
private int sumar(int a, int b)

{
if( a==Integer.MAX_VALUE || b==Integer.MAX_VALUE )
{
return Integer.MAX_VALUE;
}
else
{
return a+b;
}
}
// sigue mas abajo
// :
Por ltimo, veremos el mtodo menor que retorna la posicin dentro del arraylist que,
temporalmente, representa la menor distancia entre el nodo de origen y el nodo homlogo a dicha posicin. Recordemos que, en el arraylist, las posiciones representan vrtices
y los contenidos representan distancias.
// :
private int menor(Grafo g, Hashtable<Integer,Integer> solu)

{
int min = Integer.MAX_VALUE;
int pos = 0;
for(int i = 0; i<g.size(); i++)
{
if(!g.isVisitado(i) && solu.get(i)<min)
{
min = solu.get(i);
pos = i;
}
}
return pos;
La complejidad del algoritmo implementado por programacin dinmica sigue siendo

cuadrtica ya que se mantienen los dos ciclos anidados. Sin embargo, el cdigo es ms
corto y legible respecto de la implementacin anterior.
Veamos un programa donde el usuario selecciona cul implementacin del algoritmo de
Dijkstra desea utilizar para hallar las distancias mnimas entre un vrtice y todos los dems.
629
package libro.cap22.dijkstra.test;
public class Test
{
public static void main(String[] args) throws Exception
{
int[][] mAdy= { {i, 6, i, 6,
,{6, i, 2, i,
,{i, 2, i, 4,
,{6, i, 4, i,
,{i, 4, 6, i,
,{i, i, 4, 2,
,{i, i, i, 6,
i,
4,
6,
i,
i,
6,
i,
i,
i,
4,
2,
6,
i,
4,
i}
i}
i}
6}
i}
4}
i} };
System.out.print("Ingrese el vertice de origen: ");

int origen = scanner.nextInt();
System.out.println("Ingrese implementacion de Dijkstra: ");
String sClassImple = scanner.next();
// instancio dinamicamente la implementacion ingresada por el usuario
Dijkstra d = (Dijkstra)Class.forName(sClassImple).newInstance();
// invoco el metodo procesar
Hashtable<Integer, Integer> minimos = d.procesar(g, origen);

// muestro los resultados
System.out.println(minimos);
Si queremos que el programa ejecute la implementacin dinmica para calcular las distancias mnimas hacia el vrtice de origen 6 ingresaremos lo siguiente:
Ingrese el vertice de origen: 6
Ingrese implementacion de Dijkstra:
libro.cap22.dijkstra.imple.DijkstraImpleDinamica
{6=2147483647, 5=4, 4=10, 3=6, 2=8, 1=10, 0=12}
Y si queremos utilizar la implementacin greddy, debemos ejecutarlo e ingresar:
Ingrese el vertice de origen: 6
Ingrese implementacion de Dijkstra:
libro.cap22.dijkstra.imple.DijkstraImpleGreddy
{6=2147483647, 5=4, 4=10, 3=6, 2=8, 1=10, 0=12}
630

En este ejemplo utilizamos la clase Class para instanciar, dinmicamente, la implementacin de Dijkstra ingresada por el usuario. Observemos la siguiente lnea:
// instancio dinamicamente la implementacion ingresada por el usuario
Dijkstra d = (Dijkstra)Class.forName(sClassImple).newInstance();
El mtodo Class.forName instancia dinmicamente un objeto de la clase indicada en
la cadena sClassImple, ingresada por el usuario. Este es el punto de entrada al mundo
de la programacin por introspeccin que, en Java, se encuentra detrs de la API de
reflection ubicada en el paquete java.lang.reflect.
Si bien, el tema excede el alcance de este libro, el mismo es de suma importancia ya que
permite llevar al extremo los conceptos de abstraccin.
La programacin por introspeccin es la base para el desarrollo de herramientas genricas y frameworks como Hibernate, Spring, Struts, ZK, etc.
22.4 rbol de cubrimiento mnimo (MST)

Dado un grafo G, llamaremos rbol generador mnimo, rbol de cubrimiento mnimo o,
simplemente, MST (Minimum Spanning Tree) de G a un rbol A que tiene los mismos
vrtices que G, pero solo un subconjunto de sus aristas. Dado que A es un rbol, ser
conexo y acclico y solo conservar aquellas aristas de G que permitan conectar directa
o indirectamente a todos sus nodos con el menor costo posible.
Es decir que el costo total requerido para pasar por todos los vrtices del rbol ser mnimo.
4
6
4
6
4
5
2
4
6
Fig. 22.14 Grafo ponderado.
5
2
4
6
Fig. 22.15 rbol de cubrimiento mnimo.
22.4.1 El algoritmo de Prim

Robert C. Prim, naci en 1921 en Estados Unidos, es matemtico e ingeniero en sistemas.
En los laboratorios Bell, trabaj como
director de investigacin matemtica.
All desarroll el conocido Algoritmo
de Prim. Con su compaero, Joseph
Kruskal, desarroll dos algoritmos
diferentes para encontrar los rboles
abarcadores mnimos en un grafo
ponderado.
El algoritmo de Prim soluciona el problema de encontrar el rbol generador mnimo de un

grafo a partir de un nodo inicial que se ubicar como la raz del rbol generador. Luego,
progresivamente, se incorporarn nuevos vrtices hasta que el MST quede completo.
Comenzando por un nodo cualquiera, se evalan las distancias directas entre este y
cada uno de sus vecinos. Se selecciona el vecino que tenga la menor distancia y se lo
incorpora al rbol. Luego, se repite la operacin considerando los vecinos de cada uno
de los vrtices que ya fueron incorporados.
As, en cada iteracin el rbol incorpora un nuevo vrtice. El algoritmo finaliza cuando
todos los vrtices del grafo hayan sido incorporados al rbol.
Nuevamente, tal como lo hicimos con Dijkstra, definiremos una interface para independizar la implementacin del algoritmo. As, luego de estudiar el mtodo de Prim podremos
analizar una solucin alternativa para hallar el rbol generador mnimo de un grafo ponderado: el algoritmo de Kruskal.
631
package libro.cap22.mst;
public interface Mst
{
// retorna el arbol generador minimo del grafo g a partir del vertice n
public Grafo procesar(Grafo g, int n);
La estrategia del algoritmo de Prim consiste en armar el rbol recubridor mnimo del grafo
g, que recibimos como parmetro en el mtodo procesar, escogiendo el orden en el
que vamos a incorporar cada uno de sus vrtices en funcin de los valores de las aristas
que los unen.
Supongamos que el vrtice de inicio ser el nodo 0. Entonces, este nodo ser el primero
en incorporarse al rbol ocupando el lugar de la raz. Luego, analizamos cul de todos
sus vecinos se encuentra ubicado a menor distancia. Como en este caso todos sus vecinos son equidistantes, tomaremos cualquiera de ellos, por ejemplo: 1.
4
4
0
Algoritmo de Prim
4
6
5
4
4
6
5
2
Ahora repetimos la operacin, pero considerando los vecinos de 1 y los vecinos de 0,

siempre y cuando no hayan sido procesados. Es decir: el conjunto de vrtices a analizar
es: vecinos(1) = {2, 4} y vecinos(0) = {3}. De todos estos vrtices, el que se encuentra a
menor distancia es 2; por lo tanto, este ser el prximo nodo que debemos incorporar.
4
4
6
6
4
6
4
5
2
4
6
Ahora, el conjunto de vecinos a analizar es el

siguiente: vecinos(0) = {3}, vecinos(1) = {4} y
vecinos(2) = {3, 4, 5}. Recordemos que descartamos aquellos nodos que ya fueron incorporados al rbol.
Luego, de todo el conjunto de vecinos, los
ms cercanos son 4 (llegando por 1), 5 (llegando por 2) y 3 (llegando por 2). Todos estos
vecinos son equidistantes por lo que podemos
seleccionar cualquiera de ellos. Optaremos
por incorporar a 4 a travs de 1.
632
Claramente, el prximo vecino que debemos

incorporar ser 3 o 5, ambos pasando por 2.
Estos nodos se conectan a 2 con una distancia de 4, la menor entre todas las posibilidades.
La eleccin entre estos dos nodos ser arbitraria. Escogeremos a 3.
4
6
6
4
6
4
5
2
4
6
Visiblemente, el prximo vecino que debemos

incorporar ser 5 a travs de 3 y finalmente
conectaremos a 6 a travs de 5.
Con esto habremos formado un rbol con todos los vrtices del grafo original, pero conservando solo aquellas aristas que minimizan
el camino entre estos.
Comparemos entonces el grafo original con
su rbol generador mnimo hallado mediante
la aplicacin del algoritmo de Prim.
4
6
6
4
6
4
5
2
4
6
4
0
6
4
6
4
5
2
4
6
5
2
4
Fig. 22.16 Comparacin del grafo original con el rbol generador mnimo hallado por Prim.
Veamos entonces la clase MstImplePrim que implementa la interface Mst.
package libro.cap22.mst.imple;
import libro.cap22.mst.Mst;
633
public class MstImplePrim implements Mst

{
public Grafo procesar(Grafo g, int s)
{
// nodos incorporados al arbol, inicialmente vacio
ArrayList<Integer> incorporados = new ArrayList<Integer>();

// arbol recubridor minimo implementado como una instancia de Grafo
Grafo solu = new Grafo(g.size());
// en cada iteracion procesamos al nodo n, comenzando por s
int n = s;
for(int i=0; i<g.size()-1; i++)
{
// marco a n como procesado y lo incorporo al array
g.setProcesado(n);
incorporados.add(n);
// de todos los nodos incorporados busca el nodo no imporporado

// cuya distancia sea la menor...
int
int
int
int
incorporar[] = buscarMinimos(g,incorporados);
desde = incorporar[0]; // nodo ya incorporado
hasta = incorporar[1]; // nodo a incorporar...
dist = g.getDistancia(desde,hasta);
// agrego al arbol la arista que conecta el nuevo nodo
solu.addArista(new Arista(desde, hasta, dist));
// en la proxima iteracion marcaremos como "procesado"

// al nodo que acabamos de incorporar al arbol solucion
}
}
n = hasta;
return solu;
// sigue mas abajo

// :
El mtodo buscarMinimos analiza los vecinos de todos los nodos que contiene el
arraylist incorporados y retorna aquel que se encuentre ubicado a menor distancia.
El mtodo retorna un int[2] donde el primer elemento es el nodo desde el cual nos
conectaremos hacia el prximo nodo que debemos incorporar. Este ltimo ubicado en la
segunda posicin del array.
// :
private int[] buscarMinimos(Grafo g, ArrayList<Integer> incorporados)

{
int ret[]=new int[2] ;
int min = Integer.MAX_VALUE;
for(int i=0; i<incorporados.size(); i++)
{
int desde = incorporados.get(i);
ArrayList<Integer> vecinos = g.getVecinos(desde);
634
for(int j=0; j<vecinos.size();j++)

{
int vecino = vecinos.get(j);
if( vecino!=desde && g.getDistancia(desde,vecino)<min )
{
min = g.getDistancia(desde,vecino);
ret[0]=desde;
ret[1]=vecino;
}
}
return ret;
22.4.2 Algoritmo de Kruskal
Joseph B. Kruskal (1928 2010).

Fue un matemtico y estadstico
estadounidense.
Investigador en el Bell-Labs, en 1956,
descubri un algoritmo para la resolucin del problema del rbol recubridor
mnimo, el cual es un problema tpico
de optimizacin combinatoria.
El algoritmo de Kruskal tambin ofrece una solucin al problema de hallar el rbol recubridor mnimo de un grafo, pero en este caso el anlisis pasa por las aristas.
La estrategia consiste en incorporar, una a una, las aristas de menor peso, siempre y
cuando no formen ciclos. Dado que buscamos formar un rbol la cantidad de aristas que
debemos incorporar ser n-1 siendo n la cantidad de vrtices que tiene el grafo original.
Comenzaremos analizando el conjunto de

aristas del grafo, ordenndolo de menor a
mayor segn su distancia. A igual distancia la
eleccin es arbitraria pero nosotros daremos
prioridad a las que conecten nodos con etiquetas de menor valor.
As, el conjunto ordenado de aristas ser el siguiente: {(1,2,2), (3,5,2), (1,4,4), (2,3,4), (2,5,4),
(5,6,4), (0,1,6), (0,3,6), (2,4,6), (3,6,6), (4,5,6) }
Cada terna representa nodoDesde, nodoHasta y la distancia entre ambos.
Las aristas que agregaremos al conjunto solucin sern (1,2,2), (3,5,2), (1,4,4) y (2,3,4).
La siguiente arista en el conjunto ordenado
es (2,5,4), indicada con una lnea punteada.
Claro que al incorporar esta arista formaramos un ciclo, por esta razn la descartamos y
analizamos las siguientes.
El rbol se completa con las aristas (5,6,4),
(0,1,6) que no forman ciclos y suman la cantidad de n-1 aristas necesarias para unir a todos los vrtices del grafo original.
4
6
6
4
6
4
4
6
4
6
Algoritmo de Kruskal
4
6
4
4
6
El lector podr observar que el rbol que obtuvimos con el algoritmo de Kruskal coincide
con el rbol arrojado por el algoritmo de Prim.
635
Para simplificar la lgica del algoritmo, antes de comenzar agregaremos a la clase

Grafo el mtodo getAristas.
// :
public class Grafo

{
// :
public ArrayList<Arista> getAristas()

{
ArrayList<Arista> arr = new ArrayList<Arista>();
{
for(int j=0; j<matriz.length; j++ )
{
if( matriz[i][j] != Integer.MAX_VALUE )
{
Arista a = new Arista(i, j, matriz[i][j]);
// recordemos que sobrescribimos el metodo
// equals indicando que la arista (a,b)
// identica a la arista (b,a)
}
}
}
if( !arr.contains(a) )
{
arr.add(a);
}
return arr;
// :
Ahora s, veamos la clase MstImpleKruskal que implementa la interface Mst siguiendo estos lineamientos.
package libro.cap22.mst.imple;
import java.util.Collections;
import java.util.Comparator;
public class MstImpleKruskal implements Mst
{
public Grafo procesar(Grafo g, int s)
{
// tomo el conjunto de aristas del grafo original
ArrayList<Arista> aristas = g.getAristas();
636
// las ordeno segun su distancia, de menor a mayor
Collections.sort(aristas, new ComparaArista());

// instancio el grafo solucion (arbol, conexo y sin ciclos)
Grafo solu = new Grafo(g.size());

// agrego exactamente n-1 aristas
int i=0;
while( !aristas.isEmpty() && i<g.size()-1 )
{
// tomo la primer arista del array, la de menor peso
Arista a = aristas.get(0);
// si no hay ciclo la agrego y cuento una arista mas
if( !solu.hayCiclo(a.getN1(),a.getN2()) )
{
solu.addArista(a);
i++;
}
// la remuevo del conjunto de aristas disponibles
}
}
aristas.remove(0);
return solu;
class ComparaArista implements Comparator<Arista>

{
public int compare(Arista a1, Arista a2)
{
return a1.getDistancia()-a2.getDistancia();
}
}
La clase ComparaArista es una inner class. Java permite definir clases dentro de otras
clases con el objetivo de reducir la cantidad de archivos de cdigo fuente. La idea de
incluir una clase adentro de otra es til cuando la clase interna es de uso exclusivo de la
clase contenedora. En nuestro caso, al menos por ahora, la clase ComparaArista solo
es utilizada por la implementacin del algoritmo de Kruskal.
Notemos que el hecho de que una clase est codificada dentro del cuerpo de otra no
afecta para nada la relacin de herencia que pueda existir entre ambas. En el caso de las
clases, MstImpleKruskal y ComparaArista, ambas heredan de Object. Adems,
la primera implementa la interface Mst mientras que la segunda implementa la interface
Comparator. Solo eso.
Volviendo al algoritmo de Kruskal, notemos lo simple que result su implementacin. En
parte, esto se debe a que el mtodo hayCiclo que desarrollamos en la clase Grafo
casi al principio del captulo nos permite determinar si, al conectar dos nodos con una
arista, estaremos o no formando un ciclo en nuestro grafo.
Para terminar, veamos un programa donde el usuario ingresa un vrtice inicial y la implementacin que prefiere utilizar para hallar el rbol de cubrimiento mnimo del grafo que
hemos utilizado en este captulo.
637
package libro.cap22.mst.test;
public class Test
{
public static void main(String[] args) throws Exception
{
int[][] mAdy = { { i, 6, i,
, { 6, i, 2,
, { i, 2, i,
, { 6, i, 4,
, { i, 4, 6,
, { i, i, 4,
, { i, i, i,
6,
i,
4,
i,
i,
2,
6,
i,
4,
6,
i,
i,
6,
i,
i,
i,
4,
2,
6,
i,
4,
i
i
i
6
i
4
i
}
}
}
}
}
}
} };
System.out.print("Ingrese el nodo inicial: ");

int s = scanner.nextInt();
System.out.println("Ingrese la implementacion: ");
String sClassImple = scanner.next();
// obtengo una instancia de la implementacion indicada por el usuario
Mst mst = (Mst) Class.forName(sClassImple).newInstance();

// proceso
Grafo solu = mst.procesar(g, 0);
for(Arista a: solu.getAristas())
{
System.out.println(a);
}
Al ejecutar el programa veremos los siguientes resultados:

Ingrese el nodo inicial: 0
Ingrese la implementacion:
libro.cap22.mst.imple.MstImpleKruskal
Desde: 0, Hasta: 1 Distancia: 6
638
Para utilizar la implementacin de Prim haremos:

Ingrese el nodo inicial: 0
Ingrese la implementacion:
libro.cap22.mst.imple.MstImplePrim
22.5 Resumen
En este captulo analizamos la estructura Grafo como una estructura no lineal y recursiva. Observamos la importancia de recordar qu nodos del grafo ya hemos procesado
para no incurrir en loops infinitos.
Los algoritmos sobre grafos son complejos y la mejor forma de abordarlos es encapsulando esta complejidad utilizando clases y objetos, tal como lo hicimos con la clase
Grafo.
22.6 Contenido de la pgina Web de apoyo

El material marcado con asterisco (*) solo est disponible para docentes.
22.6.1 Mapa conceptual

22.6.2 Autoevaluaciones
22.6.3 Videotutoriales
22.6.3.1 Algoritmo de Dijkstra por greddy
22.6.3.2 Algoritmo de Dijkstra por dinmica
22.6.3.3 Algoritmo de Prim
22.6.3.4 Algoritmo de Kruskal
22.6.4 Presentaciones*

Capitulo 22

Cargado por

Copyright:

Formatos disponibles

Capitulo 22

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Capitulo 22

Cargado por

Copyright:

Formatos disponibles

22

Algoritmos sobre grafos

Objetivos del captulo

22.1 Introduccin ..................................................................602

los principales problemas que pueden

22.3 El problema de los caminos mnimos ...........................617

Algoritmos a fondo / pag. 605

22. Algoritmos sobre grafos

Leonhard Euler (1707 - 1783). Fue un

Fig. 22.1 Los 7 puentes de la ciudad de Knigsberg.

Fig. 22.2 Representacin del problema de los 7 puentes mediante un grafo.

Algortmos a fondo - Ing. Pablo A. Sznajdleder

Algoritmos a fondo / pag. 606

22.2 Definicin de grafo

En este captulo, adems de estudiar conceptos tericos, analizaremos algunos de los

22.2 Definicin de grafo

22.2.1 Grafos conexos y no conexos

22.2.2 Grafos dirigidos y no dirigidos

Algortmos a fondo - Ing. Pablo A. Sznajdleder

Algoritmos a fondo / pag. 607

22. Algoritmos sobre grafos

22.2.3 El camino entre dos vrtices

Fig. 22.6 Grafo conexo con ciclos.

Fig. 22.7 Grafo conexo sin ciclos.

Algortmos a fondo - Ing. Pablo A. Sznajdleder

Algoritmos a fondo / pag. 608

22.2 Definicin de grafo

Fig. 22.8 rbol: grafo conexo sin ciclos.

22.2.6 Grafos ponderados

Fig. 22.9 Grafo ponderado no dirigido.

22.2.7 Vrtices adyacentes y matriz de adyacencias

Algortmos a fondo - Ing. Pablo A. Sznajdleder

Algoritmos a fondo / pag. 609

22. Algoritmos sobre grafos

La matriz de adyacencias de un grafo no dirigido es simtrica ya que, para todo par de

Fig. 22.11 Matriz de adyacencias de un grafo no dirigido y ponderado

En Java, los wrappers de todos los tipos

En este caso, la relacin de adyacencia entre dos vrtices a y b se reflejada cuando en la

Algortmos a fondo - Ing. Pablo A. Sznajdleder

Algoritmos a fondo / pag. 610

22.2 Definicin de grafo

Fig. 22.12 Matriz de adyacencias de un grafo dirigido y ponderado.

22.2.8 La clase Grafo

private int matriz[][];

public Grafo(int mat[][])

Agregaremos los mtodos triviales getDistancia y size. El primero retornar la

Algortmos a fondo - Ing. Pablo A. Sznajdleder

Algoritmos a fondo / pag. 611

22. Algoritmos sobre grafos

return (n1==otra.n2 && n2==otra.n1)

public String toString()

Algortmos a fondo - Ing. Pablo A. Sznajdleder

Algoritmos a fondo / pag. 612

22.2 Definicin de grafo

Adems del constructor y el mtodo toString, en la clase Arista sobrescribimos el

// matriz cuadrada de n filas y n columnas

matriz = new int[n][n];

for(int i=0;i<n; i++)