Está en la página 1de 115

Instituto Tecnolgico de Ciudad Madero

Grafos Ponderados

Dra. Laura Cruz Reyes


Dra. Claudia Guadalupe Gmez Santilln
Dr. Nelson Rangel Valdez
Ruta ms corta
El algortimo BFD encuentra la ruta ms corta
de un vrtice de inicio a todos los otros
vrtices, asumiendo que la longitud o peso de
cada arco es el mismo.
El algoritmo de Dijkstra's encuentra la ruta
ms corta en grafos dirigidos ponderados
positivamente.

Grafos ITCM Laura Cruz-Claudia Gmez 2


Problema de los Caminos Mnimos con Costo
Positivo y Origen nico
Encontrar el caminos ms corto desde el vrtice
origen O al resto de los vrtices, medido por la suma
del costo de las aristas del camino. El costo de cada
arista es no negativo.

Queremos calcular los caminos mnimos con pesos


positivos desde un vrtice origen al resto de los
vrtices. El mtodo clsico de solucin es el algoritmo
de Dijkstra.

Laura Cruz Reyes Grafos y Caminos


Fundamento
Las siguientes cuestiones deben ser examinadas:

Cmo se ajusta el costo de ir del nodo origen


a otro nodo?

Cmo se busca el siguiente vrtice v en el


cual centrar la atencin?

Laura Cruz Reyes Grafos y Caminos


Fundamento
Vertice
Sea u el vrtice actual y sea
adyacente
v el vrtice adyacente a u
Du Dv
Sea Du el peso acumulado
Wuv (distancia) del origen o al
Vrtice
actual
u v vrtice u
Sea Dv el peso acumulado
del origen o al vrtice v
Sea Wuv el peso directo
para ir de u a v .

o Actualizando Dv una sola


vez no podemos garantizar
que se obtenga el mnimo.

Laura Cruz Reyes Grafos y Caminos


Fundamento
Vertice Si Dv es el peso acumulado
adyacente (distancia) sin utilizar u,
Du Dv si se est evaluando el peso
wuv acumulado de ir del origen a v
pasando por u,
Vrtice
actual
u v entonces Dv debera modificarse
si su valor actual es mayor que
Du + Wu,v.
Si Dv > (Du+Wu,v)
Entonces Du+Wu,v es la distancia

O de un camino ms barato al
vrtice v, pasando por los vrtices
considerados hasta el momento.

Laura Cruz Reyes Grafos y Caminos


Fundamento
Sea Dv=8, la distancia
6
mnima a v, pasando por z.

u v Sea Du=3, la distancia


mnima a u, un nodo no
visitado en el que tenemos
fijada nuestra atencin, y v
es adyacente de u.
Despus de visitar el nodo
u y haber completado su
procesamiento, el valor de
z
Dv ser 6.

Laura Cruz Reyes Grafos y Caminos


Fundamento
El ltimo vrtice u en el camino
6
a v ser un nodo ya visitado.
u v
De forma anloga, el vrtice
anterior a u debe haberse
visitado, y as sucesivamente.
Por tanto el valor de Dv
representa un camino desde
O hasta v utilizando como
nodos intermedios solamente
z vrtices que han sido ya
visitados.

Laura Cruz Reyes Grafos y Caminos


Fundamento

Si Dv corresponde a la
ruta ms corta de los
V
I vrtices ya visitados,
S
I y considerando que todas
T las aristas tienen un peso
A
D w no negativo (w0),
O
S cuando v sea el siguiente
z vrtice visitado, entonces
Dv ser la distancia
mnima desde el origen
hasta v.
Laura Cruz Reyes Grafos y Caminos
Algoritmo Dijkstra clsico

matemtico holands Edsger Dijkstra en 1959


Estructuras del Algoritmo de Dikjstra
Necesitamos 2 conjuntos y 2 arreglos para obtener la ruta
ms corta del vrtice de inicio s a todos los dems.

El conjunto S contendr todos los vrtices para los cuales se ha


calculado la distancia ms corta
Inicializamos S colocando el vrticice de inico s en l.
El conjunto V-S will contiene los vrtices que an necesitamos
procesar
Inicializamos V-S colocando los vrtices restantes en l.
d[v] contendr la distancia ms corta de s a v
Inicialmente, para cada v en V-S, asignar a d[v] el peso de los rcos
w(s,v) para cada vrtice v adyacente a s y dar un valor grande ()
para el resto de los vrtices.
p[v] contendr el padre de v en la ruta de s to v
Inicializamos p[v] a s para cada v en V-S
p
1 100
10 1 1
2 1
30
2 5 3 4
4 1
50 10 60 5 3
3 4
20
p
v S V-S d2 d3 d4 d5 1 2 3 4 5
1 1 1 1 1
1 1 2 1 1
1 1 4 1 4
1 1 4 1 3
1 1 4 1 3
Laura Cruz Reyes Grafos y Caminos
Estructuras del Algoritmo de Dikjstra

Conjunto V //nodos del grafo

entero w [1..n] [1..n] //matriz de pesos de las aristas

entero d [1..n] //vector de distancias mnimas


entero p [1..n] //vector de padres
//permite recuperar caminos mnimos
Conjunto S //nodos visitados

entero v, w //nodos actual y adyacente

Laura Cruz Reyes Grafos y Caminos


Algorithm Dikjstra
Input: a graph with the set of vertex V and the set of edges
E with weigth w
Output: the array d of distances and the array p of parents

1. Initialize S with the start vertex s


2. Initialize V-S with the remaining vertices
3. For all v in V-S
4. p[v] s
5. if there is an edge (s,v)
6. d[v] w[s,v] //direct weight
7. else
8. d[v]
9. While V-S is not empty
10. u = arg_min(V-S,d) //u is the smallest d[v] in V-S
11. Remove u from V-S and add u to S
10. for all v adjacent to u in V-S
11. if d[v] > d[u]+ w[u,v]
12. d[v]d[u]+ w[u,v]
13. p[v]u;

Laura Cruz Reyes Grafos y Caminos


Complejidad
El orden en tiempo de ejecucin del algoritmo de
Dijkstra depende mucho de dos aspectos:

Las caractersticas del grafo

La estructura de almacenamiento

Laura Cruz Reyes Grafos y Caminos


Complejidad: lista secuencial
Se emplea una lista secuencial binaria, para
almacenar los nodos no visitados V-S:
1 fue visitado, 0 no ha sido visitado
Entonces, la bsqueda arg_min regresa un ndice que
es un nodo no-visitado v con el valor mnimo en d.

La bsqueda arg_min es O(|V|) ya que para encontrar


el menor se deben analizar todos los vrtices en d, y
verificar en V_S que no haya sido visitado.

Laura Cruz Reyes Grafos y Caminos


Complejidad: lista secuencial

Como el ciclo externo se ejecuta |V| veces, esta


seccin del algoritmo es O(|V|2).

While V-S is not empty V)


//busca un nodo de costo mnimo no visitado
// el nodo esta en V-S y su D[v] es mnimo
u = arg_min(V-S,d) (V)
//u se elimina de V-S y se agrega a los visitados
Remove u from V-S (1)
add u to S (1)

Laura Cruz Reyes Grafos y Caminos


Complejidad: lista secuencial
En el ciclo ms interno, la actualizacin de d es O(1).
En el peor caso esta actualizacin se realiza para cada
nodo v y sus adyacentes w, dando una complejidad
O(|E|) en esta seccin.

While V-S is not empty


- - - - - -
for all v adjacent to u in V-S O(E)

//Actualizar si es ms barato pasar por w


si D[w] > D[v]+ C[v,w] O(1)
D[w] D[v]+ C[v,w]
P[w] v;

Laura Cruz Reyes Grafos y Caminos


Complejidad: lista secuencial
Por lo anterior, la complejidad de todo el algoritmo
sera:

T(V,E) = O(|V|2)+O(|E|)

Dado que E V2

T(V,E) = O(|V|2)

Laura Cruz Reyes Grafos y Caminos


Complejidad: cola de prioridad
Se podra emplear un rbol balanceado como
el montculo (heap) para almacenar las
distancias en d.

Por lo tanto se reducira la complejidad de


encontrar un nodo v con d mnima a un orden
logartmico O(log|V|),

Laura Cruz Reyes Grafos y Caminos


Complejidad: cola de prioridad
Como el ciclo externo se ejecuta |V| veces, esta
seccin del algoritmo sera O(|V|log|V|).

While V-S is not empty V)


//busca un nodo de costo mnimo no visitado
// el nodo esta en V-S y su D[v] es mnimo
u = arg_min(V-S,d) (logV)
//u se elimina de V-S y se agrega a los visitados
Remove u from V-S (1)
add u to S (1)

Laura Cruz Reyes Grafos y Caminos


Complejidad: cola de prioridad
En el ciclo ms interno, despes de actualizar d, la
reconstruccin del heap tardara O(log|V|).
El total de reconstrucciones del heap sera a lo ms
O(|E|), ya que esta tarea se realiza para cada nodo
con sus adyacentes. esta seccin del algoritmo sera
O(|E|log|V|).
While V-S is not empty
- - - - - -
for all v adjacent to u in V-S O(E)

//Actualizar si es ms barato pasar por w


si D[w] > D[v]+ C[v,w] O(log|V|)
D[w] D[v]+ C[v,w]
P[w] v;
Complejidad: cola de prioridad
La complejidad de todo el algoritmo seria:
T(V,E)=O(|V|log|V|)+O(|E|log|V|).

En una matriz esparcida, como |V|>|E|, la


complejidad sera:
T(V,E)= O(|V|log|V|)

En una matriz densa, como V|<|E|, la


complejidad sera:
T(V,E)=O(|E|log|V|) |
Laura Cruz Reyes Grafos y Caminos
Implementacin de V-S con tabla HASH
import java.util.HashSet;
import java.util.Set;
public class DijkstrasAlgorithm {
//graph: The weighted graph to be searched
//start: The start vertex
//pred: Output array to contain the predecessors in the shortest path
//dist: Output array to contain the distance in the shortest path
public static void dijkstrasAlgorithm (
Graph graph, int start,
int[] pred, double[] dist )
..
}
} Grafos ITCM Laura Cruz-Claudia Gmez 24
public static void dijkstrasAlgorithm(Graph graph, int start, int[] pred, double[] dist) {
int numV = graph.getNumV();
//Initialize S with the start vertex s
// Initialize V-S with the remaining vertices
Set<Integer> vMinusS = new HashSet<Integer>(numV);
for (int i = 0; i < numV; i++) {
if (i != start) {
vMinusS.add(i);
}
}
// Initialize pred and dist.
for (int v : vMinusS) {
pred[v] = start;
dist[v] = graph.edge(start, v).getWeight();
}

Grafos ITCM Laura Cruz-Claudia Gmez 25


// Main loop
//While V-S is not empty
while (vMinusS.size() != 0) {

// Find the value u in V-S with the smallest dist[u].


double minDist = Double.POSITIVE_INFINITY;
int u = -1;
for (int v : vMinusS) { Note the use of
if (dist[v] < minDist) { an inefficient
minDist = dist[v]; sequential search

u = v;
}
}

Grafos ITCM Laura Cruz-Claudia Gmez 26


// Main loop
while (vMinusS.size() != 0) {
.

// Remove u from vMinusS.


vMinusS.remove(u);

// Update the distances.


Note the
for (int v : vMinusS) {
inefficiently
if (graph.isEdge(u, v)) { use of the
double weight = graph.getEdge(u, v).getWeight(); graph and the
if (dist[u] + weight < dist[v]) { hash table
dist[v] = dist[u] + weight; ------------
Dont
pred[v] = u;
implement the
} cycle for
}
}
}
}
Grafos ITCM Laura Cruz-Claudia Gmez 27
Para un uso ms eficiente del grafo y de la tabla hash

// Update the distances.


Iterator<Edge> edgeIter = graph.edgeIterator(u);
while (edgeIter.hasNext()) {
Edge edge = edgeIter.next();
int v = edge.getDest();
if (vMinusS.contains(new Integer(v))) { Code to
double weight = edge.getWeight(); substitute the
if (dist[u] + weight < dist[v]) { cycle for
dist[v] = dist[u] + weight;
pred[v] = u;
}
}
}

Grafos ITCM Laura Cruz-Claudia Gmez 28


Ejercicios
1. Crear un archivo de datos para el primer
ejemplo de 5 vrtices y 7 arcos. Considere que la
numeracin de vrtices inicia en cero.
2. Hacer la puesta en marcha del algoritmo de
Dijkstra. Utilice el ejemplo del punto anterior,
tomando como vrtice de inicio el vrtice 0
3. Imprimir los arreglos pred y dist.

Grafos ITCM Laura Cruz-Claudia Gmez 29


import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

public class Main {

public static void main(String[] args) {

int numV = 0; // The number of vertices.


Graph g= null;

// Load the graph data from a file.


try {

Scanner scan = new Scanner(new FileReader(args[0]));


g = AbstractGraph.createGraph(scan, false, "List");
numV = g.getNumV();
//probar todos los mtodos: getNumV, isDirected, etc.

} catch (IOException ex) {


System.err.println("IO Error while reading graph");
System.err.println(ex.toString());
System.exit(1);
}
Grafos ITCM Laura Cruz-Claudia Gmez 30
}
Algoritmo de Dijkstra en detalle
s
S={} 0
10 100
V-S = { }
1 4
30

v d[v] p[v]
50
1 10 60
2
3 2 3
20
4
Algoritmo de Dijkstra en detalle
s
S={} s is the start
0
vertex
10 100
V-S = { }
1 4
30

v d[v] p[v]
50
1 10 60
2
3 2 3
20
4
Algoritmo de Dijkstra en detalle
s
S={} Set S will contain the
0
vertices for which we
100
V-S = { } have computed the 10
shortest distance
1 4
30

v d[v] p[v]
50
1 10 60
2
3 2 3
20
4
Algoritmo de Dijkstra en detalle
s
S = {} 0
10 100
V-S = { }
1 4
Set V-S will contain the 30
vertices that we still
v d[v] p[v] need to process
50
1 10 60
2
3 2 3
20
4
Algoritmo de Dijkstra en detalle
s
S={} 0
10 100
V-S = { }
1 4
30
v will contain the list of
v d[v] p[v] vertices not including s
50
1 10 60
2
3 2 3
20
4
Algoritmo de Dijkstra en detalle
s
S={} 0
10 100
V-S = { }
1 4
30
d[v] will contain the
v d[v] p[v] shortest distance from s
to50
v
1 10 60
2
3 2 3
20
4
Algoritmo de Dijkstra en detalle
s
S={} 0
10 100
V-S = { }
1 4
30
p[v] will contain the
v d[v] p[v] predecessor of v in the path
from
50 s to v
1 10 60
2
3 2 3
20
4
Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }
1 4
30

v d[v] p[v]
50
1 10 60
2
3 2 3
20
4

At initialization, the start vertex s is placed in


S, and the remaining vertices into V-S
Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }
1 4
30

v d[v] p[v]
50
1 10 60
2
3 2 3
20
4

For each v in V-S, we initialize d by setting d[v]


equal to the weight of the edge w(s, v) for each
vertex v, adjacent to s
Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }
1 4
30

v d[v] p[v]
50
1 10 10 60
2
3 2 3
20
4

For each v in V-S, we initialize d by setting d[v]


equal to the weight of the edge w(s, v) for each
vertex v, adjacent to s
Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }
1 4
30

v d[v] p[v]
50
1 10 10 60
2
3 30 2 3
20
4

For each v in V-S, we initialize d by setting d[v]


equal to the weight of the edge w(s, v) for each
vertex v, adjacent to s
Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }
1 4
30

v d[v] p[v]
50
1 10 10 60
2
3 30 2 3
20
4 100

For each v in V-S, we initialize d by setting d[v]


equal to the weight of the edge w(s, v) for each
vertex v, adjacent to s
Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }
1 4
30

v d[v] p[v]
50
1 10 10 60
2
3 30 2 3
20
4 100

For each v not adjacent to s, we set d[v] equal to


Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }
1 4
30

v d[v] p[v]
50
1 10 10 60
2
3 30 2 3
20
4 100

For each v not adjacent to s, we set d[v] equal to


Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }
1 4
30

v d[v] p[v]
50
1 10 10 60
2
3 30 2 3
20
4 100

We initialize each p[v] to s


Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }
1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 0
3 30 0 2 3
20
4 100 0

We initialize each p[v] to s


Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }
1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 0
3 30 0 2 3
20
4 100 0

We now find the vertex u in V-S that has the


smallest value of d[u]
Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }

u=1 u 1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 0
3 30 0 2 3
20
4 100 0

We now find the vertex u in V-S that has the


smallest value of d[u]
Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }

u=1 u 1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 0
3 30 0 2 3
20
4 100 0

Consider the vertices v that are adjacent to u


Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }

u=1 u 1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 0
3 30 0 2 3
v 20
4 100 0

If the distance from s to u (d[u]) plus the distance


from u to v is smaller than d[v] we update d[v] to
that value
Algoritmo de Dijkstra en detalle
s
S={0} 60 < 0
10 100
V-S = { 1, 2, 3, 4 }

u=1 u 1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 0
3 30 0 2 3
v 20
4 100 0

If the distance from s to u (d[u]) plus the distance


from u to v is smaller than d[v] we update d[v] to
that value
Algoritmo de Dijkstra en detalle
s
S={0} 60 < 0
10 100
V-S = { 1, 2, 3, 4 }

u=1 u 1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 60 0
3 30 0 2 3
v 20
4 100 0

If the distance from s to u (d[u]) plus the distance


from u to v is smaller than d[v] we update d[v] to
that value
Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }

u=1 u 1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 60 1
3 30 0 2 3
v 20
4 100 0

and set p[v] to u


Algoritmo de Dijkstra en detalle
s
S={0} 0
10 100
V-S = { 1, 2, 3, 4 }

u=1 u 1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 60 1
3 30 0 2 3
v 20
4 100 0

Remove u from V-S and


place it in S
Algoritmo de Dijkstra en detalle
s
S = { 0, 1 } 0
10 100
V-S = { 2, 3, 4 }

u=1 1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 60 1
3 30 0 2 3
20
4 100 0

Repeat until V-S is empty


Algoritmo de Dijkstra en detalle
s
S = { 0, 1 } 0
10 100
V-S = { 2, 3, 4 }

u=3 1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 60 1
3 30 0 2 3
20 u
4 100 0

The smallest d[v] in V-S is


vertex 3
Algoritmo de Dijkstra en detalle
s
S = { 0, 1 } 0
10 100
V-S = { 2, 3, 4 }

u=3 1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 60 1
3 30 0 2 3
v 20 u
4 100 0

The distance from s to u plus the distance from u


to v is 50
Algoritmo de Dijkstra en detalle
s
S = { 0, 1 } 0
10 100
V-S = { 2, 3, 4 }

u=3 1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 60 1
3 30 0 2 3
v 20 u
4 100 0

50 < d[2] (which is 60)


Algoritmo de Dijkstra en detalle
s
S = { 0, 1 } 0
10 100
V-S = { 2, 3, 4 }

u=3 1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
v 20 u
4 100 0

Set d[2] to 50 and p[2] to u


Algoritmo de Dijkstra en detalle
s
S = { 0, 1 } 0
10 100
V-S = { 2, 3, 4 }

u=3 1 4
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
v 20 u
4 100 0

Continue to the next


adjacent vertex
Algoritmo de Dijkstra en detalle
s
S = { 0, 1 } 0
10 100
V-S = { 2, 3, 4 }

u=3 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
20 u
4 100 0

Continue to the next


adjacent vertex
Algoritmo de Dijkstra en detalle
s
S = { 0, 1 } 0
10 100
V-S = { 2, 3, 4 }

u=3 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
20 u
4 100 0

90 < 100
Algoritmo de Dijkstra en detalle
s
S = { 0, 1 } 0
10 100
V-S = { 2, 3, 4 }

u=3 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
20 u
4 90 3

90 < 100
Algoritmo de Dijkstra en detalle
s
S = { 0, 1 } 0
10 100
V-S = { 2, 3, 4 }

u=3 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
20 u
4 90 3

Move u from V-S to S


Algoritmo de Dijkstra en detalle
s
S = { 0, 1, 3 } 0
10 100
V-S = { 2, 4 }

u=3 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
20 u
4 90 3

Move u from V-S to S


Algoritmo de Dijkstra en detalle
s
S = { 0, 1, 3 } 0
10 100
V-S = { 2, 4 }

u=2 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
u 20
4 90 3

Select vertex 2 from V-S


Algoritmo de Dijkstra en detalle
s
S = { 0, 1, 3 } 0
10 100
V-S = { 2, 4 }

u=2 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
u 20
4 90 3

d[2] + w(2,4) = 50 + 10 = 60
Algoritmo de Dijkstra en detalle
s
S = { 0, 1, 3 } 0
10 100
V-S = { 2, 4 }

u=2 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
u 20
4 90 3

60 < 90 (d[4])
Algoritmo de Dijkstra en detalle
s
S = { 0, 1, 3 } 0
10 100
V-S = { 2, 4 }

u=2 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
u 20
4 90 3

update d[4] to 60 and p[4] to 2


Algoritmo de Dijkstra en detalle
s
S = { 0, 1, 3 } 0
10 100
V-S = { 2, 4 }

u=2 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
u 20
4 60 2

update d[4] to 60 and p[4] to 2


Algoritmo de Dijkstra en detalle
s
S = { 0, 1, 3 } 0
10 100
V-S = { 2, 4 }

u=2 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
u 20
4 60 2

Remove 2 from V-S


Algoritmo de Dijkstra en detalle
s
S = { 0, 1, 3, 2 } 0
10 100
V-S = { 4 }

u=2 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
u 20
4 60 2

Remove 2 from V-S


Algoritmo de Dijkstra en detalle
s
S = { 0, 1, 3, 2 } 0
10 100
V-S = { 4 }

u=2 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
u 20
4 60 2

The final vertex in V-S is 4


Algoritmo de Dijkstra en detalle
s
S = { 0, 1, 3, 2 } 0
10 100
V-S = { 4 }

u=2 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
u 20
4 60 2

The final vertex in V-S is 4


Algoritmo de Dijkstra en detalle
s
S = { 0, 1, 3, 2 } 0
10 100
V-S = { 4 }

u=2 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
u 20
4 60 2

4 has no adjacent vertices; we move


4 into S
Algoritmo de Dijkstra en detalle
s
S = { 0, 1, 3, 2, 4 } 0
10 100
V-S = { }

u=2 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
u 20
4 60 2

4 has no adjacent vertices; we move


4 into S
Algoritmo de Dijkstra en detalle
s
S = { 0, 1, 3, 2, 4 } 0
10 100
V-S = { }

u=2 1 4 v
30

v d[v] p[v]
50
1 10 0 10 60
2 50 3
3 30 0 2 3
u 20
4 60 2

We are finished
Algoritmo de Dijkstra en detalle
s
s
0 0
10 100
10

1 4 1 4
30 30

50
10 60 10

v d[v] p[v] 2 3 2 3
20 20
1 10 0
2 50 3
3 30 0
4 60 2 rbol de expansin mnimo
rbol de Expansin Mnima
(Minimum Spanning Tree)

rbol de cobertura, rbol abarcante

Grafos ITCM Laura Cruz-Claudia Gmez 79


rbol de expansin
Un rbol de expansin (SP, spanning tree) es
un subconjunto de los arcos de un grafo tal
que todos los vrtices estn conectados
formando un rbol
El costo de un SP es la suma de los pesos de
los arcos.
Queremos encontrar el SP de menor costo.
La solucin fue formulada por R.C. Prim y es
muy similar al algoritmo de Dijkstra.

Grafos ITCM Laura Cruz-Claudia Gmez 80


Algoritmo de Prim
Idea general: Extiende un rbol incorporando
el arco ms barato que sale del rbol en
construccin

Grafos ITCM Laura Cruz-Claudia Gmez 81


Algoritmo de PRIM
A partir de un grafo no-dirigido, el algoritmo
(vorazmente) construye iterativamente el rbol
de expansin mnimo agregando nodos en un
rbol auxiliar
1. Iniciar con un rbol que contiene slo un nodo.
2. Mientras existan menos de n1 arcos en el rbol
a) Identificar un nodo (fuera del rbol) el cual tiene el
rco de menos peso de ese nodo a algn nodo del
rbol
b) Incorpora el nodo identificado como parte del rbol

Grafos ITCM Laura Cruz-Claudia Gmez 82


Ejemplo 1 del Algoritmo de PRIM
1. Iniciar con un rbol que contiene slo un nodo.
2. Mientras existan menos de n1 arcos en el rbol
a) Identificar un nodo (fuera del rbol) el cual tiene el rco de
menos peso de ese nodo a algn nodo del rbol
b) Incorpora el nodo identificado como parte del rbol

Grafos ITCM Laura Cruz-Claudia Gmez 83


Ejemplo 2 del Algoritmo de PRIM
1. Iniciar con un rbol que contiene slo un nodo.
2. Mientras existan menos de n1 arcos en el rbol
a) Identificar un nodo (fuera del rbol) el cual tiene
el rco de menos peso de ese nodo a algn
nodo del rbol
b) Incorpora el nodo identificado como parte del
rbol

Grafos ITCM Laura Cruz-Claudia Gmez 84


Estructuras del Algoritmo de Prim
Durante el proceso, los vrtices son divididos
en dos conjuntos
S, el conjunto de vrtice que ya se han incluido en
el rbol de expansin.
V-S, los vrtices restantes .
Algoritmo de PRIM
Algorithm Prim (G)
Input: a Graph G(V,E), G is connected and non-directed, s a start
vertex in V
Output: A minimum spanning T, this is a set of edges connecting all
nodes of V with the minimum cost

1. Initialize S with the start vertex s


2. Initialize V-S with the remaining vertices
3. While V-S is not empty
4. (u,v) = arg_min(S,V-S) //the edge with u en S and v
in V-S with the smallest w[u,v]
5. Remove v from V-S
6. Add v to S
6. Insert the edge (u,v) into the spanning tree T

Grafos ITCM Laura Cruz-Claudia Gmez 86


Desempeo del algoritmo PRIM
Usando una bsqueda secuencial
El Paso 4 es O(|V|) ya que todos los vrtices de V pueden ser
adyacentes del vrtice v.
El Paso 3 se ejecuta O(|V|) veces
Como 4 esta anidado dentro de 3, el algoritmo es O(|V|2)
Usando una cola de prioridad
El paso 4 se reduce a O(log n) donde n es el tamao de la cola de
prioridad
El algoritmo queda O(|E| log |V|)
Grafos Densos vs. Esparcidos
Para grafos densos no hay mejora ya que |E| is approximately
|V|2,
Si hay mejora para grafos esparcidos
Usando una cola de prioridad mejorada
El desempeo es O(|E| + |V| log |V|) o mejor
Implementacin de PRIM
Algorithm Prim(graph, start)
Input: a graph connected and non-directed
Output: The array result, representing the set of edges connecting all nodes of
V with the minimum cost, this is the minimum spanning tree

1. Create a Hash table to represent the V-S set


2. Declare the priority queue
3. Initialize V-S will all vertex, except the start vertex
4. Do the start vertex the current
5. While V-S is not empty
6. For all vertex in V-S which are adjacent to the current
7. Add to priority queue its edges //the pq grows in each iteration
8. Find in the priority queue the shortest edge, its destiny is dest,
//the destination is in V-S, but implicitly the source is in S
9. Take dest out of vMinusS
10. Add the dest edge to result //the source is known; it is inside the edge
11. Make dest the current vertex //adjacents are added in the next iteration
12. return result
Grafos ITCM Laura Cruz-Claudia Gmez 88
Implementacin de PRIM
import java.util.List; //to store the spanning tree as a sequential list of edges
import java.util.ArrayList; //to store the spanning tree as a sequential list of edges
import java.util.Set; //to implement V-S
import java.util.HashSet; //to implement V-S
import java.util.Iterator; //to navigate between adjacent edges
import java.util.Queue; //to find efficiently the edge with the min weight
import java.util.PriorityQueue; //to find efficiently the edge with the min weight

Grafos ITCM Laura Cruz-Claudia Gmez 89


public class PrimsAlgorithm {

public static List<Edge> primsAlgorithm(Graph graph, int start) {

List<Edge> result = new ArrayList<Edge>();


int numV = graph.getNumV();
// Use a HashSet to represent V-S
Set<Integer> vMinusS = new HashSet<Integer>(numV);
// Declare the priority queue.
Queue<Edge> pQ = new PriorityQueue<Edge>(numV, new CompareEdges());

// Initialize V-S
for (int i = 0; i < numV; i++) {
if (i != start) {
vMinusS.add(i);
}
}
int current = start; 90
// Main loop
while (vMinusS.size() != 0) {
// Update priority queue.
Iterator<Edge> iter = graph.edgeIterator(current);
while (iter.hasNext()) {
Edge edge = iter.next();
int dest = edge.getDest();
if (vMinusS.contains(dest)) {
pQ.add(edge);
}
}


}
}

91
// Main loop
while (vMinusS.size() != 0) {
// Update priority queue.

// Find the shortest edge whose source is in S and destination is in V-S.
int dest = -1;
Edge edge = null;
do {
edge = pQ.remove(); //Remove the edge with the min weight
dest = edge.getDest();
} while (!vMinusS.contains(dest));
// Take dest out of vMinusS.
vMinusS.remove(dest);
// Add edge to result.
result.add(edge);
// Make this the current vertex.
current = dest;
}
return result;
}
} 92
Comparacin de arcos
import java.util.Comparator;
/** * A class for comparing 2 edges*/

public class CompareEdges implements Comparator<Edge> {

@Override
public int compare(Edge e1, Edge e2) {
return Double.compare(e1.getWeight(), e2.getWeight());
}
}

Grafos ITCM Laura Cruz-Claudia Gmez 93


Ejemplo detallado del Algoritmo de Prim
0
S={0} 6 5

1 1 3
V-S = { 1, 2, 3, 4, 5 } 5 5
2
3 6 4 2
0
4 5
5

1 3
2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S={0} 6 5

1 1 3
V-S = { 1, 2, 3, 4, 5 } 5 5
2
3 6 4 2
0
4 5
5
The smallest edge
from u to v where u is 1 3
in S and v is in V-S is 2
the edge (0,2)

4 5
Ejemplo detallado del Algoritmo de Prim
0
S={0} 6 5

1 1 3
V-S = { 1, 2, 3, 4, 5 } 5 5
2
3 6 4 2
0
4 5
5
1
Add this edge to the 1 3
spanning tree 2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S={0} 6 5

1 1 3
V-S = { 1, 2, 3, 4, 5 } 5 5
2
3 6 4 2
0
4 5
5
1
1 3
and move 2 to S
2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2 } 6 5

1 1 3
V-S = { 1, 3, 4, 5 } 5 5
2
3 6 4 2
0
4 5
5
1
1 3
and move 2 to S
2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2 } 6 5

1 1 3
V-S = { 1, 3, 4, 5 } 5 5
2
3 6 4 2
0
4 5
5
Consider all edges (u, v)
1
where u is in S and v is 1 3
in V-S
(there are 8 possible 2
edges)

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2 } 6 5

1 1 3
V-S = { 1, 3, 4, 5 } 5 5
2
3 6 4 2
0
4 5
5
1
1 3
The smallest is (2, 5)
2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2 } 6 5

1 1 3
V-S = { 1, 3, 4, 5 } 5 5
2
3 6 4 2
0
4 5
5
1
Add (2,5) to the 1 3
spanning tree 2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2 } 6 5

1 1 3
V-S = { 1, 3, 4, 5 } 5 5
2
3 6 4 2
0
4 5
5
1
1 3
Move 5 from V-S to S
2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2, 5 } 6 5

1 1 3
V-S = { 1, 3, 4 } 5 5
2
3 6 4 2
0
4 5
5
1
1 3
Move 5 from V-S to S
2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2, 5 } 6 5

1 1 3
V-S = { 1, 3, 4 } 5 5
2
3 6 4 2
0
4 5
5
1
Find the smallest edge 1 3
(u, v) where u is in S
and v is in V-S 2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2, 5 } 6 5

1 1 3
V-S = { 1, 3, 4 } 5 5
2
3 6 4 2
0
4 5
5
1
The smallest edge is 1 3
(5, 3) 2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2, 5 } 6 5

1 1 3
V-S = { 1, 3, 4 } 5 5
2
3 6 4 2
0
4 5
5
1
The smallest edge is 1 3
(5, 3) 2

4 2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2, 5 } 6 5

1 1 3
V-S = { 1, 3, 4 } 5 5
2
3 6 4 2
0
4 5
5
1
1 3
Move 3 to S
2

4 2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2, 5, 3 } 6 5

1 1 3
V-S = { 1, 4 } 5 5
2
3 6 4 2
0
4 5
5
1
1 3
Move 3 to S
2

4 2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2, 5, 3 } 6 5

1 1 3
V-S = { 1, 4 } 5 5
2
3 6 4 2
0
4 5
5
1
The next smallest 1 3
edge is (2, 1) 2

4 2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2, 5, 3 } 6 5

1 1 3
V-S = { 1, 4 } 5 5
2
3 6 4 2
0
4 5
5
1
The next smallest 1 3
edge is (2, 1) 5 2

4 2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2, 5, 3 } 6 5

1 1 3
V-S = { 1, 4 } 5 5
2
3 6 4 2
0
4 5
5
1
1 3
Move 1 to S
5 2

4 2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2, 5, 3, 1 } 6 5

1 1 3
V-S = { 4 } 5 5
2
3 6 4 2
0
4 5
5
1
1 3
Move 1 to S
5 2

4 2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2, 5, 3, 1 } 6 5

1 1 3
V-S = { 4 } 5 5
2
3 6 4 2
0
4 5
5
1
The smallest edge to 4 1 3
is (1, 4) 5 2

4 2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2, 5, 3, 1 } 6 5

1 1 3
V-S = { 4 } 5 5
2
3 6 4 2
0
4 5
5
1
The smallest edge to 4 1 3
is (1, 4) 5 2

3 4 2

4 5
Ejemplo detallado del Algoritmo de Prim
0
S = { 0, 2, 5, 3, 1, 4 } 6 5

1 1 3
V-S = { } 5 5
2
3 6 4 2
0
4 5
5
1
The spanning tree is 1 3
complete 5 2

3 4 2

4 5