PROGRAMACION PROGRAMACION DINAMICADINAMICA

A veces no hay forma de hacer D&C razonablemente, es A veces no hay forma de hacer D&C razonablemente, es decir, dividir un problema en un número pequeño de decir, dividir un problema en un número pequeño de subproblemas de aproximadamente el mismo tamaño. En subproblemas de aproximadamente el mismo tamaño. En tales casos, la aplicación reiterada de D&C puede dar tales casos, la aplicación reiterada de D&C puede dar lugar a un algoritmo de tiempo exponencial.lugar a un algoritmo de tiempo exponencial.

. . .

. . . . . . . . . . . .

...……......................

. . .

. . .

. . .

k n

k2

kn

O(nn) problemas “fáciles” (tamaño O(1))

Es bastante habitual el caso:

. . .

n

n-1 n-1

n-2 n-2

1 1 1 1 1 1

20=1

21=2

22=4

2n

. . .

. . .

Sin embargo, dentro de la cantidad exponencial de subproblemas, no es raro que solamente haya una cantidad polinomial de subproblemas diferentes y lo que en verdad ocurra es que se resuelva un mismo subproblema muchas veces

En consecuencia, si se memoriza de alguna forma las soluciones de estos subproblemas “repetidos”, se puede conseguir un algoritmo de tiempo polinomial

La forma clásica de implementar esta idea es llenando una tabla con las soluciones de estos subproblemas. En verdad, lo que generalmente se hace es guardar las soluciones de todos los subproblemas, sea que se usarán en el futuro o no.

La técnica de llenado de la tabla de soluciones se denomina programación dinámicaprogramación dinámica. La forma de una algoritmo de programación dinámica puede variar, pero el esquema general es siempre el mismo: una una tabla a llenar y un orden en el cual se cargan las solucionestabla a llenar y un orden en el cual se cargan las soluciones

Ejemplo: Sucesión de Fibonacci

fib(0) = 1 , fib(1) = 1

fib(n+2) = fib(n) + fib(n+1)

T(1) = 1

T(n) 2T(n-1) + c n 2

fib(3) = fib(2) + fib(1)= fib(1) + fib(0) + fib(1)

fib(4) = fib(3) + fib(2)= fib(2) + fib(1) + fib(1) + fib(0) = fib(1)+ fib(0) + fib(1) + fib(1) + fib(0)

Es claro que se computan repetidamente los mismos valores

function fib (var k:integer):integer array F [0..n] of integer

begin

F [0] := 1 ; F [1] := 1 ;

for i:= 2 to k do F [i]:=F [i-1] + F [i-2 ];

fib :=F [k]

end

Claramente, la función fib calcula el k-ésimo término de la sucesión en tiempo lineal.

La técnica utilizada para diseñar fib es programación dinámica.

Ejemplo más interesante: la “serie Ejemplo más interesante: la “serie mundial”mundial”

Se tienen dos equipos, Se tienen dos equipos, AA y y BB, que debe competir entre si. , que debe competir entre si. El ganador es el primero de ellos que gane El ganador es el primero de ellos que gane nn partidos, para partidos, para un un nn dado. No hay empate, es decir, en cada partido gana dado. No hay empate, es decir, en cada partido gana AA o gana o gana BB..

HipótesisHipótesis: : AA y y BB son igualmente competentes, de modo son igualmente competentes, de modo que cada uno tiene ½ de oportunidades de ganar que cada uno tiene ½ de oportunidades de ganar cualquier partidocualquier partido

Por ejemplo, si Por ejemplo, si nn=4 y A ganó 2 partidos y B ganó 1, =4 y A ganó 2 partidos y B ganó 1, entonces entonces ii=2 y =2 y jj=3;=3;

Cual es la probabilidad Cual es la probabilidad P(2,3)P(2,3) de que A sea campeón? de que A sea campeón?

Pensar durante 5 minutos antes de darse por vencido…Pensar durante 5 minutos antes de darse por vencido…

ProblemaProblema: Calcular la probabilidad : Calcular la probabilidad P(i,j)P(i,j) de que el de que el campeón sea A, supuesto que A necesita ganar campeón sea A, supuesto que A necesita ganar ii partidos para ser el ganador, y B necesita ganar partidos para ser el ganador, y B necesita ganar jj partidos.partidos.

Puede razonarse del siguiente modo:

P(2,3) es la probabilidad de que ocurra alguno de los siguientes eventos:

<A,A>, <A,B,A>, <B,A,A>, <A,B,B,A>, <B,A,B,A>, <B,B,A,A>

Considerando que la probabilidad de que gane cualquiera de los dos es ½ , tenemos:

P(2,3)= ¼ + 1/8 + 1/8 + 1/16 + 1/16 + 1/16 = 11/16

Para obtener una expresión recursiva para P(i,j) se puede plantear una ecuación en recurrencias sobre dos variables:

i) Si i = 0 y j > 0, P(i,j) =1 ( A ya es campeón)

Si i > 0 y j = 0, P(i,j) =0 (B ya es campeón)

ii) Si i,j > 0, entonces se debe jugar al menos un partido más, y puesto que ambos equipos son igualmente competentes resulta:

P(i,j) = (P(i-1,j) + P(i, j-1))/2

Ahora bien, si se utiliza este algoritmo para calcular P(i,j), se obtiene un tiempo de ejecución T(n) de la siguiente forma (utilizando n=i+j):

T(1) = c

T(n) = 2 T(n-1) + d

Esta ecuación puede resolverse expandiendo las recurrencias:

T(n) = 2T(n-1) + d = 2(2T(n-2) + d) + d = 4T(n-2) + 3d =

= 4(2T(n-3) + d)+3d = 8T(n-3) + 7d= ……….

En general, T(n) = 2i T(n-i) + (2i -1) d

Para i=n-1, se obtiene : T(n) = 2n-1c + (2n-1 -1)d

Así, T(n) es O(2n) = O(2i+j)

Es fácil ver que lo que ocurre en la computación de P(i,j) es que se computan muchas veces los mismos valores.

Ejemplo:

P(2,3)= ½((P(1,3)+P(2,2)) = ½( ½ (P(0,3)+P(1,2)) + ½ (P(1,2) + P(2,1))) =

= ½ ( ½ (1 + ½ ( P(0,2) + P(1,1) ) + ½ ( ½ (P(0,2) + P(1,1)) + ½(P1,1)+P(2,0)))) =

= ½ ( ½ + ¼ ( 1 + ½ (P(0,1) + P(1,0)) + ¼( ½ + ½ (P(0,1) +……..)….)

Un forma más eficiente para calcular P(i,j) es llenar una tabla como la siguiente:

½ 21/32 13/16 15/16 1 4

1/32 ½ 11/16 7/8 1 3

3/16 5/16 ½ 3/4 1 2

1/16 1/8 ¼ ½ 1 1

0 0 0 0 0

4 3 2 1 0

i

j

La forma de llenar la tabla es muy simple, procediendo en diagonales que representan las posiciones de valor constante i+j

function apuestas (i,j: integer) : real;

var s,k :integer;

begin

for s := 1 to i+j do begin

{ calcular la diagonal de las posiciones cuyos índices suman s }

P[0,s] := 1.0; P[s,0] := 0.0;

for k:= 1 to s-1 do

P[k,s-k] := (P[k-1,s-k] + P[k,s-k-1])/2

end

return (P[i,j])

end;

Resulta evidente que este algoritmo es O(n2).

GREEDYGREEDY

IdeaIdea : Un problema puede verse como una búsqueda : Un problema puede verse como una búsqueda en un “espacio de soluciones” o en un “espacio de en un “espacio de soluciones” o en un “espacio de estados”. Una estrategia “greedy” está basada en la estados”. Una estrategia “greedy” está basada en la idea de que, en cada paso de dicha búsqueda, idea de que, en cada paso de dicha búsqueda, seleccionar una solución (o aproximación) parcial seleccionar una solución (o aproximación) parcial “localmente óptima” llevará a una solución globalmente “localmente óptima” llevará a una solución globalmente óptima.óptima.

o bien, dicho de otro modo,o bien, dicho de otro modo,

Una política óptima esta necesariamente compuesta por Una política óptima esta necesariamente compuesta por sub-políticas localmente óptimas.sub-políticas localmente óptimas.

Este punto de vista funciona bien en muchas ocasiones, pero veremos que no necesariamente siempre.

Ejemplo: El problema de dar el cambio

Se trata de “dar cambio” de cierta suma de dinero, con la restricción que la cantidad de monedas utilizada para hacerlo debe ser mínima.

Supongamos que se cuenta con monedas de 25, 10, 5 y 1 centavos. Si se tiene que dar cambio de 63 centavos, el método más obvio y natural dará la siguiente solución: <25, 25, 10, 1, 1, 1>

Esta secuencia es efectivamente la óptima (en el sentido anterior, es la secuencia de longitud mínima).

El algoritmo utilizado es “dar siempre la moneda de mayor valor posible que no supere el total que resta por cambiar”.

El algoritmo es greedy pues en cada paso elige la solución “localmente óptima”, es decir, la que hace decrecer más rápidamente lo que resta.

Sin embargo, el éxito del algoritmo en este caso depende de particulares propiedades de las monedas involucradas. Si en cambio tuviésemos monedas de 1, 5 y 11 centavos, y tuviéramos que dar cambio de 15, el método anterior daría <11, 1, 1, 1 ,1>, sin embargo con <5,5,5> tenemos una lista más corta.

Algoritmos greedy “famosos”Algoritmos greedy “famosos”

• Algoritmo de DijkstraAlgoritmo de Dijkstra para hallar los caminos para hallar los caminos mínimos en un digrafo: es greedy pues en cada paso mínimos en un digrafo: es greedy pues en cada paso elige el vértice aún no considerado más cercano al elige el vértice aún no considerado más cercano al origen.origen.

• Algoritmo de KruskalAlgoritmo de Kruskal para hallar el minimum para hallar el minimum spanning tree de un grafo no orientado: es greedy pues spanning tree de un grafo no orientado: es greedy pues en cada paso elige una arista más corta que no forma en cada paso elige una arista más corta que no forma ciclo con los vértices ya seleccionados.ciclo con los vértices ya seleccionados.

• Sin embargo, no siempre tener una política greedy da Sin embargo, no siempre tener una política greedy da buenos resultados. Por ejemplo, si permitimos aristas buenos resultados. Por ejemplo, si permitimos aristas con costos negativos el algoritmo de Dijkstra falla.con costos negativos el algoritmo de Dijkstra falla.

Algoritmos greedy como heurísitcasAlgoritmos greedy como heurísitcas

Idea: Abordar problemas “difíciles” en los que hallar una solución exacta u óptma es extremadamente costoso. En tales casos, puede resultar mejor encontrar una solución aproximada sencilla y eficiente.

Caso interesante, Problemas NP-completos: clase de problemas para los cuales todas las soluciones exactas conocidas requieren inspeccionar exhaustivamente todo el espacio de soluciones (es decir, requieren tiempo exponencial). Sorprendentemente, nadie aún pudo demostrar que no existan soluciones eficientes (polinómicas) para estos problemas.

En muchos casos es posible utilizar la estrategia greedy para obtener soluciones aproximadas eficientes para esta clase de problemas.

Ejemplo: El problema del Agente Viajero (PAV)Ejemplo: El problema del Agente Viajero (PAV)

Formulación Intuitiva: Un viajante de comercio debe recorrer una serie de ciudades y volver a la de partida recorriendo la menor distancia posible, es decir, sin pasar dos veces por ninguna de ellas. Se supone que hay caminos entre cada par de ciudades.

Formulación matemática: Dado un grafo completo con costos positivos asociados a sus aristas, encontrar un tour (ciclo simple que incluya a todos sus vértices) de costo mínimo (es decir, la suma de los costos de sus aristas es el menor posible).

0; 0

1; 7

4; 3

15; 4

18; 0

15; 7

0

1

2

3

4

5

6

7

8

0 5 10 15 20

EJEMPLO: PROBLEMA DEL AGENTE VIAJERO EJEMPLO: PROBLEMA DEL AGENTE VIAJERO CON 6 CIUDADESCON 6 CIUDADES

c

b

a

d

e

f

CUATRO SOLUCIONESCUATRO SOLUCIONES

(a) Costo = 50 (b) Costo = 49.73

(c) Costo = 48.39 (d) Costo = 49.78

Algoritmo greedy para el PAVAlgoritmo greedy para el PAV

La solución propuesta es una variante del algoritmo de Kruskal:

Sobre la base de elegir en cada paso la arista de costo mínimo, se imponen las dos siguientes restricciones como criterio de aceptación para el PAV:

1. No haga que un vértice tenga grado 3 o mayor

2. No forme ciclo con las aristas ya seleccionadas, excepto que el número de aristas sea igual al número de vértices.

Aplicando este algoritmo se obtiene la solución consistente del recorrido (a), cuyo costo es 50, el peor de los cuatro presentados, pero solamente un 4% peor que el óptimo que es el indicado por (c).