Vous êtes sur la page 1sur 43

Algoritmos greedy sobre grafos

Anlisis y Diseo de Algoritmos

Algoritmos greedy sobre grafos


rboles generadores minimales Algoritmo de Kruskal Algoritmo de Prim Caminos mnimos Algoritmo de Dijkstra Heursticas greedy El problema del coloreo de un grafo El problema del viajante de comercio

rboles generadores minimales


Problema Dado un grafo conexo G = (V, A) no dirigido y ponderado con pesos positivos, calcular un subgrafo conexo T G que conecte todos los vrtices del grafo G y que la suma de los pesos de las aristas seleccionadas sea mnima. Solucin Este subgrafo es necesariamente un rbol: rbol generador minimal o rbol de recubrimiento mnimo (en ingls, minimum minimum spanning tree tree [MST]).
2

rboles generadores minimales

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

rboles generadores minimales


Aplicaciones Diseo de redes: redes telefnicas, elctricas, hidralicas, hidralicas , de ordenadores, de carreteras p.ej. Construccin de redes de mnimo coste Refuerzo de lneas crticas Identificacin de cuellos de botella Enrutamiento (evitar ciclos) Soluciones aproximadas para problemas NP. Algoritmos de agrupamiento (anlisis de clusters) clusters)
4

rboles generadores minimales


Algoritmos greedy para resolver el problema: Algoritmo de Kruskal:
Comenzando con T=, considerar las aristas en orden creciente de coste y aadir las aristas a T salvo que hacerlo suponga la creacin de un ciclo ciclo. .

Algoritmo de borrado inverso:


Comenzando con T=A, considerar las aristas en orden decreciente de coste y eliminar las aristas de T salvo que eso desconectase T.

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.

rboles generadores minimales Algoritmo de Kruskal


Elementos del algoritmo de Kruskal Conjunto de candidatos: Aristas del grafo. Funcin de seleccin: La arista de menor coste. Funcin de factibilidad: El conjunto de aristas no contiene ningn ciclo. Criterio que define lo que es una solucin: El conjunto de aristas seleccionado conecta todos los vrtices (rbol con nn-1 aristas). Funcin objetivo: Suma de los costes de las aristas.
6

rboles generadores minimales Algoritmo de Kruskal


funcin Kruskal Kruskal( ( Grafo G(V,A) ) { set<aristas> C(A); // Solucin inicial vaca set<aristas> S; Ordenar(C); while (!C.empty (!C.empty() () && S.size S.size()!= ()!=V.size V.size() ()-1) { x = C.first C.first(); (); // Arista de menor coste C.erase(x); C.erase (x); if (!HayCiclo (!HayCiclo( (S,x S,x)) )) // Solucin factible? S.insert(x); S.insert (x); } if (S.size S.size()== ()==V.size V.size() ()-1) return S; else return No hay solucin; }

rboles generadores minimales Algoritmo de Kruskal

a a
u

Aadir la arista creara un ciclo.

La arista forma parte del rbol generador minimal. minimal.


8

rboles generadores minimales Algoritmo de Kruskal


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

rboles generadores minimales Algoritmo de Kruskal


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

10

rboles generadores minimales Algoritmo de Kruskal


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

11

rboles generadores minimales Algoritmo de Kruskal


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

12

rboles generadores minimales Algoritmo de Kruskal


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

13

rboles generadores minimales Algoritmo de Kruskal

5 6 4

3 4 7

14

rboles generadores minimales Algoritmo de Kruskal


Optimalidad del algoritmo de Kruskal Teorema: El algoritmo de Kruskal halla un rbol generador minimal. Demostracin: Por induccin sobre el nmero de aristas que se han incluido en el rbol generador minimal.
15

rboles generadores minimales Algoritmo de Kruskal


Optimalidad del algoritmo de Kruskal Demostracin Caso base: Sea k1 la arista de menor peso en A. Entonces, existe un AGM tal que k1 T. Suponemos que es cierto para n-1: La (n-1)-sima arista incluida por el algoritmo de Kruskal pertenece al AGM. Demostramos que es cierto para n: La n-sima arista incluida por el algoritmo de Kruskal pertenece al AGM.

16

rboles generadores minimales Algoritmo de Kruskal


Optimalidad del algoritmo de Kruskal Demostracin Caso base
Por reduccin al absurdo: Sea k1 la arista de menor peso en A. Supongamos un AGM T que no incluye a k1. Consideremos T'k1 con peso(T'k1) = peso(T') + peso(k1). En T'k1 aparece un ciclo (por qu?), pero si eliminamos cualquier arista del ciclo (x), distinta de k1, obtenemos un rbol T*=T'+k1-x con peso(T*) = peso(T') + peso(k1) peso(x). Por tanto, como peso(k1) < peso(x), deducimos que peso(T*) < peso(T'). Contradiccin.
17

rboles generadores minimales Algoritmo de Kruskal


Optimalidad del algoritmo de Kruskal Demostracin Induccin
Por reduccin al absurdo: Supongamos un AGM T' que incluye a {k1,..., kn-1} pero no incluye a kn. Consideremos T'kn con peso(T'kn) = peso(T') + peso(kn). Aparece un ciclo, que incluir al menos una arista x que NO pertenece al conjunto de aristas seleccionadas {k1, ..., kn-1} Eliminando dicha arista del ciclo, obtenemos un rbol T*=T'+kn-x con peso(T*) = peso(T') + peso(kn) peso(x). Pero peso(kn) < peso(x), por lo que peso(T*) < peso(T'). Contradiccin. 18

rboles generadores minimales Algoritmo de Kruskal


funcin Kruskal Kruskal( ( Grafo G(V,A) ) { set<aristas> C(A); set<aristas> S; Ordenar(C); while (!C.empty (!C.empty() () && S.size S.size()!= ()!=V.size V.size() ()-1) { x = C.first C.first(); (); C.erase(x); C.erase (x); if (!HayCiclo (!HayCiclo( (S,x S,x)) )) S.insert(x); S.insert (x); } if (S.size S.size()== ()==V.size V.size() ()-1) return S; else return No_hay_solucion No_hay_solucion; ; } // Eficiencia

// O(A log A) // // // // // O(1) O(1) O(1) O(V) O(V)

O(AV)

19

rboles generadores minimales Algoritmo de Kruskal


Implementacin eficiente del algoritmo de Kruskal (como combinacin de componentes conexas) Se comienza con un conjunto de n componentes conexas de tamao 1 (cada nodo en una componente conexa). La funcin de factibilidad me aceptar la arista de menor costo que una dos componentes conexas (para garantizar que no hay ciclos). En cada iteracin quedar una componente conexa menos, por lo que, finalmente, el algoritmo terminar con una nica componente conexa: el rbol generador minimal. minimal .
20

rboles generadores minimales Algoritmo de Kruskal


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

21

rboles generadores minimales Algoritmo de Kruskal


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

22

rboles generadores minimales Algoritmo de Kruskal


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

23

rboles generadores minimales Algoritmo de Kruskal


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

24

rboles generadores minimales Algoritmo de Kruskal


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

25

rboles generadores minimales Algoritmo de Kruskal


funcin Kruskal Kruskal( ( Grafo G(V,A) ) { S = ; Ordenar(A); // Orden creciente de pesos for (i=0; i< i<V.size V.size() ()-1; i++) MakeSet(V[i]); MakeSet (V[i]); while (!A.empty (!A.empty() () && S.size S.size()!= ()!=V.size V.size() ()-1) { (u,v u,v) ) = A.first A.first(); (); if (FindSet FindSet(u) (u) != FindSet FindSet(v)) (v)) S = S {(u,v {(u,v)}; )}; Union( Union (u,v u,v); ); } } if (S.size S.size()== ()==V.size V.size() ()-1) Cuello de botella return S; else return No hay solucin; } // O(A log A)

// O(1) // // // // O(1) O(1) O(1) O(V) ???

del algoritmo
26

rboles generadores minimales Algoritmo de Kruskal


Representacin de conjuntos disjuntos union-find: find: Estructura de datos union Listas enlazadas de elementos con punteros hacia el conjunto al que pertenecen

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...

rboles generadores minimales Algoritmo de Kruskal


Representacin de conjuntos disjuntos union-find: find: Union(A,B) Estructura de datos union Cunto tardan en realizarse las n uniones? uniones? Anlisis del peor caso: O(n2)
Union(S1, S2) copia 1 elemento. Union(S Union(S Union (S2, S3) copia 2 elementos. Union(S Union (Sn-1, Sn) copia nn-1 elementos.

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

rboles generadores minimales Algoritmo de Kruskal


funcin Kruskal Kruskal( ( Grafo G(V,A) ) { S = ; Ordenar(A); // Orden creciente de pesos for (i=0; i< i<V.size V.size() ()-1; i++) MakeSet(V[i]); MakeSet (V[i]); while (!A.empty (!A.empty() () && S.size S.size()!= ()!=V.size V.size() ()-1) { (u,v u,v) ) = A.first A.first(); (); if (FindSet FindSet(u) (u) != FindSet FindSet(v)) (v)) S = S {(u,v {(u,v)}; )}; Union( Union (u,v u,v); ); } } if (S.size S.size()== ()==V.size V.size() ()-1) return S; else return No hay solucin; } // O(A log A)

// O(1) // // // // O(1) O(1) O(1) O(log V)

O(A log V)
29

rboles generadores minimales Algoritmo de Prim


Elementos del algoritmo de Prim Conjunto de candidatos: Vrtices del grafo. Funcin de seleccin: El vrtice u an no seleccionado que se conecte mediante la arista de menor peso a un vrtice v del conjunto de vrtices seleccionados. Funcin de factibilidad: El conjunto de aristas no contiene ningn ciclo. Criterio que define lo que es una solucin: nn-1 aristas. El conjunto de aristas (u,v (u,v) ) conecta todos los vrtices. Funcin objetivo: Suma de los costes de las aristas.
30

rboles generadores minimales Algoritmo de Prim

En cada iteracin, aadimos la arista de menor coste que aade un nuevo nodo a nuestro rbol S

31

rboles generadores minimales Algoritmo de Prim


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

32

rboles generadores minimales Algoritmo de Prim


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

33

rboles generadores minimales Algoritmo de Prim


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

34

rboles generadores minimales Algoritmo de Prim


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 8 9 7 12 3 4 7 10 5 5 6 11

35

rboles generadores minimales Algoritmo de Prim


12 5 6 4 8 9 7 3 4 7 10 5 5 6 11 4 5 6 3 4 7 6 5

36

rboles generadores minimales Algoritmo de Prim


Optimalidad del algoritmo de Prim Teorema: Teorema: Sean T un AGM de G=(V,A), S T un subrbol de T y (u,v) la arista de menor peso conectando los vrtices de S con los de VV-A. Entonces, Entonces, (u,v) T. Demostracin: Demostracin :
El teorema anterior se puede demostrar fcilmente si tenemos en cuenta que un AGM tiene subestructuras optimales optimales
37

rboles generadores minimales Algoritmo de Prim


Optimalidad del algoritmo de Prim Teorema: Sea T un AGM y ( Teorema: (u,v u,v) ) una arista de T. Si T1 y T2 son los dos rboles que se obtienen al eliminar la arista (u,v u,v) ) de T, entonces T1 es un AGM de G1=(V1,A1), y T2 es un AGM de G2 = (V2,A2) Demostracin: Demostracin :
Por reduccin al absurdo: absurdo: Si tenemos en cuenta que peso(T) = peso(u,v peso(u,v) ) + peso(T1) + peso(T2), no puede haber rboles generadores minimales mejores ptimo. . que T1 o T2, pues si los hubiese T no sera ptimo
38

rboles generadores minimales Algoritmo de Prim


Implementacin del algoritmo de Prim Clave: Seleccionar eficientemente la arista que se aadir al rbol generador minimal minimal. . Solucin: Utilizar una cola con prioridad en la que tengamos los vrtices asociados al menor coste de una arista que conecte cada vrtice con un vrtice que ya forme parte del AGM (infinito si no existiese dicha arista).
39

rboles generadores minimales Algoritmo de Prim


funcin Prim Prim( ( Grafo G(V,A) )
{

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
}

rboles generadores minimales Algoritmo de Prim


funcin Prim Prim( ( Grafo G(V,A) )
{

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
}

rboles generadores minimales Algoritmo de Prim


Eficiencia del algoritmo de Prim O(A log V + V log V) = O(A log V) ya que que, , en un grafo conexo conexo, ,V V-1 A V(VV(V-1)

42

Caminos mnimos

De la ETSIIT a la Facultad de Ciencias

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

Camino ms corto s-2-3-5-t


19

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

ds,u u du,w w dw,v v

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

Caminos mnimos Algoritmo de Dijkstra


funcin Dijkstra ( Grafo G(V,A), vrtice s )
{

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

Caminos mnimos Algoritmo de Dijkstra


funcin Dijkstra ( Grafo G(V,A), vrtice s )
{

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[] []
}

Caminos mnimos Algoritmo de Dijkstra


funcin Dijkstra ( Grafo G(V,A), vrtice s )
{

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

n logn V 1 n logn V log V logn V 1 1 1 A logA/D V A+V log V Anlisis amortizado


75

Heursticas greedy El problema del coloreo de un grafo

Holanda Blgica Alemania Francia Suiza Austria Andorra Italia Portugal Espaa

76

Heursticas greedy El problema del coloreo de un grafo


Problema: Dado un grafo G=(V,A), se pretende colorear cada vrtice de tal forma que dos vrtices adyacentes no tengan el mismo color. Objetivo: Minimizar el nmero de colores utilizados. Problema NP No existe existe ningn algoritmo eficiente que nos asegure haber utilizado un nmero mnimo de colores.
77

Heursticas greedy El problema del coloreo de un grafo


Teorema de Appel Appel-Hanke (1976): Un grafo plano requiere a lo sumo 4 colores para colorear sus nodos de forma que no haya vrtices adyacentes del mismo color.

Si el grafo no es plano plano, , puede requerir tantos colores como vrtices haya haya. .
78

Heursticas greedy El problema del coloreo de un grafo


Algoritmo greedy heurstico: O(V)
funcin Coloreo ( Grafo G(V,A) ) { i = 1; while (grafo no coloreado) { Elegir un color ci Colorear todos los vrtices que se pueda con ci a partir de un vrtice arbitrario (esto es, todos los vrtices que no sean adyacentes a un vrtice ya coloreado con ci) i = i + 1; } } 79

Heursticas greedy El problema del coloreo de un grafo


Algoritmo greedy heurstico: El orden en que se escojan los nodos es decisivo...
3 1 2 4 3 1 2 4
80

Solucin ptima

Solucin subptima

Heursticas greedy El problema del coloreo de un grafo


Aplicacin: Diseo de los semforos de un cruce
En un cruce de calles sealamos los sentidos de circulacin. Para minimizar el tiempo de espera, construimos un grafo cuyos vrtices representan turnos de circulacin y cuyas aristas unen los turnos que no pueden realizarse simultneamente sin que haya colisiones. El problema del cruce con semforos se convierte en un problema de coloreo de los vrtices de un grafo.

81

Heursticas greedy El problema del viajante de comercio


Problema: Dado un grafo G=(V,A), encontrar un camino que empiece en un vrtice v y acabe en ese mismo vrtice pasando una nica vez por todos los vrtices de V (es decir, un circuito hamiltoniano). hamiltoniano). Objetivo: Obtener el circuito hamiltoniano de coste mnimo. Problema NP No existe existe ningn algoritmo eficiente para resolver el problema del viajante de comercio.

82

Heursticas greedy El problema del viajante de comercio


Heurstica greedy 1: Nodos como candidatos Escoger, en cada momento, el vrtice ms cercano al ltimo nodo aadido al circuito (siempre que no se haya seleccionado previamente y que no cierre el camino antes de pasar por todos los vrtices). Heurstica greedy 2: Aristas como candidatas Como en el algoritmo de Kruskal, Kruskal, pero garantizando que al final se forme un circuito.

Eficiencia: La del algoritmo de ordenacin que se use.

83

Heursticas greedy El problema del viajante de comercio


Primera heurstica: Nodos como candidatos
1 35 50 2 45 1 35 50 5 40 25 10 3 55 30 15 20 4 1 35 50 5 45 2 40 25 10 3 55 30 15 20 4 5 2 45 40 25 10 3 55 30 15 20 4

Empezando en el nodo 1 Circuito (1,4,5,3,2) Solucin = 125

Empezando en el nodo 5 Circuito (5,4,3,2,1) Solucin = 140

84

Heursticas greedy El problema del viajante de comercio


Segunda heurstica: Aristas como candidatas
1 35 50 2 45 1 35 50 5 40 25 10 3 55 30 15 20 4 5 2 45 40 25 10 3 55 30 15 20 4

Circuito: (2,3), (4,5), (3,4), (1,2), (1,5) Solucin = 10 + 15 + 20 + 45 + 50 = 140


85