Programación Dinámica Dynamic Programming (DP)

Cátedra de Programación Avanzada - Ingeniería Informática

Departamento de Ingeniería e Investigaciones Tecnológicas

Programación DinámicaDynamic Programming (DP)

Introducción



¿Cuál es el resultado de la siguiente operación?

1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1

Introducción



¿Cuál es el resultado de la siguiente operación?

1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1

14

Introducción



¿Y de la siguiente?

1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1

Introducción



¿Y de la siguiente?

1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1

15

Introducción



¿Por qué lo resolvieron más rápido?

Introducción



¿Por qué lo resolvieron más rápido?

Rta: Porque no necesitaron recontar sino que

recordaron que el resultado anterior era 14 y solo le

tuvieron que sumar 1.

¡Esa es la clave de la Programación Dinámica!

Recordar cosas para ahorrar tiempo después.

Introducción



“Those who cannot remember the past

are condemned to repeat it.“

----

“Aquellos quienes no pueden recordar el pasado

están condenados a repetirlo.”

---

Ejemplo 1:Serie de Fibonacci



Fibonacci

fib(n) = 1; if n = 0

fib(n) = 1; if n = 1

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

Entonces, los primeros números de la serie serían:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...



Una posible solución podría ser utilizando recursividad:

public int fib (int n) {

if (n < 2)

return 1;

return fib(n-1) + fib(n-2);

}

Fibonacci: Solución recursiva




Para fib(6), se realizarán las siguientes ejecuciones:




Para fib(6), se realizarán las siguientes ejecuciones:

¡Se calcula 3 veces fib(3)!



Podemos ver que la solución recursiva, repite múltiples

veces los mismos cálculos.

¿Y qué pasa si el N es mayor? Por ejemplo N=1000(Copiar el código y probar ejecución)

Para N grandes, esta solución no responde en los

tiempos esperados.

¿Cómo podemos mejorarla?

Fibonacci: Solución Recursiva



Para evitar calcular múltiples veces lo mismo, podría ser

una buena alternativa almacenar cada valor de la serie

que ya calculamos, de manera que si necesitamos un

valor que ya hemos calculado previamente, obtenerlo en

O(1).

Solo calcularemos nuevos valores de la serie cuando

nunca antes lo hayamos hecho.

Fibonacci: Solución con P.D.



Para ello, podemos utilizar un array de Integer

suficientemente grande para almacenar el valor más

grande de la serie que podríamos llegar a necesitar.

Inicializamos nuestro array con los 2 primeros valores de

la serie que conocemos fibo[0]=1, fibo[1]=1. Las

posiciones aún no calculadas tendrán valor null.

Tener cuidado si se desea utilizar una lista, ya que la consulta y

modificación de valores en una posición no siempre es O(1) y

puede hacer que nuestra solución no sea buena.




Nuestra solución quedaría de la siguiente manera:

public int fib (int n) {

if (fibo[n] == null)

fibo[n] = fib(n-1) + fibo[n-2];

return fibo[n];

}




La solución con programación dinámica, es más óptima y

no recalcula múltiples veces los mismo valores.

Esta mejora, la obtenemos con el costo de un mayor

consumo de memoria para almacenar información que

nos puede ser útil en el futuro.

En este ejemplo, la información que guardamos para

utilizar programación dinámica es directamente la

información que necesitamos (los valores de la serie)

pero como ya veremos, no siempre tiene que ser así.


Programación Dinámica



Programación Dinámica: ¿Qué es?

Programación dinámica NO ES un algoritmo.

Programación dinámica NO ES una estructura de datos.

Programación dinámica ES una técnica matemática...

que podremos aplicar a problemas que cumplan

determinadas condiciones, con el objetivo de mejorar la

complejidad computacional de un algoritmo, utilizando

determinadas estructuras de datos para almacenar

información que nos sea de utilidad en el futuro.



Programación Dinámica: Definición

Es una técnica matemática orientada a la solución de

problemas con decisiones secuenciales (u) en etapas

sucesivas (k) donde se debe minimizar el coste total de

dichas decisiones.

En cada etapa se valora no sólo el coste actual de tomar una

decisión sino los costes futuros que se originan a partir de

ella.

Cada situación en que puede encontrarse el sistema en

cada etapa, se denomina estado (x), los cuales pueden ser

finitos o infinitos.



Programación Dinámica: Definición

Mediante una decisión (uk), se va de un estado al comienzo de

una etapa (Xk) a otro estado al comienzo de la siguiente(Xk+1) .

En cada etapa se evalúa la decisión óptima para cada uno de

sus estados Xk. Cada estado guarda toda la información

necesaria para tomar las decisiones futuras sin necesidad de

conocer cómo se ha alcanzado dicho estado.

Es un procedimiento recursivo que resuelve de manera

iterativa, incorporando cada vez una etapa, partes cada vez

mayores del problema original.



Principio de Optimalidad

Dado un estado, la política óptima para las siguientes etapas

no depende de la política tomada en las etapas anteriores.

La decisión óptima inmediata sólo depende del estado en el

que se está, no de cómo se llegó hasta él. Toda la información

sobre el pasado se resume en el estado en que se encuentra.

Una vez conocida la solución óptima global, cualquier

solución parcial que involucra sólo una parte de las etapas es

también una solución óptima.

Todo subconjunto de una solución óptima es a su vez una

solución óptima para un problema parcial.



Conclusión

Frecuentemente para resolver un problema complejo se

tiende a dividir este en subproblemas, más pequeños,

resolver estos últimos (recurriendo posiblemente a nuevas

subdivisiones) y combinar las soluciones obtenidas para

calcular la solución del problema inicial.

2 6 4 8 1 4 6 3 2 6 4 8 4 8 9 3

2 6 4 8 1 4 6 3

2 6 4 8

2 6

2 6 4 8 4 8 9 3

1 4 6 3 2 6 4 8 4 8 9 3

4 8 1 4 6 3 2 6 4 8 4 8 9 3

2 6 4 8 1 4 6 3 2 6 4 8 4 8 9 3



Conclusión

Puede ocurrir que la división natural del problema conduzca a un

gran número de subejemplares idénticos.

Si resolvemos cada uno de ellos sin tener en cuenta las posibles

repeticiones, resulta un algoritmo ineficiente; en cambio

resolvemos cada ejemplar distinto una sola vez y se conserva el

resultado, el algoritmo obtenido es mucho mejor.

2 6 4 8 1 4 6 3 2 6 4 8 4 8 6 3

2 6 4 8 1 4 6 3

2 6 4 8

2 6

2 6 4 8 4 8 6 3

1 4 6 3 2 6 4 8 4 8 6 3

4 8 1 4 6 3 2 6 4 8 4 8 6 3

2 6 4 8 1 4 6 3 2 6 4 8 4 8 6 3



Conclusión

Esta es la idea de la programación dinámica: no calcular

dos veces lo mismo y utilizar normalmente una tabla de

resultados que se va rellenando a medida que se

resuelven los subejemplares.

La programación dinámica es un método ascendente. Se

resuelven primero los subejemplares más pequeños y

por tanto más simples. Combinando las soluciones se

obtienen las soluciones de ejemplares sucesivamente

más grandes hasta llegar al ejemplar original.

Ejemplo 2:Suma de Subrectángulos



Suma de Subrectángulos

Dada la siguiente matriz, ¿Cuál es el subrectángulo cuya

sumatoria de elementos internos es máxima?

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3




Si sumamos toda la matriz, quizás no obtenemos el

mayor valor, ya que también tenemos valores negativos:

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3




Deberíamos considerar diferentes subrectángulos para

encontrar aquel cuya sumatoria es máxima:

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3

10

4

8

-13



Suma de Subrectángulos: Solución sin P. D.

Podemos probar todos los tamaños de subrectángulos, en cada posición de

la matriz, sumando todos los elementos internos, e ir guardando el mayor

resultado.

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3

1x1

2x1

1x2

2x2

...

...



Suma de Subrectángulos: Solución con P. D.

Para resolver este problema con programación dinámica, utilizaremos una

matriz auxiliar (PD) para almacenar cierta información “intermedia” que nos

ayudará a calcular rápidamente la sumatoria de subrectángulos.

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3



Suma de Subrectángulos: Cálculo de matriz PD

-5 -2 3

-2 -7 -12

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3

Matriz original Matriz P.D. (con sumatorias parciales)

-5 +3 +5 +3 -8 -10 = -12

En cada posición almacenamos la sumatoria desde M[0][0] hasta M[ i ][ j ]:



-5 -2 3 11

-2 -7 -12 -2

-1 2 0 4

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3


PD[i][j] = + PD[i-1][j] + PD[i][j-1] - PD[i-1][j-1] + M[i][j]PD[i][j] = + 0 + (-2) - (-12) + (-6) = 4

Cada celda, también podemos completarla ¡usando Programación Dinámica!




-5 -2 3 11 13 14 10

-2 -7 -12 -2 -2 4 4

-1 2 0 4 4 19 22

11 21 20 20 11 31 28

-4 14 1 7 1 11 11

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3


Al completar la matriz de P.D., tendremos el siguiente resultado:




-5 -2 3 11 13 14 10

-2 -7 -12 -2 -2 4 4

-1 2 0 4 4 19 22

11 21 20 20 11 31 28

-4 14 1 7 1 11 11

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3

M PD

¿Cómo nos ayudará nuestra matriz PD a resolver nuestro problema original?

Suma de Subrectángulos: Solución con P.D.



-5 -2 3 11 13 14 10

-2 -7 -12 -2 -2 4 4

-1 2 0 4 4 19 22

11 21 20 20 11 31 28

-4 14 1 7 1 11 11

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3

M PD

Supongamos que queremos saber la sumatoria interna de este subrectángulo

que va desde M[i][j] hasta M[f][c]


j c

i

f



-5 -2 3 11 13 14 10

-2 -7 -12 -2 -2 4 4

-1 2 0 4 4 19 22

11 21 20 20 11 31 28

-4 14 1 7 1 11 11

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3

M PD

Si tomamos PD[f][c], tenemos la sumatoria de todos los valores que queremos,

el problema es que también está sumando partes de M que no nos interesan.


PD[f][c] contiene la sumatoria desde M[0][0] hasta M[f][c]

j c

i

f



-5 -2 3 11 13 14 10

-2 -7 -12 -2 -2 4 4

-1 2 0 4 4 19 22

11 21 20 20 11 31 28

-4 14 1 7 1 11 11

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3

M PD

Pero si a esa sumatoria parcial, le restamos PD[f][j-1], estaríamos restando

todo un grupo de valores que no nos interesan.


PD[f][j-1] contiene la sumatoria desde M[0][0] hasta M[f][j-1]

j c

i

f



-5 -2 3 11 13 14 10

-2 -7 -12 -2 -2 4 4

-1 2 0 4 4 19 22

11 21 20 20 11 31 28

-4 14 1 7 1 11 11

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3

M PD

Y si luego restamos PD[i-1][c], estaríamos restando otra parte que no nos

sirve… el problema ahora es que restamos 2 veces una sección.


PD[i-1][c] contiene la sumatoria desde M[0][0] hasta M[i-1][c]

j c

i

f



-5 -2 3 11 13 14 10

-2 -7 -12 -2 -2 4 4

-1 2 0 4 4 19 22

11 21 20 20 11 31 28

-4 14 1 7 1 11 11

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3

M PD

Pero esa sección que restamos 2 veces, podemos compensarla volviendo a

sumarla con el acumulado en PD[i-1][j-1].


PD[i-1][j-1] contiene la sumatoria desde M[0][0] hasta M[i-1][j-1]

j c

i

f



-5 -2 3 11 13 14 10

-2 -7 -12 -2 -2 4 4

-1 2 0 4 4 19 22

11 21 20 20 11 31 28

-4 14 1 7 1 11 11

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3

M PD

Finalmente, si efectuamos este simple cálculo, podemos obtener la sumatoria

de únicamente los valores que nos interesaban ¡en O(1)!


j c

i

f

sumatoria = + PD[f][c] - PD[f][j-1] - PD[i-1][c] + PD[i-1][j-1]sumatoria = + 31 - 21 - 4 + (-7) = -1




Este cálculo, lo tenemos que realizar para cada tamaño de subrectángulo en

cada posición de la matriz (de estos pasos no escapamos).

La ventaja es que pudimos resolver sumatorias que son costosas en tiempo

constante (con un mayor costo de memoria).

-5 3 5 8 2 1 -4

3 -8 -10 2 -2 5 4

1 8 3 -6 0 9 3

12 7 1 -4 -9 5 -6

-15 8 -12 6 3 -10 3

1x1

2x1

1x2

2x2

...

...




En este ejemplo, la información que guardamos para

utilizar programación dinámica no es directamente el

resultado del problema o valores que necesitamos, sino

que almacenamos información intermedia que nos

simplifica y mejora un determinado proceso interno de

nuestro algoritmo.

Estos casos suelen ser más complejos de detectar y

requieren mayor práctica de la metodología, ya que no

son tan triviales como el ejemplo de Fibonacci.



Solución sin P.D. Solución con P.D.

Generación de matriz de P.D. ¿? ¿?

Generación de subrectángulos

(distintos tamaños) ¿? ¿?

Movimiento de subrectángulos

(por cada posición de M) ¿? ¿?

Cálculo de la sumatoria de los

elementos internos ¿? ¿?

Complejidad Computacional ¿? ¿?

Análisis de complejidad computacional de ambas soluciones:

Suma de Subrectángulos: Análisis C.C.




Generación de matriz de P.D. - O(N2)


(distintos tamaños) O(N2) O(N2)


(por cada posición de M) O(N2) O(N2)


elementos internos O(N2) O(1)















Pre-cálculo

Solución

+













Complejidad Computacional O(N6) O(N2) + O(N4)

Pre-cálculo

Solución

+













Complejidad Computacional O(N6) O(N4)

Pre-cálculo

Solución

+





Encontrar la subsecuencia de longitud máxima

Dudas

¿?

Documents

Programación Dinámica Dynamic Programming (DP)