Beruflich Dokumente
Kultur Dokumente
4 6 5 16 8 10
24 23 18 11 14 21 7 9
4 6 5 8 11 7 9
G = (V, A)
TG aT ca = 50
Algoritmo de Prim:
Comenzando con un nodo raz arbitrario s, hacer crecer el rbol T desde s hacia afuera. afuera. En cada paso, paso, se aade al rbol T el nodo que tenga una arista de menor coste que lo conecte a otros nodos de T.
a a
u
10
11
12
13
5 6 4
3 4 7
14
16
O(AV)
19
21
22
23
24
25
del algoritmo
26
MakeSet(): Creacin del conjunto, MakeSet(): conjunto, O(1). FindSet(): FindSet (): Encontrar el conjunto al que pertenece, pertenece, O(1). Union(A,B): Copia Copia elementos de A a B haciendo 27 que los elementos de A tambin apunten a B...
Mejora: Copiar siempre el menor en el mayor. Peor caso: Un elemento se copia como mximo log(n) veces, luego n uniones se hacen en O(n log n). El anlisis amortizado de la operacin nos dice que una unin es de orden O(log n).
28
O(A log V)
29
En cada iteracin, aadimos la arista de menor coste que aade un nuevo nodo a nuestro rbol S
31
32
33
34
35
36
PriorityQueue Q; // Cola con prioridad foreach (v V) { coste[v] = ; padre[v] = NULL; Q.add(v, coste[v]); } coste[r] = 0; // Eleccin de una raz r S = ; // Nodos ya explorados while (!Q.empty (!Q.empty()) ()) { u = Q.pop(); // Menor elemento de Q S = S {u}; foreach ((u,v ((u,v) )A incidente en u) if ((v ((vS) && (coste( (coste(u,v u,v) ) < coste[v])) { coste[v] = coste(u,v coste(u,v); ); // Actualizar prioridad padre[v] = u; // Vecino ms cercano de u } } 40 Resultado: El AGM est almacenado en el vector de padres
}
PriorityQueue Q; foreach (v V) { // O(V log V) coste[v] = ; padre[v] = NULL; Q.add(v, coste[v]); } coste[r] = 0; // O(log V) S = ; while (!Q.empty (!Q.empty()) ()) { // V iteraciones u = Q.pop(); // O(log V) S = S {u}; Para cada arista del grafo foreach ((u,v ((u,v) )A incidente en u) if ((v ((vS) && (coste( (coste(u,v u,v) ) < coste[v])) { O(A log V) coste[v] = coste(u,v coste(u,v); ); // O(log V) padre[v] = u; // O(1) } } 41 Resultado: El AGM est almacenado en el vector de padres
}
42
Caminos mnimos
2.9 km
43
Caminos mnimos
Problema Dado un grafo G ponderado con pesos positivos, calcular el camino de menor peso existente entre un vrtice s y otro vrtice t.
2
14
23 18
s 6
30 15 5 20
2 11 16 44
4
6
Coste = 50 9 + 23 + 2 + 16
44
Caminos mnimos
Algoritmo de Dijkstra (1959) Dado un grafo G=(V,A) y un vrtice s, encontrar el camino de costo mnimo para llegar desde s al resto de los vrtices en el grafo.
IDEA: Mantener el conjunto de nodos ya explorados para los cuales ya hemos determinado el camino ms corto desde s
45
Caminos mnimos
Algoritmo de Dijkstra (1959) Conjunto de candidatos: Vrtices del grafo. Solucin parcial S: Vrtices a los cuales ya sabemos llegar usando el camino ms corto (inicialmente ) Funcin de seleccin: Vrtice v del conjunto de candidatos (V (V\ \S) que est ms cerca del vrtice s.
46
Caminos mnimos
Propiedades de los caminos mnimos Si d(s,v d(s,v) ) es la longitud del camino mnimo para ir desde el vrtice s hasta el vrtice v, entonces se satisface que d( d(s,v s,v) ) d( d(s,u s,u) ) + d(u,v d(u,v) )
s ds,x dx,w x
47
Caminos mnimos
Algoritmo de Dijkstra (1959) Funcin de seleccin: Vrtice v del conjunto de candidatos (V (V\ \S) que est ms cerca del vrtice s. Esto es, es, elegir el vrtice v que minimice
(v) = min d (u ) + d (u , v)
( u , v ) : u S
d(u) u
d(u,v)
S
s
48
Caminos mnimos
d(u) u
d(u,v)
S
s
d(u) u
d(u,v)
S
s
49
Set S = ; // Vrtices ya seleccionados PriorityQueue Q; // Cola con prioridad foreach ( vV ) { pred[v] [v] = null null; ; Q.add( Q.add(v,d v,d[v]); [v]); d[v] = ; pred } d[s]=0; while (!Q.empty (!Q.empty()) ()) { v = Q.pop (); // Seleccin del vrtice S.add(v); foreach ( ( (v,w v,w) )A incidente en v ) if ( d[w] > d[v] + coste( coste(v,w v,w) ) ) { d[w] = d[v] + coste(v,w coste(v,w); ); pred[w] pred [w] = v; } } Resultado: Caminos mnimos almacenados en el vector pred pred[] []
}
50
Set S = ; PriorityQueue Q; foreach ( vV ) { d[v] = ; pred pred[v] [v] = null null; ; Q.add( Q.add(v,d v,d[v]); [v]); // O(log V) } d[s]=0; // O(1) while (!Q.empty (!Q.empty()) ()) { v = Q.pop (); // O(log V) S.add(v); // O(1) foreach ( ( (v,w v,w) )A incidente en v ) if ( d[w] > d[v] + coste( coste(v,w v,w) ) ) { // O(1) d[w] = d[v] + coste(v,w coste(v,w); ); // O(log V) pred[w] pred [w] = v; // O(1) } } 51 Resultado: Caminos mnimos almacenados en el vector pred pred[] []
}
Set S = ; PriorityQueue Q; foreach ( vV ) { // O(V log V) d[v] = ; pred pred[v] [v] = null null; ; Q.add( Q.add(v,d v,d[v]); [v]); } d[s]=0; while (!Q.empty (!Q.empty()) ()) { v = Q.pop (); S.add(v); Para cada arista del grafo foreach ( ( (v,w v,w) )A incidente en v ) if ( d[w] > d[v] + coste( coste(v,w v,w) ) ) { O(A log V) d[w] = d[v] + coste(v,w coste(v,w); ); pred[w] pred [w] = v; } } 52 Resultado: Caminos mnimos almacenados en el vector pred pred[] []
}
Caminos mnimos
S= Q = {s, 2, 3, 4, 5, 6, 7, t }
0
s 14 9 2 23 3
6 30
18 2 4 6
15
5 20
11
19
16
distancia al nodo
44
53
Caminos mnimos
S={} Q = { s, 2, 3, 4, 5, 6, 7, t }
0
s 14 9 2 23 3
6 30
18 2 4 6
15
5 20
11
19
16
44
54
Caminos mnimos
S={s} Q = { 2, 3, 4, 5, 6, 7, t }
9 0
s 14 9 2 23 3
14
6 30
18 2 4 6
15
5 20
11
19
16
15
44
55
Caminos mnimos
S={s} Q = { 2, 3, 4, 5, 6, 7, t }
9 0
s 14 9 2 23 3
14
6 30
18 2 4 6
15
5 20
11
19
16
15
44
56
Caminos mnimos
S = { s, 2 } Q = { 3, 4, 5, 6, 7, t }
9 0
s 14 9 2 23 3
32
14
6 30
18 2 4 6
15
5 20
11
19
16
15
44
57
Caminos mnimos
S = { s, 2 } Q = { 3, 4, 5, 6, 7, t }
9 0
s 14 9 2 23 3
32
14
6 30
18 2 4 6
15
5 20
11
19
16
15
44
58
Caminos mnimos
S = { s, 2, 6 } Q = { 3, 4, 5, 7, t }
9 0
s 14 9 2 23 3
32
14
6 30
18 2 4 6
15
5 20
11
19
44
44
16 t
15
59
Caminos mnimos
S = { s, 2, 6 } Q = { 3, 4, 5, 7, t }
9 0
s 14 9 2 23 3
32
14
6 30
18 2 4 6
15
5 20
11
19
44
44
16 t
15
60
Caminos mnimos
S = { s, 2, 6, 7 } Q = { 3, 4, 5, t }
9 0
s 14 9 2 23 3
32
14
6 30
18 2 4 6
15
5 20
11
19
35
44
16 t
15
59
61
Caminos mnimos
S = { s, 2, 6, 7 } Q = { 3, 4, 5, t }
9 0
s 14 9 2 23 3
32
14
6 30
18 2 4 6
15
5 20
11
19
35
44
16 t
15
59
62
Caminos mnimos
S = { s, 2, 3, 6, 7 } Q = { 4, 5, t }
9 0
s 14 9 2 23 3
32
14
6 30
18 2 4 6
15
5 20
11
19
34
44
16 t
15
51
63
Caminos mnimos
S = { s, 2, 3, 6, 7 } Q = { 4, 5, t }
9 0
s 14 9 2 23 3
32
14
6 30
18 2 4 6
15
5 20
11
19
34
44
16 t
15
51
64
Caminos mnimos
S = { s, 2, 3, 5, 6, 7 } Q = { 4, t }
9 0
s 14 9 2 23 3
32
14
6 30
18 2 4 6
15
5 20
11
45
6
19
34
44
16 t
15
50
65
Caminos mnimos
S = { s, 2, 3, 5, 6, 7 } Q = { 4, t }
9 0
s 14 9 2 23 3
32
14
6 30
18 2 4 6
15
5 20
11
45
6
19
34
44
16 t
15
50
66
Caminos mnimos
S = { s, 2, 3, 4, 5, 6, 7 } Q={t}
9 0
s 14 9 2 23 3
32
14
6 30
18 2 4 6
15
5 20
11
45
6
19
34
44
16 t
15
50
67
Caminos mnimos
S = { s, 2, 3, 4, 5, 6, 7 } Q={t}
9 0
s 14 9 2 23 3
32
14
6 30
18 2 4 6
15
5 20
11
45
6
19
34
44
16 t
15
50
68
Caminos mnimos
S = { s, 2, 3, 4, 5, 6, 7, t } Q={ }
9 0
s 14 9 2 23 3
32
14
6 30
18 2 4 6
15
5 20
11
45
6
19
34
44
16 t
15
50
69
Caminos mnimos
9 0
s 14 9 2
23
32
14
6 30
18 2 4 6
15
5 20
11
45
6
19
34
44
16 t
15
50
70
Caminos mnimos
Optimalidad del algoritmo de Dijkstra Invariante: Para cada vS, d(v) es la longitud del camino mnimo para ir desde el vrtice s hasta el vrtice v.
P P' s S u v
71
Caminos mnimos
Optimalidad del algoritmo de Dijkstra Demostracin Por induccin sobre el tamao de S Caso base: |S| = 0. Trivial.
P P' s S u v
72
Caminos mnimos
Optimalidad del algoritmo de Dijkstra Demostracin Por induccin sobre el tamao de S Induccin: Supongamos que es cierto para |S| = k 0. Sea v el siguiente nodo que se aade a S y( (u,v u,v) ) la arista elegida para conectar S con v. El camino ms corto de s a u ms (u,v u,v) ) es un camino de s a v de longitud d(v). Cualquier otro camino P de s a v ser de longitud l(P)d(v) : Sea (x,y (x,y) ) la primera arista de P que abandona S y P el subcamino de s a x. La longitud de P es mayor que d(v) en cuanto abandona S.
73
Caminos mnimos
Optimalidad del algoritmo de Dijkstra Demostracin l (P) l (P') + l (x,y) d(x) + l (x, y) d(y) d(v)
Pesos no negativos Hiptesis inductiva Por El algoritmo de definicin Dijkstra elige v antes que y P y
P' s S
u v
74
Caminos mnimos
Implementacin del algoritmo de Dijkstra La implementacin eficiente del algoritmo de Dijkstra se basa en el uso de una estructura de datos adecuada: Una cola con prioridad.
Operacin add min update isEmpty Total Algoritmo Array Dijkstra V V A V V V 1 1 V2 Heap binario log V log V log V 1 A log V Heap n-ario Heap Fibonacci
Holanda Blgica Alemania Francia Suiza Austria Andorra Italia Portugal Espaa
76
Si el grafo no es plano plano, , puede requerir tantos colores como vrtices haya haya. .
78
Solucin ptima
Solucin subptima
81
82
83
84