Documentos de Académico
Documentos de Profesional
Documentos de Cultura
T3 Diseño Alg
T3 Diseño Alg
De optimización:
Hallar el camino más corto
[1,9,34,-2,6,28]
N 20 30 50 100
Recursiva 1 seg 2 min 21 días 109 años
Iterativa 1/3 mseg ½ mseg ¾ mseg 1.5 mseg
Divide y Vencerás (Divide para Reinar)
Consiste en dividir el problema en partes menores, encontrar
soluciones para las partes y combinarlas en una solución
global.
DV(x){
if (x es suficientemente pequeño) {
return algoritmo_específico(x);
}
else {
descomponer x en {xi, …, xk}
for i = 1 to k
yi ← DV(xi)
y ← recombinar (yi, …, yk)
return y;
}
}
Divide y Vencerás (Divide para Reinar)
P.e.: Multiplicación de número grandes X, Y de n dígitos
Método tradicional : O(n2)
Divide y reinarás?....
X = Xi * 10n/2 + Xd
Y = Yi * 10n/2 + Yd
Divide y Venceras
Dividir
X = 12345678 = xi * 104 + xd xi=1234 xd=5678
Y = 24680135 = yi * 104 + yd yi=2468 yd=0135
Combinar
X * Y = (Xi * 104 + Xd) * (Yi *104 + Yd)
= Xi * Yi * 108 + (Xi * Yd + Xd * Yi) *104 + Xd * Yd
Multiplicación de enteros grandes
función multiplica (X,Y,n) {
if (P es pequeño) {
return X*Y;
}else{
Obtener xi, xd, yi, yd; // DIVIDIR
z1 = multiplica (xi, yi, n/2);
z2 = multiplica (xi, yd, n/2);
z3 = multiplica (xd, yi, n/2);
z4 = multiplica (xd, yd, n/2);
aux = suma(z2,z3); // COMBINAR
z1 = desplaza_izq(z1,n);
aux = desplaza_izq(aux,n/2);
z = suma(z1,aux);
z = suma(z,z4);
return z;
}
}
Multiplicación de enteros grandes
función multiplica (X,Y,n) { eficiencia
if (P es pequeño) { O(1)
return X*Y; O(1)
}else{
Obtener xi, xd, yi, yd; O(n)
z1 = multiplica (xi, yi, n/2); T(n/2)
z2 = multiplica (xi, yd, n/2); T(n/2)
z3 = multiplica (xd, yi, n/2); T(n/2)
z4 = multiplica (xd, yd, n/2); T(n/2)
aux = suma(z2,z3); O(n)
z1 = desplaza_izq(z1,n); O(n)
aux = desplaza_izq(aux,n/2); O(n)
z = suma(z1,aux); O(n)
z = suma(z,z4); O(n)
return z; O(1)
}
}
Multiplicación de enteros grandes
Tiempo de ejecución:
Algoritmo específico
Para resolver problemas de tamaño pequeño
i/w 0 1 2 3 4 5 6 7 8
Objeto Peso Valor
0 0 0 0 0 0 0 0 0 0
1 1 15
1 0
2 5 10
2 0
3 3 9 3 0
4 4 5 4 0
Para i, w > 0:
si w-Wi < 0 Entonces
B[i,w] = B[i-1,w]
sino
B[i,w] = max(B[i-1,w],C[i] + B[i-1, w-W[i]]
Ejemplo- Problema de la mochila
k = k – W3 = 4 – 3 = 1
Problema de la mochila – ítems seleccionados
Si B[2,1] = B[1,1] entonces el item 2 no entra en la mochila.
i = i – 1 = 2 – 1 = 1
Problema de la mochila – ítems seleccionados
Los valores de B[1,1] B[0,1] entonces el item 1entra a la
mochila.
k = k – W1 = 1 – 1 = 0
Problema de la mochila – ítems seleccionados
Entonces la combinación de objetos que maximizan el robo
es:
Problema de la mochila
Para encontrar los items que fueron seleccionados hacemos
uso del algoritmo Backtrace
public static boolean[] ObjSel(int []W, int [][]B, int n, int M){
boolean X[] = new boolean[n];
int i = n; int k = M;
while (i > 0 && k > 0 ){
if ( B[i][k] != B[i-1][k] ){
X[i-1] = true; //{item i esta en la mochila};
k = k - W[i-1];
}
else
X[i-1] = false;
i--;
}
return X;
}
Pasos del diseño del algoritmo
El diseño de un algoritmo de Programación Dinámica consta
de los siguientes pasos:
Planteamiento de la solución como una sucesión de decisiones y
verificación de que ésta cumple el principio de óptimo.
Definición recursiva de la solución.
Cálculo del valor de la solución óptima mediante una tabla en
donde se almacenan soluciones a problemas parciales para
reutilizar los cálculos.
Construcción de la solución óptima haciendo uso de la
información contenida en la tabla anterior.