Programación dinámica 1

Introduccion Algoritmo 1 Algoritmo 2 Algoritmo 3 Referencias

Programacion Dinamica

Noh Noh Jose Alberto - Osorio Cab Mario Jesus - Yam Uicab ReyesEduardo

Universidad Autonoma de YucatanFacultad de Matematicas

Unidad Multidisciplinaria Tizimin


¿Que es la programacion dinamica?

La programacion dinamica, al igual que el metodo de divide yvenceras, resuelve problemas mediante la combinacion de las solucionesa subproblemas,los algoritmos divide y venceras dividen el problema ensubproblemas disjuntos, se resuelven los subproblemas de formarecursiva, y luego se combinan sus soluciones para resolver el problemaoriginal.

La programacion dinamica se aplica cuando los subproblemas sesuperponen, es decir, cuando subproblemas proporcionansubsubproblemas. En este contexto, un algoritmo de divide y vencerashace mas trabajo de lo necesario, resolviendo repetidamente lossubsubproblemas comunes.

Un algoritmo de programacion dinamica resuelve cada subsubproblemasolo una vez y luego guarda su respuesta en una tabla, evitando de estemodo el trabajo de recalcular la respuesta cada vez que resuelve cadasubsubproblema.













Cuando se desarrolla un algoritmo de programacion dinamica,seguimos una secuencia de cuatro pasos:

1. Caracterizar la estructura de una solucion optima.

2. definen recursivamente el valor de una solucion optima.

3. Calcular el valor de una solucion optima, tıpicamente en forma deabajo hacia arriba.

4. Construir una solucion optima de informacion computarizada.

En las secciones se siguientes utilizara el metodo de programaciondinamica para resolver algunos problemas de optimizacion.

1.- Examina el problema de cortar una varilla en varillas de menorlongitud en forma que maximice su valor total.

2.- Preguntar como podemos multiplicar una cadena de matricesmientras se realiza el menor numero de multiplicaciones escalarestotales.

3.- Se realizara la optimizacion de la suma de subconjuntos, agregandouna variable.




































































Algoritmo 1

Algoritmo 1

Rod Cutting(Corte de Varilla)


Descripcion del problema

Dada una variila de longitud N pulgadas y una tabla de precios pi parai = 1, 2, .., n. Determinar el ingreso maximo rn, obtenible de cortar lavarilla y la venta de la piezas.

Podria darse el caso de que no sea necesario cortar la varilla paraobtener el maximo ingreso posible

longitud i 1 2 3 4 5 6 7 8 9 10

costo pi 1 5 8 9 10 17 17 20 24 30

Ejemplo de tabla de precios





longitud i 1 2 3 4 5 6 7 8 9 10

costo pi 1 5 8 9 10 17 17 20 24 30






longitud i 1 2 3 4 5 6 7 8 9 10

costo pi 1 5 8 9 10 17 17 20 24 30



Ejemplo n=4

Podemos cortar una varilla de longitud n en 2n−1 formas diferentes, yaque tenemos una opcion independiente de cortar o no cortar, a unadistancia i pulgadas del extremo izquierdo, para i = 1, 2, ...., n− 1 .

Denotamos una descomposicion en piezas con corriente notacion deaditivo, de modo que 7 = 2 + 2 + 3 indica que una varilla de longitud 7se corta en tres piezas y dos de longitud 2 y uno de longitud 3


Ejemplo n=4




Ejemplo n=4




Generalizando un poco

Si una solucion optima corta la varilla en k piezas, por alguna1 ≤ k ≤ n, entonces una descomposicion optima n = i1 + i2 + · · ·· +ik

de la varilla en piezas de longitudes i1, i2, ik proporciona la maximaingresos correspondientes rn = pi1 + pi2 + · · ·· + pik .

r1 = 1 de la solucion 1 = 1 (sin cortes);r2 = 5 de la solucion 2 = 2 (sin cortes);r3 = 8 de la solucion 3 = 3 (sin cortes);r4 = 10 de la solucion 4 = 2 + 2;r5 = 13 de la solucion 5 = 2 + 3;r6 = 17 de la solucion 6 = 6 (sin cortes);r7 = 18 de la solucion 7 = 1 + 6 o 7 = 2 + 2 + 3;r8 = 22 de la solucion 8 = 2 + 6;r9 = 25 de la solucion 9 = 3 + 6;r10 = 30 de la solucion 10 = 10 (sin cortes).













De manera mas general, podemos enmarcar los valores rn para n > 1en terminos de ingresos optimos de mimbres mas cortos:

rn = max(pn, r1 + rn−1, r2 + rn−2, ..., rn−1 + r1) (1)



De manera mas general, podemos enmarcar los valores rn para n > 1en terminos de ingresos optimos de mimbres mas cortos:

rn = max(pn, r1 + rn−1, r2 + rn−2, ..., rn−1 + r1) (1)



El primer argumento, pn, corresponde cuando no hay cortes y la ventade la varilla de longitud n.

El otro argumento n− 1 al corresponde al maximo de los ingresosobtenidos al hacer un corte inicial de la varilla en dos piezas de tamanoi y n− i, para cada i = 1, 2, ...., n− 1, y luego optimamente cortar lasotras piezas, la obtencion de ingresos rn y rn−i de esas dos piezas.



El primer argumento, pn, corresponde cuando no hay cortes y la ventade la varilla de longitud n.

El otro argumento n− 1 al corresponde al maximo de los ingresosobtenidos al hacer un corte inicial de la varilla en dos piezas de tamanoi y n− i, para cada i = 1, 2, ...., n− 1, y luego optimamente cortar lasotras piezas, la obtencion de ingresos rn y rn−i de esas dos piezas.



Tengase en cuenta que para resolver el problema original de tamano n,resolvemos problemas mas pequenos de del mismo tipo, pero detamanos mas pequenos.

Una vez que hacemos el primer corte, podemos considerar las dospiezas como instancias independientes del problema de barra de corte.

La solucion optima global incorpora soluciones optimas a los dossubproblemas relacionados, maximizar los ingresos de cada una de esasdos piezas.













De manera relacionada, pero un poco mas sencillo, para organizar unaestructura recursiva para el problema rod-cutting, consideramos unadescomposicion que consiste en una primera pieza de longitud i cortarel extremo de la izquierda, y luego un resto de la parte derecha delongitud ni.

Solo el resto, y no a la primera pieza, se pueden dividir aun mas.Podemos ver cada descomposicion de una barra de longitud n de estamanera: como una primera pieza seguido por alguna descomposiciondel resto.

Al hacerlo, podemos encontrar la solucion sin cortes en absoluto quedecir que la primera pieza tiene un tamano de i = n y ingresos pn yque el resto tiene tamano 0 con r0 = 0 ingresos correspondientes .Ası se obtiene la siguiente version mas simple de ecuacion (1):

rn = max16i6n

(pi + rn−i) (2)






rn = max16i6n

(pi + rn−i) (2)






rn = max16i6n

(pi + rn−i) (2)


Implementacion recursiva Top-Down(arriba hacia abajo)

El siguiente procedimiento implementa el calculo implıcita en laecuacion (2) en un sencillo, de arriba hacia abajo, de manera recursiva.

CUT-ROD(p, n)1 if n==02 return 03 q=−∞4 for i=1 to n5 q = max(q, p[i] + CUT −ROD(p, n− i))6 return q



El siguiente procedimiento implementa el calculo implıcita en laecuacion (2) en un sencillo, de arriba hacia abajo, de manera recursiva.

CUT-ROD(p, n)1 if n==02 return 03 q=−∞4 for i=1 to n5 q = max(q, p[i] + CUT −ROD(p, n− i))6 return q



¿Por que CUT −ROD es ineficiente? El problema es que CUT −RODse auto llama recursivamente una y otra vez con los mismos valores delos parametros; resuelve el mismo subproblema repetidamente.

T (n) = 1 +∑n−1j=0 T

( .j)

T (n) = 2n

Por lo que el tiempo de ejecucion de CUT-ROD es exponencial en n.




T (n) = 1 +∑n−1j=0 T

( .j)

T (n) = 2n





T (n) = 1 +∑n−1j=0 T

( .j)

T (n) = 2n



Ejemplo n=4

Resuelve el mismo subproblema repetidamente


Mejorar el algoritmo usando Programacion Dinamica

Se busca minimizar el tiempo de ejecucion, a un tiempo polinomial.

Existen dos enfoques:

1.- de arriba hacia abajo con memorizacion (top-down withmemorization)

2.- metodo de abajo hacia arriba (bottom-up method)














De arriba hacia abajo con memorizacion

MEMOIZED-CUT-ROD(p, n)1 let r[0..n] be a new array2 for i=0 to n3 r[i] =−∞4 return MEMOIZED-CUT-ROD-AUX(p, n, r)

MEMOIZED-CUT-ROD-AUX(p, n, r)1 if r[n] ≥ 02 return r[n]3 if n == 04 q=05 else q=−∞6 for i=1 to n7 q= max(q, p[i] + MEMOIZED-CUT-ROD-AUX(p,n-i, r))8 r[n] = q9 return q



MEMOIZED-CUT-ROD(p, n)1 let r[0..n] be a new array2 for i=0 to n3 r[i] =−∞4 return MEMOIZED-CUT-ROD-AUX(p, n, r)

MEMOIZED-CUT-ROD-AUX(p, n, r)1 if r[n] ≥ 02 return r[n]3 if n == 04 q=05 else q=−∞6 for i=1 to n7 q= max(q, p[i] + MEMOIZED-CUT-ROD-AUX(p,n-i, r))8 r[n] = q9 return q



En este caso, el procedimiento principal MEMOIZED-CUT-RODinicializa un nuevo arreglo auxiliar r[0...n] con el valor −∞ , unaopcion practica para denotar ”desconocido”. (Valores de ingresosconocidos son siempre no negativo). Se llama a su rutina de ayuda,MEMOIZED-CUT-ROD-AUX.

El procedimiento MEMOIZED-CUT-ROD-AUX es solo la versionmemorizada de nuestro procedimiento anterior, CUT-ROD. En primerlugar en la lınea 1 comprueba si el valor deseado ya se conoce y, si loes, la lınea 2 devuelve el valor.

De lo contrario, las lıneas 3-7 calculan el valor q deseado de la manerahabitual, la lınea 8 guarda en r[n], y la lınea 9 la devuelve.












De abajo hacia arriba

La version de abajo hacia arriba es aun mas simple:

BOTTOM-UP-CUT-ROD(p, n)1 let r[0..n] be a new array2 r[0] = 03 for j = 1 to n4 q=−∞5 for i=1 to j6 q= max(q, p[i] + r[j - i])7 r[j] = q8 return r[n]



La version de abajo hacia arriba es aun mas simple:

BOTTOM-UP-CUT-ROD(p, n)1 let r[0..n] be a new array2 r[0] = 03 for j = 1 to n4 q=−∞5 for i=1 to j6 q= max(q, p[i] + r[j - i])7 r[j] = q8 return r[n]



Para el enfoque dinamico de programacion de abajo hacia arriba,BOTTOM-UP-CUT-ROD utiliza el orden natural de los subproblemas:un problema de tamano i es ”mas pequeno”que un subproblema detamano j si i < j.

Por lo tanto, el procedimiento resuelve subproblemas de tamanosj = 0, 1, ..., n, en ese orden.

La lınea 1 del procedimiento BOTTOM-UP-CUT-ROD crea una nuevamatriz r[0...n] en la que guarda los resultados de los subproblemas, y lalınea 2 inicializa r[0] a 0, ya que una varilla de longitud 0 no obtieneingresos.

La lıneas 3-6 resuelve cada subproblema de tamano j, paraj = 1, 2, ..., n, con el fin de aumentar el tamano.

El enfoque utilizado para resolver un problema de un tamanoparticular, j es el mismo que el utilizado por CUT-ROD, excepto que lalınea 6 hace referencia ahora directamente entrada de la matriz r[j − i]en lugar de hacer una llamada recursiva para resolver el subproblemade tamano j − i.

La lınea 7 guarda en r[j] la solucion al subproblema de tamano j.Finalmente, la lınea 8 retorna r[n], que es igual a la rn valor optimo.










































Graficamente

El enfoque de abajo hacia arriba, resuelve lossubproblemas mas pequenos primero paraque cuando uno mas grande los necesite, yaesten resueltos y solo obtenerlos.Los dos enfoques logran un tiempo deejecucion polinomial

t(n) = O(n2)


Reconstruccion de una solucion

Podemos extender el enfoque de programacion dinamica para registrarno solo el valor optimo calculado para cada subproblema, sino tambienuna eleccion que llevo al valor optimo. Con esta informacion, podemosimprimir facilmente una solucion optima.

EXTENDED-BOTTOM-UP-CUT-ROD(p, n)1 let r[0..n] and s[0..n] be a new array2 r[0] = 03 for j = 1 to n4 q=−∞5 for i=1 to j6 if q < p[i] + r[j − i]7 q = p[i] + r[j - i]8 s[j] = i7 r[j] = q8 return r and s



Podemos extender el enfoque de programacion dinamica para registrarno solo el valor optimo calculado para cada subproblema, sino tambienuna eleccion que llevo al valor optimo. Con esta informacion, podemosimprimir facilmente una solucion optima.

EXTENDED-BOTTOM-UP-CUT-ROD(p, n)1 let r[0..n] and s[0..n] be a new array2 r[0] = 03 for j = 1 to n4 q=−∞5 for i=1 to j6 if q < p[i] + r[j − i]7 q = p[i] + r[j - i]8 s[j] = i7 r[j] = q8 return r and s



El siguiente procedimiento toma una tabla de precios p y un tamano dela barra n, y llama a EXTENDED-BOTTOM-UP-CUT-ROD paracalcular la matriz s[1...n] de tamanos optimos de la primera pieza yluego imprime la lista completa de los tamanos de la pieza en unadescomposicion optima de una varilla de longitud n:

PRINT-CUT-ROD-SOLUTION(p, n)1 (r, s) = EXTENDED-BOTTOM-UP-CUT-ROD(p, n)2 while n > 03 print s[n]4 n = n -s[n]

En nuestro ejemplo de corte de barra, la llamada aEXTENED-BOTTOM-UP-CUT-ROD(p, 10) devolvera la siguientematriz:

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

r[i] 0 1 5 8 10 13 17 18 22 25 30

s[i] 0 1 2 3 2 2 6 1 2 3 10

Una llamada a PRINT-CUT-ROD-SOLUTION(p, 10) imprimirıa solo10, pero una llamada con n = 7 imprimirıa los cortes 1 y 6,correspondiente a la primera descomposicion optima para r7 dadoanteriormente.






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

r[i] 0 1 5 8 10 13 17 18 22 25 30

s[i] 0 1 2 3 2 2 6 1 2 3 10







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

r[i] 0 1 5 8 10 13 17 18 22 25 30

s[i] 0 1 2 3 2 2 6 1 2 3 10







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

r[i] 0 1 5 8 10 13 17 18 22 25 30

s[i] 0 1 2 3 2 2 6 1 2 3 10







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

r[i] 0 1 5 8 10 13 17 18 22 25 30

s[i] 0 1 2 3 2 2 6 1 2 3 10



Algoritmo 2

Algoritmo 2

Matrix-chain multiplication (Multiplicacion de matrices en cadena



El siguiente ejemplo de programacion dinamica es un algoritmo queresuelve el problema de la multiplicacion de matrices de cadena. Se nosda una secuencia (cadena) (A1, A2, ..., An) de n matrices demultiplicarse, y deseamos calcular el producto.

A1A2 · · · ·An

Se puede evaluar la expresion anterior utilizando algun algo ritmoestandar para multiplicar pares de matrices, y despues resolver lasambiguedades que seria como multiplicar entre si las matrices.



El siguiente ejemplo de programacion dinamica es un algoritmo queresuelve el problema de la multiplicacion de matrices de cadena. Se nosda una secuencia (cadena) (A1, A2, ..., An) de n matrices demultiplicarse, y deseamos calcular el producto.

A1A2 · · · ·An

Se puede evaluar la expresion anterior utilizando algun algo ritmoestandar para multiplicar pares de matrices, y despues resolver lasambiguedades que seria como multiplicar entre si las matrices.



Un producto de matrices esta totalmente entre parentesis ya sea unasola matriz o el producto de dos productos de matrices entreparentesis, rodeado por parentesis.Por ejemplo, si la cadena de matrices es (A1, A2, A3, A4), entoncespodemos representar el producto A1A2A3A4 de 5 maneras:

(A1(A2(A3A4))),(A1((A2A3)A4)),((A1A2)(A3A4)),((A1(A2A3))A4),(((A1A2)A3)A4),

Es importante tener en cuenta el costo de la multiplicacion de dosmatrices, el algoritmo estandar se presenta en el siguiente algoritmo,los atributos rows and columns son el numero de filas y columnas deuna matriz













MATRIX-MULTIPLY(A, B)1 if A.columns 6= B.rows2 error ıncompatible dimensions”3 else let C be a new A.rows x B.columns matrix4 for i = 1 to A.rows5 for j = 1 to B.columns6 cij = 07 for k= 1 to A.columns8 cij = cij + aik · bkj9 return C

Podemos multiplicar dos matrices A y B solo si son compatibles: elnumero de columnas de A debe ser igual al numero de filas de B.

vamos a expresar los costos en terminos del numero de multiplicacionesescalares












Ejemplo

Considera la siguiente cadena de tres matrices A1, A2, A3

Supon que las dimensiones de A1 son 10x100Supon que las dimensiones de A2 son 100x5Supon que las dimensiones de A3 son 5x50

((A1A2)A3) = 7500 multiplicaciones(A1(A2A3)) = 75000 multiplicaciones


Ejemplo

Considera la siguiente cadena de tres matrices A1, A2, A3

Supon que las dimensiones de A1 son 10x100Supon que las dimensiones de A2 son 100x5Supon que las dimensiones de A3 son 5x50

((A1A2)A3) = 7500 multiplicaciones(A1(A2A3)) = 75000 multiplicaciones


Ejemplo

Notamos que el problema de multiplicacion de cadena de matrices esde la siguiente manera:dada una cadena (A1, A2, ..., An) de n matrices, donde i = 1, 2, .., n, yla matriz Ai tiene dimension pi−1 x pi, Con parentesis completos parael producto A1A2 · ·An .Una manera que minimiza el numero demultiplicaciones escalares.

Tenga en cuenta que en el problema de la multiplicacion de matrices decadena, no estamos realmente multiplicando matrices.Nuestro objetivo es solo para determinar un orden para lamultiplicacion de matrices que tiene el costo mas bajo.


Ejemplo

Notamos que el problema de multiplicacion de cadena de matrices esde la siguiente manera:dada una cadena (A1, A2, ..., An) de n matrices, donde i = 1, 2, .., n, yla matriz Ai tiene dimension pi−1 x pi, Con parentesis completos parael producto A1A2 · ·An .Una manera que minimiza el numero demultiplicaciones escalares.

Tenga en cuenta que en el problema de la multiplicacion de matrices decadena, no estamos realmente multiplicando matrices.Nuestro objetivo es solo para determinar un orden para lamultiplicacion de matrices que tiene el costo mas bajo.


Contar el numero de parentesis

Antes de resolver el problema, se comprobaran todas las formas deparentesis, para demostrar que no se produce un algoritmo eficiente.

Se denota numero de parentesis de una secuencia de matrices con P(n),por lo que cuando n=1, se tiene solo una matriz y solo una forma deparentesis, n ≥ 2, sera un prducto totalmente entre parentesis , y ladivision entre los dos subproductos puede producirse entre la k-esima y(k + 1) matrices para cualquier k = 1, 2, ..., n− 1. por lo que se obtienela siguiente recurrencia:

p(n) =

1 si n = 1∑n−1

k=1 P (k)P (n− k) si n ≥ 2(3)





p(n) =

1 si n = 1∑n−1

k=1 P (k)P (n− k) si n ≥ 2(3)





p(n) =

1 si n = 1∑n−1

k=1 P (k)P (n− k) si n ≥ 2(3)



La recurrencia (3), es de Ω(2n), El numero de soluciones es exponencialde n, y el metodo brute-force de busqueda exhaustiva es una malaestrategia para determinar la manera optima de parentesis de unamatriz en cadena.


La aplicacion de programacion dinamica


2. definir recursivamente el valor de una solucion optima.

3. Calcular el valor de una solucion optima.





















Paso 1: La estructura de un parentizacion optima

Para mayor comodidad, adoptemos la notacion Ai..j , donde i ≤ j, parala matriz que resulta de la evaluacion del producto AiAi+1 · ·Aj .

Supongamos que poner entre parentesis optimos a AiAi+1 · · ·Aj ,dividimos el producto entre AkyAk+1.

Entonces la forma en que un parentesis el ”prefijo”subcadenaAiAi+1 · · ·Ak dentro de este parentizacion optimo de AiAi+1 · · ·Ajdebe ser un parentizacion optimo de AiAi+1 · · ·Ak.













Ahora se usara la subestructura optima para demostrar que podemosconstruir una solucion optima al problema desde las soluciones optimasde subproblemas.

Podemos construir una solucion optima para un caso del problema demultiplicacion de matrices en cadena separando el problema en dossubproblemas (optimamente parentizados AiAi+1 · · ·Ak yAk+1Ak+2 · · ·Aj), la busqueda de soluciones optimas al caso de unsubproblema , y luego la combinacion de estas soluciones optimas delsubproblema.

Se debe asegurar de que cuando se busca el lugar correcto para dividirel producto, hemos considerado todos los lugares posibles, por lo queestamos seguros de haber examinado la optima.












Paso 2: Una solucion recursiva

Sea m[i, j] es el numero mınimo de multiplicaciones escalaresnecesarios para calcular la matriz Ai..j ; para el problema completo, lamanera mas bajo costo para calcular A1..n lo tanto, serıa m[1, n].

Podemos definir m[i, j] recursivamente de la siguiente manera. Si i = j,el problema es trivial; la cadena se compone de una sola matrizAi..i = Ai, de modo que no hay multiplicaciones escalares, no esnecesario calcular el producto. Por lo tanto, m[i, i] = 0 parai = 1, 2, .., n.



Sea m[i, j] es el numero mınimo de multiplicaciones escalaresnecesarios para calcular la matriz Ai..j ; para el problema completo, lamanera mas bajo costo para calcular A1..n lo tanto, serıa m[1, n].

Podemos definir m[i, j] recursivamente de la siguiente manera. Si i = j,el problema es trivial; la cadena se compone de una sola matrizAi..i = Ai, de modo que no hay multiplicaciones escalares, no esnecesario calcular el producto. Por lo tanto, m[i, i] = 0 parai = 1, 2, .., n.



Para calcular m[i, j] cuando i < j, que se aprovechan de la estructurade una solucion optima desde el paso 1. Supongamos que se colocanentre parentesis de forma optima, nos dividimos elproductoAiAi+1 · · ·Aj entre AkyAk+1, donde i ≤ k < j.

Luego, m[i, j] es igual al costo mınimo para el calculo de lossubproductos Ai..k y Ak+1..j , mas el costo de multiplicar estas dosmatrices.

Recordando que cada matriz Ai es pi−1 x pi, vemos que el calculo delproducto de la matriz Ai..kAk+1..j toma pi−1pkpj

m[i, j] = m[i, k] + m[k + 1, j] + pi−1pkpj















Esta ecuacion recursiva asume que conocemos el valor de k, lo cual nosabemos.

Hay solo j − i posibles valores para k, sin embargo, es decir,k = i, i + 1, ..., j − 1. La parentizacion optima debe utilizar uno de estosvalores para k, solo tenemos que comprobarlos todos para encontrar lamejor.

Por lo tanto, nuestra definicion recursiva para el costo mınimo deparentesizacion del producto AiAi+1 · · ·Aj se convierte en

m[i, j] =

0 si i = j

mini≤k<j

m[i, k] + m[k + 1, j] + pi−1pkpj si i < j (4)

m[i, j] son los valores de los costos de las soluciones optimas a lossubproblemas, pero que no proporcionan toda la informacion que senecsita para construir una solucion optima.






m[i, j] =

0 si i = j

mini≤k<j








m[i, j] =

0 si i = j

mini≤k<j








m[i, j] =

0 si i = j

mini≤k<j








m[i, j] =

0 si i = j

mini≤k<j






Para ayudarnos a hacerlo, definimos s[i, j] para ser un valor de k en laque separamos el producto AiAi+1 · · ·Aj en una parentizacion optima.Es decir, s[i, j] es igual a un valor k tal quem[i, j] = m[i, k] + m[k + 1, j] + pi−1pkpj .




Para ayudarnos a hacerlo, definimos s[i, j] para ser un valor de k en laque separamos el producto AiAi+1 · · ·Aj en una parentizacion optima.Es decir, s[i, j] es igual a un valor k tal quem[i, j] = m[i, k] + m[k + 1, j] + pi−1pkpj .


Paso 3: Calculo de los costos optimos

Observe que tenemos relativamente pocos subproblemas distintos: unsubproblema para cada cambio de i y j satisfaciendo 1 ≤ i ≤ j ≤ n, o(n2

)+ n = O(n2) en todos.

Un algoritmo recursivo puede encontrar cada subproblema muchasveces en diferentes ramas de su arbol de recursion. Esta propiedad desubproblemas superpuestos es la segunda caracterıstica de cuando seaplica programacion dinamica.

En lugar de calcular la solucion hasta la recurrencia (4) de formarecursiva, calculamos el coste optimo mediante el uso de un enfoquetabular de abajo hacia arriba.















MATRIX-CHAIN-ORDER(p)1 n = p.length - 12 let m[1..n, 1..n] and s[1..n-1, 2..n] be new table3 for i=1 to n4 m[i, i] = 05 for l = 2 to n6 for i = 1 to n-l+17 j = i + l − 18 m[i, j] =∞9 for k= 1 to j-110 q = m[i, k] + m[k+1, j] + pi−1pkpj11 if q ¡ m[i,j]12 m[i,j] = q13 s[i,j] = k14 return m and s

El algoritmo calcula primero m[i, i] = 0 para i = 1, 2, .., n en las lıneas3-4, Seguidamente, utiliza la recurrencia (4) para calcular m[i, i + 1]para i = 1, 2, ..., n− 1, durante la primera ejecucion del bucle for enlıneas 5-13.



MATRIX-CHAIN-ORDER(p)1 n = p.length - 12 let m[1..n, 1..n] and s[1..n-1, 2..n] be new table3 for i=1 to n4 m[i, i] = 05 for l = 2 to n6 for i = 1 to n-l+17 j = i + l − 18 m[i, j] =∞9 for k= 1 to j-110 q = m[i, k] + m[k+1, j] + pi−1pkpj11 if q ¡ m[i,j]12 m[i,j] = q13 s[i,j] = k14 return m and s

El algoritmo calcula primero m[i, i] = 0 para i = 1, 2, .., n en las lıneas3-4, Seguidamente, utiliza la recurrencia (4) para calcular m[i, i + 1]para i = 1, 2, ..., n− 1, durante la primera ejecucion del bucle for enlıneas 5-13.



La segunda vez a traves del bucle, se calcula m[i, i + 2] parai = 1, 2, ..., n− 2, y ası sucesivamente. En cada paso, el m[i, j] costocalculado en lıneas 10-13 depende solo de entradas de la tablam[i, k] ym[k + 1, j] ya calculada.

La siguiente imagen ilustra este procedimiento en una cadena de n = 6matrices.











la tabla m y s calculados por MATRIX-CHAIN-ORDER para n = 6 ycon los siguientes valores.

matrix A1 A2 A3 A4 A5 A6

dimension 30 x 35 35 x 15 15 x 5 5 x 10 10 x 20 20 x 25

La tabla m utiliza la diagonal principal y superior triangular, y la tablade s utiliza solo la triangular superior .



El numero mınimo de multiplicaciones escalares para las 6 matrices esm[1,6] = 15,125. De las entradas oscuras , los pares.que tienen el mismo sombreado se toman juntos en la lınea 10 cuandose calcula



Una simple inspeccion de la estructura de bucle anidado deMATRIX-CHAIN-ORDER produce un tiempo de ejecucion de Ω(n3)para el algoritmo.

Por lo tanto, MATRIX-CHAIN-ORDER es mucho mas eficiente que elmetodo en tiempo exponencial de enumerar todos parentesis posibles ycomprobar cada uno.



Una simple inspeccion de la estructura de bucle anidado deMATRIX-CHAIN-ORDER produce un tiempo de ejecucion de Ω(n3)para el algoritmo.

Por lo tanto, MATRIX-CHAIN-ORDER es mucho mas eficiente que elmetodo en tiempo exponencial de enumerar todos parentesis posibles ycomprobar cada uno.


Paso 4: La construccion de una solucion optima

MATRIX-CHAIN-ORDER determina el numero optimo demultiplicaciones escalares necesarias para calcular un producto dematriz de cadena, que no muestra directamente como multiplicar lasmatrices. La tabla de s[1..n− 1, 2..n] nos da la informacion quenecesitamos para hacerlo.

Cada entrada de s[i, j] registra un valor de k tal que un parentizacionoptima de AiAi+1 · · ·Aj divide entre el producto Ak y Ak+1.

El siguiente procedimiento recursivo imprime una parentizacion optimade (Ai, Ai+1, .., Aj), teniendo en cuenta la tabla s calculada porMATRIX-CHAIN-ORDER y los ındices i y j.

La llamada inicial de PRINT-OPTIMAL-PARENS (s, 1, n) imprimeuna parentizacion optima de (A1, A2, ..., An).





















PRINT-OPTIMAL-PARENS(s, i, j)1 if i == j2 print .A”i3 else print ”(”4 PRINT-OPTIMAL-PARENS(s, i, s[i, j])5 PRINT-OPTIMAL-PARENS(s, s[i,j] +1, j)6 print ”)”

En el ejemplo de la imagen de las tablas, la llamada dePRINT-OPTIMAL-PARENS(s, 1,6) imprime la parentizacion((A1(A2A3))((A4A5)A6)).


Algoritmo 3

Algoritmo 3

Sumas de subconjuntos y Mochilas: Adicion de una variable



Consideramos una version en la que las solicitudes tienen una duraciony una fecha lımite, que es difıcil de resolver directamente usandotecnicas comunes.

Se utilizara la programacion dinamica para resolver el problema, perocon una modificacion: el conjunto de subproblemas resultan no sersuficientes, por lo que terminan creando una coleccion desubproblemas, esto se hace mediante la adicion de una nueva variable ala recurrencia subyacente al programa dinamico.



Consideramos una version en la que las solicitudes tienen una duraciony una fecha lımite, que es difıcil de resolver directamente usandotecnicas comunes.

Se utilizara la programacion dinamica para resolver el problema, perocon una modificacion: el conjunto de subproblemas resultan no sersuficientes, por lo que terminan creando una coleccion desubproblemas, esto se hace mediante la adicion de una nueva variable ala recurrencia subyacente al programa dinamico.


El problema

Tenemos una unica maquina que puede procesar trabajos, y tenemosun conjunto de solicitudes 1, 2.....n. Solo somos capaces de utilizar esterecurso para el perıodo entre el tiempo 0 y el tiempo W , para algunnumero W .

Cada solicitud corresponde a un trabajo que requiere wi tiempo paraprocesarse. Si nuestro objetivo es procesar los trabajos a fin demantener la maquina tan ocupado como sea posible hasta ”terminar”laW .

Formalmente, se nos da n elementos (1, ..., n), y cada uno tiene un wipeso no negativo dado (parai = 1, ..., n). Tambien se nos da una cotaW .

Nos gustarıa seleccionar un subconjunto S de los elementos para que∑iεS wi 6 W y, sujetos a esta restriccion,

∑iεS wi es lo mas grande

posible. Vamos a llamar a esto el problema de suma de subconjunto


El problema








El problema








El problema








El problema

Este problema es un caso especial natural de un problema mas generalllamado el problema de la mochila, donde cada solicitud i tiene unvalor vi y un peso wi .

El objetivo en este problema mas general es seleccionar un subconjuntodel maximo valor total, sujeto a la restriccion de que su peso total nosupere W

Se utilizara el peso o el tiempo cuando se refiere a la cantidad wi y W .


El problema





El problema





Diseno del Algoritmo

Para saber el valor para el OPT (n) no solo necesitamos el valor deOPT (n− 1), pero tambien necesitamos saber la mejor solucion quepodemos conseguir utilizando un subconjunto de los primeros n− 1artıculos y peso total permitido W − wn.

Supongamos que W es un entero, y todas las solicitudes de i = 1, ..., ntienen pesos wi enteros. Tendremos un subproblema para cadai = 0, 1, ....., n y cada entero 0 ≤ w ≤W .

Usaremos OPT (i, w) para indicar el valor de la solucion optimautilizando un subconjunto de los elementos 1, ....., i con un maximopeso w, es decir,

OPT (i, w) = maxS

∑jεS

wj






OPT (i, w) = maxS

∑jεS

wj






OPT (i, w) = maxS

∑jεS

wj






OPT (i, w) = maxS

∑jεS

wj



Donde el maximo esta en el subconjuntos S ⊆ 1, .., i que satisface∑jεS wj ≤ w.

Por otra parte, OPT (n,W ) es la cantidad que estamos buscando en elfinal. Se usara ϑ para denotar una solucion optima para el problemaoriginal.

Si n /∈ ϑ, entonces OPT (n,W ) = OPT (n− 1,W ), ya podemos ignorar elpunto n.l

Si n ∈ ϑ, entonces OPT (n,W ) = wn + OPT (n− 1,W − wn), ya queahora tratamos de utilizar la capacidad restante de W − wn en unamanera optima con los elementos 1, 2, .., n− 1 .

Cuando el elemento enesimo es demasiado grande, es decir, W < wn,entonces debemos tener OPT (n,W ) = OPT (n− 1,W ). De locontrario, se obtiene la solucion optima permitiendo todas las npeticiones para tomar la mejor de estas dos opciones.
























Utilizando la misma lınea de argumentacion para el subproblema paralos elementos 1, ..., i, y el maximo peso admitido w, obtenemos lasiguiente recurrencia.

Siw < wientoncesOPT (i, w) = OPT (i− 1, w).Encasocontrario

OPT (i, w) = max(OPT (i− 1, w), wi + OPT (i− 1, w − wi))(5)



Utilizando la misma lınea de argumentacion para el subproblema paralos elementos 1, ..., i, y el maximo peso admitido w, obtenemos lasiguiente recurrencia.


OPT (i, w) = max(OPT (i− 1, w), wi + OPT (i− 1, w − wi))(5)



Algoritmo que construye una tabla de todos los valores de OPT(i, w),el calculo de cada uno de ellos es mas de una vez

SUBSET-SUM(n, W)1 Array M[0...n, 0...W]2 Initialize M[0,w]=0 for each w=0,1,..,W4 for i = 1 to n5 for w = 0 to W6 Use the recurrence (5) to compute M[i, w]7 Endfor8 Endfor9 return M[n, W]



Algoritmo que construye una tabla de todos los valores de OPT(i, w),el calculo de cada uno de ellos es mas de una vez

SUBSET-SUM(n, W)1 Array M[0...n, 0...W]2 Initialize M[0,w]=0 for each w=0,1,..,W4 for i = 1 to n5 for w = 0 to W6 Use the recurrence (5) to compute M[i, w]7 Endfor8 Endfor9 return M[n, W]



La tabla de dos dimensiones de valores OPT . La columna mas a laizquierda y la fila inferior es siempre 0. La entrada para OPT (i, w) secalcula a partir de las otras dos entradas OPT (i− 1, w) yOPT (i− 1, w − wi) , como se indica por las flechas.


Analizando el Algoritmo

La imagen anterior muestra la construccion de subproblemas, en la quese refleja una matriz bidimensional de subproblemas para representarel algoritmo disenado en este caso:El valor M [i, w] se calcula a partir de los otros dos valores deM [i− 1, w] y M [i− 1, w − wi].

Como ejemplo de este algoritmo ejecucion, considere una instancia conel lımite de peso W = 6, y n = 3 artıculos de tamanos w1 = w2 = 2 yw3 = 3. Nos parece que el valor optimo OPT(3, 6) = 5.



La imagen anterior muestra la construccion de subproblemas, en la quese refleja una matriz bidimensional de subproblemas para representarel algoritmo disenado en este caso:El valor M [i, w] se calcula a partir de los otros dos valores deM [i− 1, w] y M [i− 1, w − wi].

Como ejemplo de este algoritmo ejecucion, considere una instancia conel lımite de peso W = 6, y n = 3 artıculos de tamanos w1 = w2 = 2 yw3 = 3. Nos parece que el valor optimo OPT(3, 6) = 5.



La siguiente imagen ilustra la forma en que el algoritmo se llena latabla bidimensional de valores OPT, fila por fila.



Ahora nos interesa el tiempo de funcionamiento de este algoritmo, seconstruye una tabla de soluciones M , y calculamos cada uno de losvalores de M [i, w] en tiempo O(1) utilizando los valores anteriores. Ası,el tiempo de ejecucion es proporcional al numero de entradas en latabla.

De hecho, su tiempo de ejecucion no es una funcion polinomica de n;mas bien, es una funcion polinomica de N y W, el entero mas grandeimplicado en la definicion del problema. Llamamos a este tipo dealgoritmos pseudo-polinomial.

Los algoritmos pseudo-polinomial pueden ser razonablemente eficientecuando los numeros wi involucrados en la entrada son razonablementepequeno; Sin embargo, se vuelven menos practico ya que estos numerosse incrementan.

















Extension: Problema de la Mochila

El problemas de la mochila es un poco mas complejo, Considere unasituacion en la que cada elemento i tiene un peso wi no negativo, ytambien un valor distinto vi..

Nuestro objetivo ahora es encontrar un subconjunto S de un maximode valor

∑i∈S vi, sujeto a la restriccion de que el peso total del

conjunto no debe exceder W:∑i∈S wi ≤W .

Se usara el conjunto analogo de subproblemas, OPT (i, w), para indicarel valor de la solucion optima utilizando un subconjunto de loselementos 1, ..., i y el peso maximo disponible w

















Consideramos que una solucion optima ϑ, e identificamos dos casosdependiendo de si o no n ∈ ϑ.



Con esta lınea de argumentacion de los subproblemas implica elsiguiente analogo de (5).
















OPT (i, w) = max(OPT (i− 1, w), vi + OPT (i− 1, w − wi))(6)

Con el uso de esta recurrencia, podemos escribir un algoritmo deprogramacion dinamica completamente analoga, y esto implica elsiguiente hecho.El problema de la mochila puede resolverse en tiempo O(nW ) .


Referencias

Jon Kleinberg, Eva TardosAlgorithm DesignPearson, 2006.

Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,CliffordSteinIntroduction to AlgotithmsMassachusetts Institute of Technology, 2009.

Date post:	06-Aug-2015
Category:	Education
Upload:	jose-alberto-noh-noh
View:	228 times
Download:	2 times

Programación dinámica 1

Education