programación dinámica

Bibliografía: (Horowitz,97) (Brassard,97) (Cormen,91)
4. Ejemplos.
3. Esquema iterativo.
2. Esquema recursivo.
1. Introducción
PROGRAMACIÓN DINÁMICA
Solución: Secuencia de decisiones
Ejemplos: Cambio de monedas, Mochila, Camino mínimo en
un grafo.
- Restricciones
- Función objetivo.
Problemas de optimización.
1. Introducción
– 11x1000 (11 billetes)
– 5x2000+1x1000 (6 billetes)
– 2x5000+1x1000 (3 billetes)
• La estrategia voraz consiste en coger el billete más grande
que se pueda cada vez.
• Suministrar la cantidad de billetes solicitada de
forma que el número total de billetes sea mínimo.
• Ejemplo: M=11000 pts, B={1000, 2000, 5000}
Ejemplo: Cajero automático
–A veces no hay solución; p.e. Si M=3000 y
no hay billetes de 1000
–A veces no la encuentra; p.e. M=11000 y no
hay billetes de 1000
–A veces encuentra una factible pero no
óptima; p.e. B={100, 500, 1100, 5000} y
M=6500. La solución que se obtendría sería:
1x5000+1x100+4x100 (6 billetes)
i =1
i
i
∑ p ⋅x
N
N
i =1
con la restricción de que los objetos quepan en la mochila ∑ wi ⋅ xi ≤ M
Obtener el máximo beneficio
Resultado: (x1.. xN ), 0 ≤ xi ≤ 1
Datos: (p1.. pN ), (w1.. wN ), M
Problema: ¿Qué objetos debemos introducir en la mochila para
que el valor total sea máximo? Se permite que se fraccionen los
elementos.
Sea una mochila de capacidad M y N objetos. Cada objeto tiene
un volumen wi y un valor pi, 1≤i≤N.
El problema de la mochila con
fraccionamiento
a)
b)
c)
d)
(1/2, 1/3, 1/4)
(1, 2/15, 0)
(0, 2/3, 1)
(0, 1, 1/2)
SOLUCION
16.50
20.00
20.00
20.00
PESO
24.25
28.20
31.00
31.50
VALOR
Criterio de selección de los objetos que se van metiendo:
- El de mayor relación valor/peso
La solución óptima debe llenar la mochila completamente. Sólo
se fracciona el último.
Soluciones factibles:
Ejemplo: M=20, w=(18,15,10) p=(25,24,15)
Mochila con fraccionamiento (cont)
Solución= (1, 0, 10/15, 1)
Beneficio= 25+10/15*12+10=42.99;
- Selección: El de mayor relación valor/peso
pi / wi =(5/30, 13/18,12/15,10/10)
Peso=50;
Ejemplo: M=50, w=(30,18,15,10) p=(25,13,12,10)
Mochila con fraccionamiento (cont)
∀ ( x1 , x2 ,..., xn )
max
i
i
i =1
∑ b ⋅x
n
Solución: (x1,x2,…,xn)
i =1
i
i
∑ p ⋅x
n
0
xi = 
1
≤M
Conjunto n de objetos con pesos (pi) y beneficios (bi)
Mochila de capacidad M.
Encontrar el subconjunto de objetos que caben en la
mochila y que maximizan el beneficio.
Mochila sin fraccionamiento
2
2 4
5
6
3
3
4
1
8
4
5
6
6
F=6
Solución: Coste(6)
i =1
0

cos te(i ) = 
{
cos te( j ) + c ( j , i )} 1 < i ≤ F
∀j∈min
pred ( i )
1
3
Ejemplo: Problema del Rio Congo
2
2 4
5
6
3
3
4
1
8
4
5
6
6
F=6
Solución: Coste(1)
i=F
0

cos te(i ) = 
{
cos te( j ) + c (i, j )} 1 ≤ i < F
∀jmin
∈suc ( i )
1
3
Problema del Rio Congo
fsi
fPDR
sino
PDR:=
x ∈alternativas(A)
opt
{calculo(PDR(x),coste(A, x))}
si contorno(A) entonces PDR:=trivial(A)
esquema PDR (A:λ): R
Esquema recursivo:
X '∈ X
X * = arg max F ( X ' )
Hay que encontrar la secuencia X*∈X, tal que F(X*) sea
óptima.
Sea un problema cuyo conjunto de soluciones es X, y la
función objetivo F:X→ R+
2. Esquema recursivo.
Coste(4)
Coste(1)
1
2
3
Coste(1)
Coste(2)
Coste(5)
Coste(4)
2 4
5
6
3
3
Coste(1)
4
1
8
4
5
6
6
Coste(1)
Coste(1) Coste(2) Coste(1)
Coste(2) Coste(1) Coste(1) Coste(2) Coste(3)
Coste(2) Coste(1) Coste(2) Coste(3)
Coste(3)
Coste(6)
2
2 4
5
6
3
3
4
1
8
4
5
6
6
T[1]:=0
T[2]:= min{T[1]+c(1,2)}=0+2=2
T[3]:= min {T[1]+c(1,3), T[2]+c(2,3)}= min{0+3, 2+4}=3
T[4]:= min {T[2]+c(2,4), T[3]+c(3,4)}= min{2+5, 3+3}=6
T[5]:= min {T[2]+c(2,5), T[4]+c(4,5)}= min{2+6, 6+1}=7
T[6]:= min {T[3]+c(3,6), T[4]+c(4,6), T[5]+c(5,6)}=
min {3+8, 6+4, 7+6}= 10
Ordenación de subproblemas: 1,2,3,4,5,6
Tabla de almacenamiento T: vector [1..F] de R
1
3
2
2
0
1
3
3
4
6
6
7 10
5
fpara
cmin:=T[F ];
ffunción.
j∈ pred ( i )
T [i ] := min {T [ j ] + c( j , i )}
para i:= 2 hasta F hacer
Algoritmo iterativo
función cmin (G=(V,A)):R;
var T: vector [ 1..F ] of R;
T [1] :=0;
fPDI
PDI:=T[pn];
fpara
fsi
sino
T[p i ]: =
x ∈alternativa(p i )
opt
i
i
{calculo(T[p ], coste(x, p ))}
si pi ∈contorno(A) entonces T[pi]:=trivial(pi)
para i:=1 hasta n hacer
var T: Tabla[p] de R ; i:N; fvar
/* Sea n el número de subproblemas */
/* Sean pi los “nombres” nombres de los subproblemas ordenados pi ≤pi+1*/
Esquema PDI(A: λ): R
3. Esquema iterativo
T
2
2
0
1
3
3
4
6
5
6
7 10
C
1
-1
T[i] := T[jmejor]+c(jmejor,i);
C[i] :=jmejor;
fpara
L:=insertar (listavacia, F); i:=F;
mientras C [i] <>-1 hacer
L:= insertar (L, C [i] );
i:= C [i];
fmientras;
cmin:=(T[F ],L);
ffunción
j∈ pred ( i )
jmejor := min {T [ j ] + c( j , i )}
T [1] :=0; C [1]:=−1;
para i:= 2 hasta F hacer
2
1
3
1
Algoritmo iterativo
función cmin (G=(V,A)):(R, Lista de N);
var T: vector [ 1..F ] of R;
C: vector [ 1..F ] of N;
L:Lista de N;
4
3
5
4
6
4
(0,0)
(i,j)
(i,j-1)
(i-1,j)
(i-1,j-1)
1) Camino óptimo.
4. EJEMPLOS
(I,J)
Solución: coste(I,J)
0


cos te(i, j − 1) + d[(i, j),(i, j − 1)]

cos te(i − 1, j) + d[(i, j),(i − 1, j)]


cos te(i, j) =  cos te(i, j − 1) + d[(i, j),(i, j − 1)],




−
+
−
min
cos
te
(
i
1
,
j
)
d
[(
i
,
j
),(
i
1
,
j
)],



 cos te(i − 1, j − 1) + d[(i, j),(i − 1, j − 1)

(i > 1) ∧ ( j = 1)
(i > 1) ∧ ( j = 1)
(i = 1) ∧ ( j = 1)
(i = 1) ∧ ( j > 1)
(1,1)
(i,j)
(i,j-1)
(i-1,j)
(i-1,j-1)
(I,J)
1
2
3
4
5
6
7
1
2
T: matriz[1..I,1..J] de R;
3
4
5
6
7
fpara
fpara
coste:=T[I,J];
fin
T[i − 1, j ] + d [(i , j ), (i − 1, j )],



T[i , j ]: = min T[i , j − 1] + d [(i , j ), (i , j − 1)],

T[i − 1, j − 1] + d [(i , j ),(i − 1, j − 1)]


T[1,1]:=0
para j:=2 hasta J hacer T[1,j]:=T[1,j-1]+d[(1,j),(1,j-1)] fpara
para i:=2 hasta I hacer
T[i,1]:=T[i-1,1]+d[(i,1),(i-1,1)]
para j:=2 hasta J hacer
Función coste (I,J:N):R;
var T: matriz[1..I,1..J] de R;
1
2
3
4
5
6
7
1
2
T: matriz[1..I,1..J] de R;
3
4
5
6
7
1
2
3
4
5
6
7
1
V1 V2
2
V1 V2
V1,V2: vector[1..J] de R;
3
4
5
6
7
fpara
V1:=V2;
fpara
coste:=V2[J];
fin
V 1[ j ] + d [(i, j ), (i − 1, j )],



V 2[ j ] := min V 2[ j − 1] + d [(i, j ), (i, j − 1)], 
V 1[ j − 1] + d [(i, j ), (i − 1, j − 1)]


V1[1]:=0
para j:=2 hasta J hacer V1[j]:=V1[j-1]+d[(1,j),(1,j-1)] fpara
para i:=2 hasta I hacer
V2[1]:=V1[1]+d[(i,1),(i-1,1)]
para j:=2 hasta J hacer
Función coste (I,J:N):R;
var V1,V2: vector[1..J] de R;
Reducción del coste espacial (1)
fpara
iant:=(iant+1)mod 2; isig:= (isig+1) mod 2;
fpara
coste:=T[isig,J];
fin
T[0,1]:=0
para j:=2 hasta J hacer T[0,j]:=T[0,j-1]+d[(1,j),(1,j-1)] fpara
iant:=0; isig:=1;
para i:=2 hasta I hacer
T[isig,1]:=T[iant,1]+d[(i,1),(i-1,1)]
para j:=2 hasta J hacer

T [iant , j ] + d [(i, j ), (i − 1, j )],


T [isig , j ] := min T [isig , j − 1] + d [(i, j ), (i, j − 1)], 
T [iant , j − 1] + d [(i, j ), (i − 1, j − 1)]


Función coste (I,J:N):R;
var T: matriz [0,1,1..J] de R;
Reducción del coste espacial (2)
1
iant iant
isig
isig
0
(1,1)
(i,j)
(i,j-1) (i+1,j-1)
(i-1,j)
(i-1,j-1)
Camino óptimo permitiendo diversos puntos de salida y llegada
(I,J)
fpara
fpara
coste:= min{T [i, J ]}
1≤i≤ I
fin
;
T [i − 1, j ] + d [(i, j ), (i − 1, j )],

T [i , j − 1] + d [(i, j ), (i , j − 1)],



T [i, j ] := min 

−
−
+
−
−
T
i
j
d
i
j
i
j
[
1
,
1
]
[(
,
),
(
1
,
1
)]


T [i + 1, j − 1] + d [(i , j ), (i + 1, j − 1)]
para i:=1 hasta I hacer T[i,1]:=0 fpara
para j:=2 hasta I hacer
T[1,j]:= min{T[1,j-1]+d[(1,j),(1,j-1)], T[2,j-1]+d[(2,j),(1,j-1)]}
T[I,j]:= min{T[I-1,j-1]+d[(I-1,j),(I,j-1)], T[I,j-1]+d[(I,j),(I,j-1)],
T[I-1,j]+d[(I-1,j),(I,j)]}
para i:=2 hasta I-1 hacer
Función coste (I,J:N):R;
var T: matriz[1..I,1..J] de R;
Ejemplo de aplicación: Sean n recursos que deben asignarse
a r proyectos. Si j (0<=j<=n) recursos se asignan al proyecto
i, el beneficio resultante es N(i,j). El problema es asignar los
recursos a los r proyectos de modo que se maximice el
beneficio total.
2) Asignación de recursos. Grafo multietapa.
(1,1)
1
K=1
5
6
9
(3,2)
4
(2,2)
3
(1,2)
2
K=2
2
7
1
3
4
(2,3)
6
(1,3)
5
K=3
5
3
(1,4)
7
K=4
min
{c[( j, k − 1), (i, k )] + T [ j, k − 1]}
1≤ j ≤ nk −1 ( G )
fpara
fpara
Gmultietapa:=T[1,K(G) ];
fin
T [i, k ] :=
T[1,1] :=0;
para k:=2 hasta K(G) hacer
para i:=1 hasta nk(G) hacer
T: matriz [1..max_vertices_etapa, 1..K(G) ] de R;
Función Gmultietapa (G(V,A):grafo):R;
{ K(G): número de etapas;
ni (G): vertices de la etapa i
c:A--->R;
}
β=acbbb
aabb
s
acbbb i
Ejemplo:
acbbb
Transformación Γ de α en β:Secuencia de reglas de
error aplicadas.
Sustitución: ∀a∈∑ α1aα2 -------> α1xα2 x∈∑
Inserción:
α1α2 -------> α1xα2 x∈∑
Borrado:
α1xα2 -------> α1α2 x∈∑
Modelo de error
α=aabb
3) Distancia entre cadenas de caracteres
∀Γ
min ( N s ( Γ ) + N i ( Γ ) + N B ( Γ ))
b
b
a
a c
a
Ejemplo:
b
b
b
a
c
a
a
b
b
b
b
b
Como sólo se puede aplicar una regla de error a un carácter,
una tranformación corresponde con una “alineamiento” entre
las dos cadenas.
d(α , β)=
Distancia: Mínimo número de reglas de error para convertir
la cadena α en β.
a c b b b
Borrado
Inserción
a a b b
a c b b b
a a b b
Sustitución
a a b b
a c b b b
Alineamiento asociado a cada regla:
aabb
bbb
abb
abb
bbb
bbb
aabb
abb
cbbb
cbbb
abb
cbbb
I
abb
bbb
S
aabb
bb
bbb
abb
cbbb
aabb
acbbb
bb
cbbb
B
Arbol de todas las transformaciones
abb
cbbb
abb
acbbb
bb
cbbb
bb
acbbb
β11 β22 ….. βj−1
j−1 βjj …….βm
α1 α2 ….. αi−1 αi …….αn
ββ11 ββ22…..
…..ββj−1
j−1 β
βjj …….βm
…..ααi−1
αi i …….αn
i−1α
αα11 αα22…..
βj−1 ββjj …….βm
2 …..
β1β1β2β…..
βj−1
…..ααi−1i−1 ααii …….αn
αα1 1αα2 2…..
d (i-1,j)+ Borr (αi)
d (i,j-1)+ Ins (βj)
d (i-1,j-1)+ Sust (αi, βj)
Obtención de la solución recursiva: ¿Cuál es la mejor forma de
haber alineado hasta el carácter i de la cadena α y el carácter j
de la cadena β?.
0


d (i − 1, j ) + Borr (αi )


d (i , j − 1) + Ins( β j )

d (i − 1, j ) + Borr (α )

i
d (i , j ) = 


min d (i , j − 1) + Ins( β j )




d (i − 1, j − 1) + Sust (αi , β j ) 



j=0
j=0
j>0
i > 0∧ j > 0
i = 0∧
i > 0∧
i = 0∧
i
b
b
a
α a
aa
cc
bb
j
b
b
T[i,j]:=min{T[i-1,j-1]+Sust(αi,βj),
T[i,j-1]+Ins(βj),
T[i-1,j]+Borr(αi) }
aa
β
B S
I
para j:=1 hasta |β| hacer
T[0,j]:=T[0,j-1]+Ins(βj);
para i:=1 hasta |α| hacer
T[i,j]:=min{T[i-1,j-1]+Sust(αi,βj),
T[i,j-1]+Ins(βj),
T[i-1,j]+Borr(αi) }
fpara
fpara
Distancia:=T[|α| , |β| ];
fin
T[0.0]:=0;
para i:=1 hasta |α| hacer T[i,0]:=T[i-1,0]+Borr(αi)
var T:matriz[ 0..|α|, 0..|β| ] de N;
Función Distancia(α,β):N;
∀ ( x1 , x2 ,..., xn )
max
i
i
i =1
∑ b ⋅x
n
Solución: (x1,x2,…,xn)
i =1
i
i
∑ p ⋅x
n
0
xi = 
1
≤M
Conjunto n de objetos con pesos (pi) y beneficios (bi)
Mochila de capacidad M.
Encontrar el subconjunto de objetos que caben en la
mochila y que maximizan el beneficio.
4) Mochila sin fraccionamiento
1
1
0
1
1
0
0
1
1
0
0
1
0
0
x3
x2
x1
1
1
3
Ejemplo:
0
4
7
1
6
1
0
P=(4,6,2,5)
3
0
4
4
3
1
6
9 8
5
1
5
b=(3,5,4,6)
6
0
0
4
1
M=9
2
0
0
0
0
0
x3
x2
X1


0

−∞

mochila (m, i ) = 
−∞

mochila (m, i − 1) + 0,


max mochila (m − p , i − 1) + b 
i
i


i > 0∧m > 0
i = 0∧m = 0
m<0
i = 0∧m > 0
m
9
8
7
6
5
4
3
2
1
0
0
1
2
3
4
T[m,i]= min{T[m,i-1]+0,
T[m-pi,i-1]+bi}
P=(4,6,2,5)
b=(3,5,4,6)
M=9
fin
mochila:=
max
∀m , 0 ≤ m ≤ M
{T[m, n]}
para i:=1 hasta n hacer
para m:=0 hasta M hacer
si (m-pi)<0 entonces T[m,i]:=T[m,i-1]
sino si (T[m,i-1]+0)<(T[(m-pi),i-1]+bi) entonces T[m,i]:= (T[(m-pi),i-1]+bi)
sino T[m,i]:= (T[m,i-1]+0)
fsi
fsi
fpara
fpara
para m:=1 hasta M hacer T[m,0]:=-∞;
T[0,0]:=0;
var T: matriz[0..M,0..n] de R;
Función mochila (p,v:lista de R, n:N,M:R):R;
(I;J)

i = 0∨ j = 0
1

ncam(i , j ) = 
ncam(i − 1, j ) + ncam(i , j − 1) i > 0 ∨ j > 0

(0,0)
5) Número de caminos
para i:=1 hasta I hacer
para j:=1 hasta J hacer
T[i,j]:=T[i-1,j]+T[i,j-1];
fpara
fpara
ncaminos:=T[I,J];
fin;
para i:=0 hasta I hacer T[i,0]:=1;
para j:=0 hasta J hacer T[0,j]:=1;
var T:matriz[0..I,0..J] de N;
función ncam (I,J:N):N;
si n<=1 entonces fib:=1
sino
f1:=1; f2:=1;
para i:=2 hasta n hacer
f3:=f1+f2;
f1:=f2; f2;=f3;
fpara
fib:=f3;
fin;
función fib(n:N)N;
var f1,f2,f3:N;
1
n = 0∨n = 1

fib( n) = 
n >1
 fib( n − 1) + fib( n − 2)
6) Fibonacci
n = m∨m = 0
1

f ( n, m) = 
n>m
 f ( n − 1, m − 1) + f ( n − 1, m)
7) Combinaciones
k
k
Φ(ik , jk )
siendo li la longitud de la palabra i.
n = ik
Φ(ik , jk ) = ( M − ( ∑ ln + ( jk − ik )) 2
jk
es un valor asociado a la línea k, siendo ik y
las palabras inicial y final de la línea k. Una posible definición de φ es
donde
k =1
∑ Φ(i , j )
K
jk
Sea W un texto compuesto por la secuencia de palabras w1,w2,…,wn. Queremos
que aparezca en K líneas de M caracteres cada líneay ajustado a izquierda y
derecha. Para ello podemos introducir espacios en blanco entre las palabras. Una
medida de lo “buena” que es una solución podría ser:
8) Ajuste de líneas en un texto
k=2
k=1
w2
w2w3
w1
w2..wn
w3
w1w2
w1w2
w3
w4w5
Arbol de soluciones
w1
w2w3
w4w5
Ejemplos de soluciones
w1w2w3
w4
w5
w1..wn
w5
w4w5
w5
w3w4w5
w4w5
w5
Nota: Se considera que Φ (i,j) es infinito si no caben las palabras en la línea

k =1
Φ (1, i )

f (i , k ) = 
 min { f ( j , k − 1) + Φ ( j + 1, i )} k > 1
∀j ,1≤ j <i
w3
w3w4
w1w2
w1w2w3 w4
w2
w2w3
w2w3w4
w1
Ejemplo:
¿Cómo haber alineado hasta la palabra j con k líneas?
2
1
w1w2w3w4 4
w1w2w3 3
w1w2
w1
1
2
3
4
5
6
7
1≤ j < i
T [i , k ]: = min{T [ j , k − 1] + Φ ( j + 1, i )}
Error de contorno: No se ha tenido en consideración que la última
línea no genera distorsión.
fpara
fpara
ajustar:=T[n,K];
fin.
1≤ j < i
T [i , k ]: = min{T [ j , k − 1] + Φ ( j + 1, i )}
para i:=1 hasta n hacer T[i,1]:=Φ (1,i) fpara;
para k:=2 hasta K hacer
para i:=k hasta n hacer
función ajustar(l:lista de N; n:N; K:N):N;
var T: matriz[1..n,1..K] de N;
0
w2
w2
w1
w1
2
w2
w1
1
w2
w1
3
w3
w3
w3
4
w3
w4
w4
5
w4
w4
Es un problema de segmentación.
6
w5
w5
w5
w5
w6
w6
w6
w6
0≤ j <i
V [i ] := min {V [ j ] + Φ ( j + 1, i )}
Problema: Alinear un texto de n palabras sin fijar el número de líneas.