MST: dos algoritmos glotonesalram/analisis_algo/clase11.pdf · • Algoritmo de Kruskal. •...

MST: dos algoritmos glotonescomp-420

Tuesday, September 24, 13

Dos algoritmos glotones para MST

• Algoritmo de Kruskal.

• Algoritmo de Prim.

• Ambos pueden ejecutarse en un tiempo O(E log V) utilizando montículos binarios.

• Ambos algoritmos son glotones o greedy.

• En cada paso el algoritmo toma la mejor opción en ese momento.

• Generalmente esta estratégia no garantiza encontrar una solución globalmente óptima al problema.

• En el caso de los MST estos algoritmos glotones si nos llevan al árbol con menor costo.


Minimum Spanning Tree• Si todos los pesos w de las aristas del grafo son diferentes, el MST

es único. Prueba:


Repaso: montículos binarios• Binary heaps• Árbol binario casi completo (excepto el último nivel)• Se representa con un arreglo A con dos atributos:

• length• heap-size

• Hay dos clases de montículo binario: max-heap y min-heap.• El max-heap debe mantener la propiedad: El valor de cada nodo i debe ser

a lo más, el valor de su padre (el elemento más grande es la raíz. • Para min-heap el valor más chico es el de la raíz.

16

14 10

8 7 9 3

2 4 1

1

2 3

4 5 6 7

8 9 10

3 2 11014 78 4916

7 8 1032 54 961


Dos algoritmos glotones para MST

• Ambos algoritmos utilizan una regla específica para encontrar aristas seguras (línea 3 del algoritmo genérico).

• En el Algoritmo de Kruskal, el conjunto A es un bosque.

• La arista segura que se agrega siempre es la arista con menor peso que conecta dos componentes distintas.

• En el Algorimo de Prim el conjunto A es un sólo árbol.

• La arista segura que se agrega es siempre aquella con menor peso que conecte el árbol a un vértice que todavía no esté en el MST.


Alonso Ramírez Manzanares Computación y Algoritmos 29.01.2013

Recordatorio, manejo de conjuntos:Ejemplo 2 : Problema de conectividad (1)

• Nos dan una secuencia de pares de enteros, donde cada entero representa un objeto de algún tipo y tenemos que interpretar el par p-q como “p está conectado con q”.

• Relación transitiva: Si “p está conectado con q” y “q está con r”, entonces “p está conectado con r”.

• La meta es escribir un programa que filtre los pares externos al conjunto (guardar solo las nuevas conexiones mínimas): Para un par entrada p-q, la salida deberá ser el par solo si los pares revisados hasta entonces no implican que p está conectado a q. Si los pares visitados implican que p esta conectado a q, se debe ignorar el par p-q y continuaremos al siguiente par.

4



Recordatorio, manejo de conjuntos:Ejemplo 2 : Problema de conectividad (2)

par entrada salida conexión

3-4 3-4

4-9 4-9

8-0 8-0

2-3 2-3

5-6 5-6

2-9 2-3-4-9

5-9 5-9

7-3 7-3

4-8 4-8

5-6 5-6

0-2 0-8-4-3-2

6-1 6-1

6

Ojo, la salida nunca tendrá mas de N-1

pares

Dados N nodos de índices 0

a N-1



Recordatorio, manejo de conjuntos:Ejemplo 2: Problema de conectividad (5)

• Operaciones fundamentales para un algoritmo de conectividad (útiles para resolver tareas similares sobre la misma estructura del grafo)

• al tener un par nuevo: determinar si representa una nueva conexión.

• Si es asi, incorporar la información que la conexión ha sido encontrada y actualizar la estructura del grafo.

• Operaciones:

• Encontrar el conjunto que contiene un elemento particular.

• Reemplazar los conjuntos que contienen dos elementos dados por su unión.

• el problema de conectividad puede resolverse realizando estas dos operaciones. Cada conjunto se conoce como componentes conectados.

9



Recordatorio, manejo de conjuntos:Problema de conectividad: algoritmo quick-union

15

#include <iostream>using namespace std;

static const int N = 10000;

int main(){! int i, j, p, q, id[N];! for (i=0; i<N; i++)

! ! id[i] = i;! while ( cin >> p >> q ){

for (i=p; i!=id[i]; i=id[i]); // find for (j=q; j!=id[j]; j=id[j]); if(i==j) continue; id[i]=j; // quick union cout << “ << p << “ ” << q << endl;}

}

• algoritmo basado en un arreglo indexado por el nombre del objeto.• cada objeto apunta a otro objeto del mismo componente conectado, en una estructura que no tiene ciclos. • para determinar si dos objetos están en el mismo componente (conjunto), hay que seguir los apuntadores hasta llegar al que apunte a si mismo.




p q 0 1 2 3 4 5 6 7 8 9

3 4 0 1 2 4 4 5 6 7 8 9

4 9 0 1 2 4 9 5 6 7 8 9

8 0 0 1 2 4 9 5 6 7 0 9

2 3 0 1 9 4 9 5 6 7 0 9

5 6 0 1 9 4 9 6 6 7 0 9

2 9 0 1 9 4 9 6 6 7 0 9

5 9 0 1 9 4 9 6 9 7 0 9

7 3 0 1 9 4 9 6 9 9 0 9

4 8 0 1 9 4 9 6 9 9 0 0

5 6 0 1 9 4 9 6 9 9 0 0

0 2 0 1 9 4 9 6 9 9 0 0

6 1 1 1 9 4 9 6 9 9 0 0

5 8 1 1 9 4 9 6 9 9 0 0

16



Recordatorio, manejo de conjuntos:Problema de conectividad: quick-union

p q

3 4

4 9

8 0

2 3

5 6

2 9

5 9

7 3

4 8

5 6

0 2

6 1

0 1 2 4 5 6 7 8 9

3

0 1 2 9 5 6 7 8

3

4

01 2 9 5 6 7

8

3

4

1 5 6 7

3

4

0

8

9

2

1

5

6

7

3

4

0

82

9

1

5

6 7

3

4

0

82

9

1

5

6 7

3

4

0

82

9

1

5

6 7

3

4

0

82

9




• quick-union no tiene que recorrer el arreglo completo para cada par de entrada.

• haciendo estudios empíricos y análisis matemáticos (próxima clase) se puede determinar que el algoritmo quick-union es más eficiente que el algoritmo quick-find.

• para M>N+1, el algoritmo quick-union puede tomar más de MN/2 instrucciones para resolver un problema de conectividad con M pares de entrada y N objetos, NOTA: no son los mismos M y N de la vez pasada.

• aún así no se puede garantizar que esto ocurra para cualquier par de entradas, ya que la operación find puede ser lenta.

18


Alonso Ramirez Manzanares Computación y Algoritmos 29.01.2013

Recordatorio, manejo de conjuntos:Problema de conectividad: quick-union pesado

Utiliza un vector adicional donde se

cuenta cual árbol es mayor, y siempre

conecta el menor al mayor.

La versión pesada sigue a lo mas lg N apuntadores para

determinar si 2 de N objetos están conectados

0 1 2 3 4 5 6 7 8 9



Recordatorio, manejo de conjuntos:Codigo de quick-union pesado

#include <iostream>using namespace std;static const int N = 10000;int main(){! int i, j, p, q, id[N], sz[N];! for (i=0; i<N; i++) {! ! id[i] = i; sz[i] = 1; // 2 inicializaciones ! }! while ( cin >> p >> q ){

for (i=p; i!=id[i]; i=id[i]); // find for (j=q; j!=id[j]; j=id[j]); if(i==j) continue; if(sz[i] < sz[j]){ id[i]=j; sz[j]+= sz[i];// quick union + peso } else{ id[j]=i; sz[i]+= sz[j];// quick union + peso

} cout << “ << p << “ ” << q << endl;}

}



Recordatorio, manejo de conjuntos: ¿la complejidad de quick union pesado es?

• M*lg(N), para M pares que llegan con N nodos a investigar.

• De esta forma, agregando un poco de código, tenemos un algoritmo que es mucho mas eficiente.


MST: Algoritmo de Kruskal

• Descubierto por Kruskal en 1956.

• Encuentra una arista segura para agregar al bosque A encontrando entre todas las aristas que conecten dos árboles cualquiera en el bosque, la arista (u,v) con menor costo.

• Sean C1 y C2 dos árboles conectados por (u,v). Como (u,v) deben ser aristas ligeras conectando C1 a otro árbol, sabemos que es una arista segura para C1.

• El algoritmo de Kruskal es glotón porque en cada paso agregamos al bosque A la arista ligera con el menor costo posible.



MST-Kruskal(G, w)

1 A ! "2 for each vertex v # V [G]3 do Make-Set(v)4 sort the edges of E into nondecreasing order by weight w5 for each edge (u, v) # E, taken in nondecreasing order by weight6 do if Find-Set(u) $= Find-Set(v)7 then A ! A % {(u, v)}8 Union(u, v)9 return A



a

b

h

c d

g f

i e

1

2

2

8 10

14

9

78

4

67

11

4

Aristas procesadas

Colección de conjuntos disjuntos: AColección de conjuntos disjuntos: AColección de conjuntos disjuntos: AColección de conjuntos disjuntos: AColección de conjuntos disjuntos: AColección de conjuntos disjuntos: AColección de conjuntos disjuntos: AColección de conjuntos disjuntos: AColección de conjuntos disjuntos: A

aristas iniciales

{h,g}

{i,c}

…

{d,f}

{a} {b} {c} {d} {e} {f} {g} {h} {i}

{a} {b} {c} {d} {e} {f} {g,h}{g,h} {i}

{a} {b} {c,i}{c,i} {d} {e} {f} {g,h}{g,h}

… … … … … … … … …

{a,b,c,d,e,f,g,h,i}{a,b,c,d,e,f,g,h,i}{a,b,c,d,e,f,g,h,i}{a,b,c,d,e,f,g,h,i}{a,b,c,d,e,f,g,h,i}{a,b,c,d,e,f,g,h,i}{a,b,c,d,e,f,g,h,i}{a,b,c,d,e,f,g,h,i}{a,b,c,d,e,f,g,h,i}

arista costo

{h,g} 1

{i,c} 2

{g,f} 2

{a,b} 4

{c,f} 4

{i,g} 6

{c,d} 7

{h,i} 7

{a,h} 8

{b,c} 8

{d,e} 9

{f,e} 10

{b,h} 11

{d,f} 14


ejemplo


Kruskal: tiempo de ejecución• Depende de la implementación elegida para conjuntos disjuntos.

• Suponemos representación por árboles con heurísticas.

• Inicializar en la línea 1 toma:

• O(1)

• Ordenar las aristas en la línea 4 toma:

• O(E log E)

• El cíclo for de las líneas 5 a 8 realiza O(E) operaciones FIND-SET y UNION en bósques disjuntos.

• Junto con las V operaciones MAKE-SET de las líneas 2 a 3 esto toma un tiempo de O((V+E)α(V)).

• Como G está conectado, tenemos E≥V-1 y las operaciones de conjuntos disjuntos toman O(Eα(V)).


Kruskal: tiempo de ejecución

• Ya que α(V) = O(log V) = O(log E), el tiempo de cálculo total del algoritmo de

Kruskal es de O(E log E).

• Observando que E ≤ V2, tenemos log E = O(log V) que nos permite reescribir el tiempo de ejecución total como:

• O(E log V).


MST: dos algoritmos glotonescomp-420


MST: Algoritmo de Prim (Jarník)

• Es otro caso especial del algoritmo genérico para encontrar MST.

• Las aristas de A siempre forman un solo árbol.

• El algoritmo empieza de un vértice arbitrario r y el árbol crece hasta que conecta a todos los vértices en V.

• En cada paso se agrega una arista ligera al árbol A que conecta a A a un vértice aislado de GA = (V,A).

• Cuando el algoritmo termina, A es un árbol generador mínimo.

• Esta es una estratégia greedy ya que el árbol crece en cada paso con una arista que contribuye lo mínimo posible al costo total del árbol.


MST: Algoritmo de Prim

MST-Prim(G, w, r)

1 for each u ! V [G]2 do key[u] " #3 ![u] " NIL4 key[r] " 05 Q " V [G]6 while Q $= %7 do u " Extract-Min(Q)8 for each v ! Adj[u]9 do if v ! Q and w(u, v) < key[v]10 then ![v] " u11 key[v] " w(u, v)



• Mientras se ejecuta el algoritmo los vértices que no están en el árbol viven en una cola de prioridad min Q respecto a su campo key.

• Para cada vértice v, key[v] es el peso mínimo de cualquier arista que conecte a v con un vértice en el árbol. Por convención key[v] = ∞ si no existe tal arista.

• El campo π[v] se refiere al padre de v en el árbol.

• Durante la ejecución del algoritmo el conjunto A se mantiene implícitamente como:

• Cuando el algoritmo termina, la cola de prioridad min Q está vacía y

A = {(v, ![v]) : v ! V " {r}" Q}.

A = {(v, ![v]) : v ! V " {r}}.



a

b

h

c d

g f

i e

1

2

2

8 10

14

9

78

4

67

11

4


Ejemplo


Caminos más cortos en gráficascomp-420


Caminos más cortos en gráficas

• Dado un grafo con peso y dirigido G = (V, E) con una función de peso w : E→R que

transforma aristas a valores reales de peso.

• El peso del camino p=<v0, v1, ..., vk> es la suma de los pesos de los ejes que lo constituyen.

w(p) =k!

i=1

w(vi!1, vi)

November 14, 2005 Copyright © 2001-5 by Erik D. Demaine and Charles E. Leiserson L17.3

Paths in graphs

Consider a digraph G = (V, E) with edge-weight function w : E ! R. The weight of path p = v1 !

v2 !!! vk is defined to be

"#

$

%$1

11),()(

k

iii vvwpw .

v1v1

v2v2

v3v3

v4v4

v5v54 –2 –5 1

Example:

w(p) = –2



• Un camino más corto de u a v es un camino de peso mínimo de u a v.

• El peso del camino más corto de u a v se define como:

!(u, v) =

!

min{w(p) : up

! v} si hay un camino de u a v,! en cualquier otro caso.

• Un camino más corto de u a v se define como cualquier camino p con peso:

w(p) = !(u, v)



• ¿Qué interpretación puede darse al peso de las aristas?

• distancia,

• tiempo,

• costo,

• penalidad,

• pérdida,

• cualquier cantidad que se acumule linealmente a lo largo del camino y que se quiera minimizar.

• El algoritmo BFS es un algoritmo que encuentra el camino más corto en gráficas sin peso (con peso unitario). Es la base para los algoritmos para gráficas con peso.



• Nos enfocaremos a encontrar el camino más corto a partir de una sola fuente:

• Dada una gráfica G = (V, E), ¿cómo ir de un vértice fuente s∈V a cáda vértice v∈V?

• ¿Qué otros problemas se podrían resolver?

• camino más corto a un solo destino (a partir de todos los vértices).

• camino más corto entre un solo par de vértices.

• camino más corto entre todos los pares de vértices de una gráfica (hay métodos más eficientes para resolver este problema).


Subestructura óptima

• Un subcamino de un camino más corto (óptimo) entre dos vértices es un camino más corto.

• Cortando y pegando ...

• Esta propiedad de subestructura óptima...¿de qué tipo de algoritmos es característica?

• Algoritmo de Dijkstra: algoritmo glotón.

• Algoritmo de Floyd-Warshall: programación dinámica.

November 14, 2005 Copyright © 2001-5 by Erik D. Demaine and Charles E. Leiserson L17.7

Optimal substructure

Theorem. A subpath of a shortest path is a shortest path.

Proof. Cut and paste:


Gráficas con aristas de peso negativo

< s, a >, !(s, a) = w(s, a) = 3

< s, b >, !(s, b) = w(s, a) + w(a, b) = 3 + (!4) = !1

< s, c >, < s, c, d, c >, < s, c, d, c, d, c > . . . w < c, d, c >= 6 + (!3) = 3 > 0

< s, c >, !(s, c) = w(s, c) = 5

< s, d >, !(s, d) = w(s, c) + w(c, d) = 11

< s, e >, < s, e, f, e >, < s, e, f, e, f, e > . . . w(e, f, e) = 3 + (!6) = !3 < 0< s, e >= !(s, e) = !"

0

3

-∞

-1

-∞

-∞5 11

∞ ∞

∞

s

a b

c d

e f

g

h i

j

3

-4

4

86

-3

5

2

-6

37

-83

2


MST: dos algoritmos glotonesalram/analisis_algo/clase11.pdf · • Algoritmo de Kruskal. •...

Documents

Transcript of MST: dos algoritmos glotonesalram/analisis_algo/clase11.pdf · • Algoritmo de Kruskal. •...