Apuntes de Terico de Programacin 3

Apuntes de Terico PROGRAMACIN 3

Greedy

Versin 1.1

Apuntes de Terico de Programacin 3

ndice
ndice .............................................................................................................................. 2 Introduccin .................................................................................................................... 3 Ejemplo 1 (problema de las monedas) ......................................................................... 3 Ejemplo 2 (problema de la mochila) ............................................................................ 4 Aplicaciones del mtodo Greedy a grafos ........................................................................ 7 rboles de cubrimiento................................................................................................ 7 Prim......................................................................................................................... 9 Kruskal .................................................................................................................. 12 Caminos de mnimo costo de un vrtice a todos los dems vrtices ............................ 15

Apuntes de Terico de Programacin 3

Introduccin
Los algoritmos diseados utilizando la mtodo Greedy son generalmente utilizados para resolver problemas de optimizacin, es decir, problemas en los cuales se tiene un conjunto de candidatos, de los cuales se debe elegir un subconjunto que satisfaga una cierta condicin de optimalidad y eventualmente condiciones de factibilidad. El mtodo Greedy consiste en analizar el conjunto de candidatos y tomar, en cada etapa una decisin ptima (elegir el mejor candidato). Esta decisin es tomada localmente, o sea sin tener en cuenta las decisiones de etapas pasadas o de etapas futuras. De acuerdo a lo anterior se puede resumir que el mtodo Greedy trabaja en etapas y en cada etapa se toma una decisin localmente ptima, de manera de generar la solucin ptima al problema. Claramente el hecho de generar la solucin ptima a partir de una sucesin de decisiones localmente ptimas en varias etapas, no es vlido para cualquier problema ni aun para instancias del mismo problema.

Ejemplo 1 (problema de las monedas)

Dada una cantidad de dinero y un conjunto de monedas de distintos valores, cambiar a monedas el dinero utilizando la mnima cantidad de monedas. Se plantea el siguiente algoritmo para resolver el problema:
mientras dinero > 0 hacer sea i la moneda de mayor valor que cumple valor(i) <= dinero entonces k := dinero div valor(i) dinero = dinero - k * valor(i)

Se puede observar que es un algoritmo basado en el mtodo Greedy, trabaja por etapas y toma en cada una de ellas la decisin localmente ptima: tomar tantas veces como sea posible la moneda de mayor valor. A continuacin se ver que sucede para distintas instancias del problema: a) Dinero = 10 Monedas con valores 3 y 2 No se puede resolver con el algoritmo planteado, aunque existe una solucin al problema.

Apuntes de Terico de Programacin 3 b) Dinero = 15 Monedas con valores 11, 5 y 1 El resultado que se obtiene usando el algoritmo planteado: 1 moneda de 11 4 monedas de 1 Por lo tanto aunque el algoritmo halla una solucin al problema, sta no es ptima dado que la solucin ptima est dada por 3 monedas de 5. c) Dinero = 15 Monedas con valores 10, 5 y 1 El resultado que se obtiene usando el algoritmo planteado: 1 moneda de 10 1 moneda de 5 Lo cual constituye la solucin ptima. Como conclusin puede decirse que este problema no es resoluble por el mtodo Greedy, dado que hallar la solucin ptima tomando la moneda de mayor valor (decisin localmente ptima) en cada etapa conduce a la solucin ptima dependiendo del valor de las monedas.

Ejemplo 2 (problema de la mochila)

Dados una mochila de capacidad M y n objetos, tal que cada objeto i ocupa una capacidad wi en la mochila y produce una ganancia pi al incluirlo en la misma, determinar las fracciones de los objetos xi, 0 xi 1, 0 i n-1, tal que la ganancia obtenida sea mxima. Formalmente el problema se plantea de la siguiente manera: solucin: < x0 ,..., x n1 > maximizar
n 1 i =0

px
i i =0 i i

n 1

(1) (2) (3)

sujeto a

w x

con 0 x i 1 y 0 i n 1

Una solucin a este problema ser cualquier n-upla <x0, , xn-1> que satisfaga las condiciones (2) y (3), esto es una n-upla factible. La solucin ptima es la solucin factible que maximiza la condicin (1). 4

Apuntes de Terico de Programacin 3

Si se considera la siguiente instancia del problema de la mochila:

n=3 M = 20 ( P0 , P1 , P2 ) = (25,24,15) ( w0 , w1 , w2 ) = (18,15,10) hay 4 soluciones (n-uplas factibles): x0 1 2 3 4 1 0 1/2 0 x1 2/15 2/3 1/3 1 x2 0 1 1/4 1/2

w x
i

px
i

20 20 16.5 20

28.2 31 24.25 31.5

De las cuales, la ltima es la solucin ptima. Si la suma total de capacidades que ocupan los objetos es menor o igual que M claramente la tupla xi=1 0 i n-1 es la solucin ptima. Si la suma total de capacidades que ocupan los objetos es mayor que M, no todos los xi pueden ser 1. Si se considera la siguiente estrategia: Tomar en cada etapa el objeto, no incluido an en la mochila, con mayor ganancia. Si este objeto no entra entero en la mochila, se toma una fraccin de l llenando la mochila. Suponiendo que se llega a la siguiente situacin al utilizar la estrategia anterior: Capacidad restante en la mochila: 2 Objeto i-simo Pi = 4 Objeto j-simo Pj = 3 wi = 4 wj = 2

Se puede observar que es mejor llevar el objeto j-simo entero que llevar la mitad del objeto i-simo. Por lo tanto la estrategia anterior solo conduce a la solucin ptima si los objetos entran enteros en la mochila. Esta estrategia siempre conduce a una solucin, pero no asegura que sta sea la solucin ptima. Si se considera la siguiente estrategia: Balancear la ganancia segn la capacidad, o sea incluir en cada etapa aquel objeto, no incluido an en la mochila, con mayor ganancia por unidad de capacidad (Pi / wi)
5

Apuntes de Terico de Programacin 3 Para poder aplicar esta estrategia se supondr que los objetos vienen dados en orden decreciente de Pi / wi. Se puede demostrar que utilizando esta estrategia se obtiene una solucin ptima al problema en todos los casos. El algoritmo que resuelve el problema haciendo uso de esta estrategia es el siguiente:
void KnapSock (float M, int n, float *solucion, float *W) { int i; float capacidad; for(i = 0; i < n; i++) solucion[i] = 0; capacidad = M; i = 0; while ((i < n) && (W[i] <= capacidad)) { solucion[i] = 1; capacidad = capacidad - W[i]; i++; } if (i < n) solucion[i] = capacidad / W[i]; }

Volviendo al ejemplo anterior: n=3 M = 20 ( P0 , P1 , P2 ) = (25,24,15)

( w10 , w1 , w2 ) = (18,15,10) P0 25 = w0 18 P1 8 = w1 5 P2 3 = w2 2

el orden en que se consideran los objetos es: 8 3 25 ( x1 , x 2 , x 0 ) = , , 5 2 18

Inicialmente:
W = (15, 10, 18) M = 20;

Solucin ptima: solucion = (1,1/2,0) se obtiene la 4 solucin de la tabla.

Apuntes de Terico de Programacin 3

Aplicaciones del mtodo Greedy a grafos rboles de cubrimiento

Sea G=(V,E) un grafo no dirigido conexo, un rbol de cubrimiento es un grafo G=(V,E), donde E es un subconjunto de E y tal que G es un rbol, o sea un grafo conexo y sin ciclos. Para el siguiente grafo:

algunos de los rboles de cubrimiento del grafo son :

Apuntes de Terico de Programacin 3

Si se asocia a cada arista del grafo un costo, o sea se define una funcin c:ER y se define el costo del rbol como C = c(e) e E ' , el problema de hallar el rbol de cubrimiento de costo mnimo (ACCM) puede verse como un problema de optimizacin. Por ejemplo dado el grafo:
16 1 21 19 11 6 33 5 18 6 2 5

14 4

10

Uno de los rboles de cubrimiento de costo mnimo es el siguiente:

16 1 11 6 6 2 5

5 18

Para hallar un ACCM se usar la siguiente propiedad: Propiedad MST (Minimum Spanning Tree): Sea G = (V, E) un grafo conexo con una funcin de costo definido sobre las aristas. Sea U un subconjunto de los vrtices V, si (u, v) es una arista de costo mnimo tal que u U y v V U entonces existe un rbol de cubrimiento de costo mnimo que incluye a (u, v) como una de sus aristas. Demostracin: Para demostrar la propiedad se supondr por absurdo que no existe ningn rbol de cubrimiento de costo mnimo para el grafo G que incluya la arista (u, v) entre sus aristas.

Apuntes de Terico de Programacin 3 Sea entonces, T cualquier rbol de cubrimiento de costo mnimo para G. Si se agrega la arista (u, v) a T, se genera un ciclo (recordar que T es un rbol y por lo tanto existe un camino de u a v). Debe existir otra arista (u, v) tal que u ' U y v' V U , y que forme parte del camino de u a v. Si se quita la arista (u, v) se rompe el ciclo y se tiene un rbol de cubrimiento T en el cual se cumple:

Costo (T ' ) = Costo (T ) c(u ' , v' ) + c (u , v) Y como (u, v) es de costo mnimo (entre las aristas que tienen un extremo en U y el otro en V-U) c(u, v) c (u ' , v' ) Costo (T ' ) Costo (T ) lo cual contradice la hiptesis de que no existe ningn rbol de cubrimiento de costo mnimo que incluya la arista (u, v).

Para resolver el problema de hallar el ACCM se vern dos algoritmos que se basan en la propiedad MST. Notar que la propiedad indica una estrategia a seguir, la cual es: elegir la arista de mnimo costo entre dos conjuntos de vrtices no conectados entre s.
Prim

La idea de este algoritmo es construir el ACCM a partir de un vrtice arbitrario y en cada paso tener un nico rbol que va creciendo al agregarse aristas. Esto significa que si en un paso cualquiera del algoritmo se tiene un rbol T formado por el conjunto de vrtices U, se agrega la arista < i, j > / i U , j V U y c(< i, j >) = min{ c (< k , l >) / < k , l > E , k U , l V U } (notar que de esta forma no se generan ciclos). El algoritmo finaliza cuando U = V. Y se puede observar la aplicacin directa de la propiedad MST. A continuacin se ver un ejemplo de cmo funciona el algoritmo de Prim.

Apuntes de Terico de Programacin 3 Sea el grafo:

10 1 2

50 45 30 35 40 3

4 20 55

15

25

El algoritmo comienza desde un vrtice arbitrario, por ejemplo el 1. Las aristas que cumplen que uno de sus vrtices est en el rbol y el otro no son: <1,2>, <1,5> y <1,4> cuyos costos son 10, 45 y 30 respectivamente. Se agrega al rbol la arista de mnimo costo de las anteriormente mencionadas, o sea la arista <1,2> y se repite el proceso. Las aristas que cumplen que uno de sus vrtices est en el rbol y el otro no son: <1,5>, <1,4>, <2,5>, <2,3> y <2,6> cuyos costos son 45, 30, 40, 50 y 25 respectivamente. Por lo tanto en este paso se elige la arista <2,6> y el rbol resultante es el siguiente:
10 1 2

25

10

Apuntes de Terico de Programacin 3 Luego se sigue repitiendo el proceso y se van eligiendo sucesivamente las aristas: <3,6>, <6,4> y <3,5>. Una vez finalizado el algoritmo el ACCM queda de la siguiente manera:
10 1 2

3 35

4 20

15

25

Seudocdigo del algoritmo:

Prim (Grafo G, Grafo &arbol) { ListaVertices U; arbol = CrearGrafo(); U = CrearLista(); Agregar(U,1); mientras (U != V) sea <u,v> la arista de costo minimo / u in U y v in V-U AgregarArista(arbol,<u,v>); Agregar(U,v); fin mientras }

11

Apuntes de Terico de Programacin 3

Kruskal

El algoritmo de Kruskal se diferencia del algoritmo de Prim dado que en vez de mantener un solo rbol en todo momento, puede tener varios, es decir un bosque. Inicialmente se considera el bosque formado por todos los vrtices del grafo G (sin aristas) y en cada paso se trata de unir rboles, para lo cual se consideran las aristas en orden creciente de costos. Si una arista tiene sus extremos en el mismo rbol es descartada porque generara un ciclo. Ejemplo:
10 1 2

50 45 30 35 40 3

4 20 55

15

25

Las aristas ordenadas por costo son: <1,2> <3,6> <4,6> <2,6> <1,4> <3,5> <2,5> <1,5> <2,3> <5,6> 10 15 20 25 30 35 40 45 50 55

12

Apuntes de Terico de Programacin 3 Inicialmente se tiene la siguiente situacin:

1 2

En el primer paso se considera la arista <1,2> por ser la de menor costo y adems no generar un ciclo. En los siguientes pasos se agregan las aristas <3,6>, <4,6> y <2,6> generando la siguiente situacin:
10 1 2

4 20

15

25

La siguiente arista a considerar es la <1,4>, la cual no es incluida porque genera un ciclo. A continuacin se agrega la arista <3,5> que es la siguiente en la lista y el algoritmo finaliza su ejecucin ya que cualquier otra arista generara un ciclo si es agregada.

13

Apuntes de Terico de Programacin 3 Seudocdigo del algoritmo:

kruskal (Grafo G, Grafo &arbol) { ListaAristas E; arbol = CrearGrafo(); E = OrdenarAristas(G); mientras (arbol tiene menos de n-1 aristas) && (!Vacio(E)) sea e in E una arista de minimo costo Borrar(E,e); si e no crea un ciclo en arbol entonces AgregarArista(arbol,e); fin mientras }

14

Apuntes de Terico de Programacin 3

Caminos de mnimo costo de un vrtice a todos los dems vrtices

Otra aplicacin del mtodo Greedy a grafos es encontrar los caminos de mnimo costo de un vrtice a todos los dems vrtices de un grafo. En trminos de grafos el problema se puede plantear de la siguiente forma: Dado un grafo G = (V,E) dirigido o no, con una funcin c de costo asociado ( c : E R + {0} ) a las aristas de G, el problema consiste en determinar los caminos de mnimo costo desde un vrtice a todos los otros vrtices del grafo. Para resolver este problema se utiliza un algoritmo Greedy conocido con el nombre de Dijkstra. Este algoritmo trabaja manteniendo un conjunto S de vrtices cuyo camino de mnimo costo desde el vrtice orgen ya se conoce (inicialmente este conjunto S solo contiene el vrtice origen). En cada paso se agrega a S un nuevo vrtice tal que el camino desde el vrtice origen a dicho vrtice es el de menor costo posible de los caminos que restan hallar. El algoritmo termina cuando S contiene todos los vrtices del grafo. Si se asume que las aristas no tienen costos negativos, siempre se puede encontrar un camino desde el vrtice origen a un vrtice de V-S que solo pasa por vrtices de S y talque es el camino de menor costo de los caminos que quedan por hallar. Esto es porque si hubiera en V-S algn vrtice w por el cual es de menor costo acceder a w, por la forma de construir S, w ya debera estar en S. Para implementar este algoritmo se necesita: Una matriz Cnxn / C[i, j ] es el costo de ir desde el vrtice i al vrtice j si existe la arista <i, j>, sino C[i, j ] = Un arreglo D1xn que contenga el costo del camino de mnimo costo del origen a cada vrtice. Para el seudocdigo del algoritmo se asume que los vrtices estn numerados de 1 a n.

15

Apuntes de Terico de Programacin 3

Procedure Dijkstra (int origen) S = {origen}; Para (i in 1..n) D[i] = C[origen][i] Para (i in 1..n-1) elegir un vertice w in V-S / D[w] sea minimo S = S {w}; Para (v in V-S) D[v] = minimo{D[v], D[w]+C[w][v]}

Fin Fin Fin A continuacin se ver como funciona el algoritmo de Dijkstra en el siguiente grafo:
100 1 10 30 10 2 60 5

50 3 20 4

C:
1 2 3 4 5

2 10

3 50 20

4 30

5 100 10 60

S = {1} La primer iteracin inicializa el arreglo D D:

10

30

100

El camino de menor costo a un vrtice de V-S es al vrtice 2. Se agrega el vrtice 2 a S y se actualiza D: S = {1,2} D:

10

60

30

100 16

Apuntes de Terico de Programacin 3

El camino de menor costo a un vrtice de V-S es al vrtice 4. Se agrega el vrtice 4 a S y se actualiza D: S = {1,2,4} D:

10

50

30

90

El camino de menor costo a un vrtice de V-S es al vrtice 3. Se agrega el vrtice 3 a S y se actualiza D: S = {1,2,4,3} D:

10

50

30

60

El camino de menor costo a un vrtice de V-S es al vrtice 5. Se agrega el vrtice 5 a S y se actualiza D: S = {1,2,4,3,5} D:

10

50

30

60

El algoritmo de Dijkstra es O(n2), siendo n la cantidad de vrtices, porque se realiza n-2 veces encontrar el mnimo de D (operacin de orden n). Si se quiere construir el camino de menor costo del origen a todos los dems vrtices del grafo, se puede utilizar otro arreglo P de vrtices / P[v] contiene el vrtice anterior en el camino de menor costo. El arreglo P se inicializa con el vrtice origen y el algoritmo se modifica de la siguiente manera.
Procedure Dijkstra (int origen) S = {origen}; Para (i in 1..n) D[i] = C[origen][i] P[i] := origen Fin Para (i in 1..n-1) elegir un vertice w in V-S / D[w] sea minimo S = S {w}; Para (v in V-S) si (D[w]+C[w][v] < D[v]) entonces D[v] := D[w]+C[w][v]; P[v] := w;

Fin Fin Fin 17

Apuntes de Terico de Programacin 3 Los sucesivos valores que van tomando los elementos del arreglo P son: P: P: P: P: P: 1 1 1 1 1 1 1 1 1 1 1 2 4 4 4 1 1 1 1 1 1 1 4 3 3

Luego es posible encontrar los vrtices del camino de mnimo costo en una recorrida hacia atrs del arreglo P. Por ejemplo para hallar el camino desde el origen al vrtice 5 se hace: P[5] = 3 P[3] = 4 P[4] = 1 indica que hay arista con el origen y el camino es 1 4 3 5 Si el grafo tiene aristas de costo negativo el algoritmo de Dijkstra no encuentra los caminos de mnimo costo, como se observa en el siguiente grafo:
b 2 1 s a -2

3 c

Sea s el vrtice origen. El algoritmo de Dijkstra elige el vrtice a en el primer paso (el costo del camino de s a a es 1), luego elige el vrtice b cuyo camino desde s es de costo 3 y por ltimo elige el vrtice c. Sin embargo el haber elegido el vrtice b antes que el vrtice c fue una decisin errnea ya que de esta manera el camino encontrado (s a b) desde s hasta b es de costo 3, mientras que si se hubiera elegido primero el vrtice c y luego el vrtice b, el camino desde s hasta b es de costo 2 (s a c b) y por lo tanto menor.

18