Problema de La Mochila

Problema de la mochila 0/1:
Programacion Paralela
Leticia Leonor Pinto Alva
3 de marzo de 2014
Resumen
El proposito de este artculo es resolver el problema de la mochila para objetos no divisibles
usando programacion dinamica con un enfoque secuencial y paralelo. Si consideramos el caso
en que teniendo un presupuesto jo [1], debemos tomar una decision frente a varias opciones,
cada una con un costo y un valor, teniendo como objetivo seleccionar un subconjunto de estos
a n de maximizar el valor total.
Este es en pocas palabras el problema de la mochila, que se presenta en diferentes situaciones
como la contratacion de trabajadores, la programacion de tareas y al hacer una oferta en
subastas en b usqueda de patrocinados.
Palabras Clave: Knapsack(Mochila), OPENMP, Threads(Hilos).
Figura 1: Knapsack Problem
1. Introducci on
El problema de la mochila es uno de los 21
problemas NP-completos de Richard Karp, esta-
blecidos por el informatico teorico en un famoso
artculo de 1972[2].
La idea conceptual que se nos muestra es simple
mas no su solucion, fue referenciado en 1897 en un
artculo de George Ballard Mathews[3].
Conectividad en Grafos y el problema de
la mochila son problemas clasicos en los que
se puede implementar mediante un ordenador
ADN [7]. Estos problemas se pueden resolver
por los ordenadores convencionales en tiempo
polinomial(seudo-polinomica para la mochila), pe-
ro solo en la medida en que son los sucientemente
peque nos en la memoria. Computadoras de tipo
ADN utilizando programacion dinamica podran
resolver problemas de dimensiones sustancialmente
mayor debido a su gran capacidad de memoria en
comparacion a ordenadores convencionales.
La realizacion de este artculo surgio por una
idea simple que se presenta en nuestra casa, los
programas de television, todo programa de televi-
sion antes de salir al aire necesita auspiciadores.
Para elegir a los auspiciadores se necesita de un
estudio previo, es decir jar un rango de preferen-
cias, ademas de la ganancia posible obtenida con
1
una cantidad de tiempo en que se presentara su
publicidad. En base a eso se tomara la decision
mas optima y que genere asi el mayor benecio
posible tanto al programa como a la televisora.
En terminos generales, el problema de la
mochila[10] aparece en los procesos de toma
de decisiones del mundo real en una amplia varie-
dad de campos, tales como la b usqueda de la forma
menos dorrochadora para cortar materia prima,
concurso de asientos de inversiones y carteras,
asientos en concurso de activos para activos de
titulizacion respaldados y la generacion de claves
para la Merkle-Hellman Knapsack cryptosystem.
Por esto el estudio y desarrollo del problema
de la mochila con el algoritmo de programacion
dinamica y aun mejor paralelizado resulta util.
Justicacion Matematica
El problema de la mochila es un problema de
optimizacion matematica[4] que trata de hallar
una solucion x
de un conjunto S que cumple las

siguientes condiciones:
x S = {x
1
, x
2
, ...., x
n
} , x
= x
Si x S, f(x
) f(x)
Programacion lineal
Si un modelo de optimizacion[11] usa progra-
macion lineal, entonces las funciones que lo
componen(funcion objetivo y restricciones) son
lineales.
Funcion objetivo:
max
n
i=1
c
i
x
i
donde, c
i
: coecientes y x
i
: variable de decision.
Restricciones:
n
i=1
a
ij
x
i
R
j
donde, a
ij
: coecientes y R
j
: restricciones.
Para la denicion del problema se usara el
enfoque de programacion lineal entera binaria,la
cual tiene variables de decision al conjunto solu-
cion x
1
, x
2
, ..., x
n
donde x
i
Z y x
i
0, 1 , con
restriccion del W(peso max).
Problema de la Mochila
Existen n elementos que poseen dos caratersticas:
valor v
i
y peso w
i
, los cuales seran introducidos en
un contenedor de tal manera que se maximice el
valor acumulado (v
1
, v
2
, ..., v
n
) de los objetos y no
sobrepase la capacidad maxima del contenedor W.
Los objetos seran los x
i
que tendran un v
i
y un w
i
, estos x
i
pueden tomar el valor de 1 si
se introduce o 0 si no se introduce en el contenedor.
Matematicamente[9]:
Se busca la funcion objetivo:
max
n
i=i
v
i
x
i
de tal manera que:
i = 1, 2, ...n, x
i
0,1y
n
i=1
w
i
x
i
W
2. Algoritmos
2.1. Fuerza bruta
Se tiene el vector solucion (x
1
, x
2
, ..., x
n
) donde
x
i
0, 1, luego se busca todas las combinaciones
de este vector con el n que satisfaga la funcion
objetivo y cumpla las restricciones.
Si se considera a (x
1
, x
2
, ..., x
n
) la solucion
del problema, entonces haberla encontrado to-
mara 2 x 2 x....x 2 x 2 as sucesivamente n veces
casos para hallarla.
Veamos un algoritmo:
2
Inicio del programa:
mochila(w,v,W,n):
w:vector de pesos
v:vector de valores
W:Peso total
n:cantidad de items
i f ( n==0 or W==0)
//Caso base en e l que no hay obj e t os
//( n=0) o e l peso es 0
r et ur n 0;
i f (w[ n1]>W)
// Si wk > W
// ent onces e l obj et o no s e es coge
r et ur n mochi l a (W, w, v , n1);
// Si e l obj et o k es es cogi do ent onces
//su peso es r es t ado del t o t a l y
//su val or v [ k ] es cons i der ado
// par t e de l a s ol uc .
e l s e :
r et ur n max( v [ n1]+
mochi l a (W w[ n1] , w, v , n1) ,
mochi l a (W, w, v , n1));
Fin del programa
Desarrollando el arbol de recursion se observa
que la solucion crece de manera exponencial, por
lo tanto su complejidad sera:
O(2
n
)
2.2. Algoritmo Genetico
Generamos una poblacion de individuos[6]
cuyos cromosomas(conjunto de genes) simbolizan
una solucion del problema. La representacion del
individuo es binaria de la forma(0,1,1,1,0,0,1)
donde el n umero de bits en el cromosoma de cada
individuo es el n umero de objetos disponible. En
este caso existiran 7 objetos disponibles, donde si
un gen toma el valor de 1 signica que ingreso al
contenedor y 0 si no lo hizo.
El algoritmo general de un algoritmo genetico
es el siguiente:
1. Inicalizacion de la poblacion
2. Evaluacion de la poblacion
3. Mientras(no se llegue a la condicion de n)
4. Seleccion de padres:
5. Recombinacion
6. Mutacion
7. Evaluacion
8. Seleccion de supervivientes
Figura 2: Combinacion y mutacion de cromosomas
En la gura 2 se muestra el proceso de combina-
cion y mutacion, los dos primeros cromosomas se
combinan, es decir comparten genes a sus descen-
dientes, y forman los cromosomas (1,1,1,1,0,0,1) y
(0,0,0,0,1,1,1).
Luego existe una peque na probabilidad que el
cromosoma mute como se da en el caso del quinto
cromosoma(1,0,0,1,0,1,1) que muta al cromosoma
(1,1,0,1,0,0,1).
El algoritmo se ejecuta por generaciones has-
ta lograr obtener un individuo que cumpla con
las caractersticas optimas, luego este individuo
sera la solucion para el problema.
3
Este metodo es rapido y no ocupa mucha
memoria, por contra parte obtiene una solucion
aproximada, en muchos casos es exacta, pero en
otros casos podria no serlo generando un grado de
incertidumbre que sera adecuado dependendiendo
de lo que busquemos.
2.3. Programaci on dinamica
Basicamente la eciencia de este metodo es
resolver los subproblemas una sola vez, luego
guardar cada solucion en una tabla para su futuro
uso[8].
Aplicado a la resolucion de problemas de op-
timizacion se basa en el principio de optimalidad:
En una secuencia de decision optima toda
subsecuencia ha de ser tambien optima
Dadas 2 tuplas:
v
1
, v
2
, v
3
, ..., v
n
y w
1
, w
2
, w
3
, .., w
n
, y W>0.
Queremos determinar un subconjunto T tal que:
Maximice T,
sujeto a T <=W.
Esto signica que dados n items de peso w
i
y valor v
i
, encontrar los items tal que al ser
tomados, estos sean menor al valor maximo W y a
su vez correspondan al valor maximo posible.
Podemos darle el valor de (1) si fue conside-
rado en la solucion o de (0) si no.
Sea A(i,j) quien representa el maximo valor
que puede ser obtenido si el peso maximo es W
y los items son elegidos de 1,...,i. Optamos por la
siguiente denicion recursiva:
Este problema se presenta tanto en subproblemas
superpuestos y subestructura optima y por lo
tanto es un buen candidato para la programacion
dinamica.
Algoritmo:
Primero, ingresamos el n umero total de items,
pesos, y valores de cada item. Luego ingresamos el
maximo peso(maxWeight). Finalmente calculamos
el maximo valor que puede ser obtenido usando la
funcion Knapsack.
Funcion Knapsack:
Esta funcion toma el n umero total de items,
el peso de cada item(weight), el valor de cada
item(value) y el peso maximo(maxWeight) como
argumentos. Que retornara el maximo valor que
pueda ser obtenido de estos items, considerando
tambien el conjunto de items seleccionados.
Declaramos vmax[items+1][maxWeight+1]. Donde
vmax[i][w] representa el maximo valor que puede
ser obtenido si el peso maximo resultara w y los
items elegidos : 1,..,i.
vmax[0][w] = 0 para todo w porque hasta el
momento hemos elegido 0 items. vmax[i][0]=0
para todo w porque el maximo peso que podemos
obtener es 0.
Recurrencia:
f or i =1 to i tems
f or w=0 to maxWeight
vmax[i][w] = vmax[i-1][w], si no tomamos el
item i. Si w-weight[i]>=0, supongamos que
tomamos este item, entonces vmax[i][w] =
max(vmax[i][w],vmax[i-1][w-weight[i]+ value[i]]).
Donde, max es la funcion que retorna el maximo
de los 2 argumentos que toma.
Luego para hallar el conjunto de elementos
que toma recorremos la matriz que nos queda
empezando de atras hacia adelante. Considerando
que se evaluaran solo si son mayores a cero y
si vmax[iter][w] != vmax[iter-1][w] cubriendo el
vector x que guardara las soluciones con 1 si es
que no es el maximo y vamos restandole los pesos
guardados en el vector weight:
4
i t e r=i tems ;
w=maxWeight ;
whi l e ( i t e r >0 && w>0)
{
i f (vmax [ i t e r ] [ w] ! =vmax [ i t e r 1] [w] )
{
x [ i t e r ] =1;
w=wwei ght [ i t e r ] ;
}
i t e r ;
}
Finalmente retorna el valor maximo posible que fue
guardado en la matriz: vmax[items][maxWeight].
3. Implementaci on Secuencial
La implementacion secuencial se basa en la
idea del uso de una matriz basandon os en la
programacion dinamica para subdividir las tareas
y asi lograr tareas independientes.
Cada elemento de la matriz contiene un valor
maximo considerando la cantidad de espacio
posible segun su posicion.
Las columnas van desde el peso 0 al peso maximo,
mientras que las las nos permiten analizar 1er
item; 1er y 2do item; 1er,2do y 3er item; asi suce-
sivamente hasta analizar todos los item ingresados
en la matriz.
De esta forma al recorrer las las consideran-
do los items uno a uno podremos tener el peso
minimo y el valor maximo
Luego al tener el valor maximo recorrer la
ultima columna para asi guardar con 0s y 1s en un
vector solucion indicando que no se encuentra o si
se encuentra respectivamente.
Finalmente la impresion de los item seleccio-
nados se dara imprimiendo las posiciones que
hayan sido llenadas con 1s.
Siendo su complejidad O(n*W) donde n es el
n umero de objetos y W el peso maximo.
//Retorna el valor maximo
int max(int a,int b)
//Funcion knapsack
//encargada de hallar valor max
//y conjuntos de items
int Knapsack(int items,int weight[],
int value[],int maxWeight)
{
//Declaracion de las variables
//Llenado de la fila 0 y columna 0
for(iter=1;iter<=items;iter++)
{
for(w=0;w<=maxWeight;w++)
{
//Caso en que no se toma el item
vmax[iter][w] = vmax[iter-1][w];
//En caso que considerando
//el peso es posible tomar el item
if(w-weight[iter] >=0)
{
//funcion encargada de tomar
//el valor max entre
//el subconjunto anterior
//o el objeto actual
vmax[iter][w] = max(vmax[iter][w],
vmax[iter-1][w-weight[iter]]+value[iter]
}
}
}
//Esta parte es la que se encarga
//de devolvernos el conjunto de items
//Se llena de 0s el vector soluc x
x[iter]=0;
//Recorro la ultima columna
//Esto debido a que
//esta columna guarda los valores max
//tomando en cuenta los respect items
iter=items;
w=maxWeight;
while(iter>0 && w>0)
{
if(vmax[iter][w]!=vmax[iter-1][w])
{
//Llena de 1s si esta dentro
5
//del conj que nos da el valor max
x[iter]=1;
w=w-weight[iter];
}
iter--;
}
printf("conj d items..");
//consideramos el conj d items
//coincidiendo las posiciones
//con los items
//si la posicion guarda 1
//imprimimos los items
//pues estan considerados en la sol
if(x[iter]==1)
printf(" %d\t",iter);
//Finalmente retornamos el valor max
return vmax[items][maxWeight];
}
//main llama a todas la funciones
int main()
{
//se ingresa la cant de items
//y el peso y valor de c/u
//tamb el peso max
//se llama a la funcion knapsack
//usando los parametros ingresados
}
Un caso de ejemplo seria:
items=3
peso[1]=1 y valor[1]=2
El peso maximo=3
Siendo el item 3 elegido.
EL desarrollo de la matriz de valores maxi-
mos seria la siguiente:
i/w 0 1 2 3
0 0 0 0 0
1 0 2 2 2
2 0 2 4 6
3 0 2 4 8
vmax[iter][maxWeight]=8 = valor maximo.
4. Implementaci on Paralela
La idea surge en utilizar las subtareas indepen-
dientes para aminorar el tiempo de trabajo y asi
optimizar el programa. En esta etapa se usaran
hilos(threads) con la API(Interfaz de programa-
cion de Aplicaciones); es decir, mas propiamente
OPENMP.
Que nos permite a nadir concurrencias en pro-
gramas escritos en C, como es nuestro caso.
La parte que se busca paralelizar del codigo
en C es:
{
for(w=0;w<=maxWeight;w++)
{
vmax[iter][w] = vmax[iter-1][w];
if(w-weight[iter] >=0)
{
vmax[iter][w] = max(vmax[iter][w],
vmax[iter-1][w-weight[iter]] +
value[iter]);
}
}
}
La parte secuencial que quedara de la funcion
knapsack seran las sentencias donde el vector
solucion es llenado que no implica mucha compu-
tacion y al recorrer solo una columna de la matriz
tiene complejidad n, siendo n la cantidad de items.
Por lo que su compejidad seria O((n/procs)*W+n).
La idea de plasmar estas 2 diferencias es mostrar
que estamos sujetos al coste secuencial es decir
mostrar a modo educativo que por mas procesa-
dores o rapidez tengamos si existen dependencias
6
esa parte del codigo se ejecuta de manera se-
cuencial imposibilitando la paralelizaci on pues
la aceleracion potencial de un algoritmo en una
plataforma de computo en paralelo esta dada por
la ley de Amdahl, formulada originalmente por
Gene Amdahl en la decada de 1960.
Esta se nala que una peque na porcion del programa
que no pueda paralelizarse va a limitar la acelera-
cion que se logra con la paralelizacion.[11]
Siendo la parte secuencial la siguiente:
while(iter>0 && w>0)
{
if(vmax[iter][w]!=vmax[iter-1][w])
{
x[iter]=1;
w=w-weight[iter];
}
iter--;
}
Finalmente para paralelizar el problema se usara el
modelo de memoria compartida usando la libera
OpenMP. Para poder lograr este cometido no debe
de existir dependencias entre las porciones que se
delegaran a cada thread, es decir, siendo f(n) una
funcion entonces f(n) no debe depender de f(n-1).
En el problema de la mochila las dependen-
cias se dan entre las diferentes las, por ende,
vmax[i][w] depende de los valores de vmax[i-1][w],
vmax[i-1][w-2],..,vmax[i-1][0], pero no existe de-
pendencia dentro de una misma columna; esto es
vmax[i][w] no depende de vmax[i][w-1], asu vez
este no depende de vmax[i][w-2], asi sucesivamente
hasta el caso de vmax[i][0].
Por lo tanto la paralelizacion es factible, lue-
go dividimos la la i de la matriz entre el n umero
de threads en diferentes secciones de tal manera
que cada thread estara trabajando en su propia
seccion de la la y luego rellene la la con valores
calculados de vmax[i][w].
Cuando todos los threads han acabado en la
la i se pasa a la siguiente la i+1, as su-
cesivamente hasta la la n, hacemos uso de
openmp barrier para asegurar que todos los hilos
hayan terminado y asi puedan pasar ala siguiente
seccion a trabajar.
Como se muestra en el siguiente codigo:
//Se omite las declaraciones
//de las variables privadas
//y compartidas por simpleza
#pragma omp parallel
private(thread,i,w,t,weight,value)
shared(numThreads,items,vmax,maxWeight)
{
{
#pragma omp for
for (int w = 0; w < maxWeight+1; ++w){
if (i == 0 or w == 0) //caso base
vmax[i][w] = 0;
else if (weight[i-1]<= w){
//lo toma y compara
vmax[i][w] = max(vmax[i-1][w],
vmax[i-1][w - weight[i-1]]+value[i-1]);
}//fin del else if
else
//caso en el que no lo toma
vmax[i][w] = vmax[i-1][w];
}//fin del for paralelizable
}//fin del for general
//retorna vmax[items][maxWeight]
//que es el valor maximo
}//fin del omp parallel
//La parte del vector solucion se obvia
//pues es la misma de la implementacion
secuencial
7
5. Resultados
5.1. Implementaci on Secuencial:
Notamos que para la implementacion secuencial
debemos ingresar gran cantidad de n umeros para
que se pueda apreciar el lapso de tiempo en que
es ejecutada la funcion Knapsack, por este motivo
hacemos uso de la funcion random para generar
n umero aleatorios que llenen los vectores de peso
y valores.
Ahorrando asi el ingreso manual de cada da-
tos que se complica cuanto mas grande es la
cantidad de datos que se tendran que ingresar.
Recordemos que en este tipo de implementa-
cion el procesador lee la matriz la a la teniendo
una complejidad igual a la cantidad de items ingre-
sados por el peso maximo soportado por la mochila.
Ejemplo:
Ingrese la cantidad de objetos a procesar:
5
Ingrese peso[1] y valor[1]
1 4
2 5
3 2
5 9
7 7
Ingrese el peso maximo que sera soportado
por la mochila: 10
Matriz de valores maximos:
i/w 0 1 2 3 4 5 6 7 8 9 10
0 0 0 0 0 0 0 0 0 0 0 0
1 0 4 4 4 4 4 4 4 4 4 4
2 0 4 5 9 9 9 9 9 9 9 9
3 0 4 5 9 9 9 11 11 11 11 11
4 0 4 5 9 9 9 13 14 18 18 18
5 0 4 5 9 9 9 13 14 18 18 18
Conjunto optimo de soluciones:
1 2 4
El maximo valor obtenido sera: 18
Knapsack tomo 0.000020 segundos.
Notando asi que para pocos elementos el tiempo
empleado para procesarlos y obtener el valor
maximo es practicamente 0 segundos.
Caso del uso de la funcion random:
Capacidad de la mochila 5000
Cantidad de objetos 200
max valor 80
max peso 95
tiempo: 0.10000 segundos
vmax=6830
Notando asi que el tiempo aun es menor a
uno pero que posiblemente pueda ser optimizado
ejecutandolo en paralelo.
8
5.2. Implementaci on Paralela
En este tipo de implementacion nos valemos de
la dependencia entre las y la independencia entre
columnas al momento de compara el valor maximo
entre el nuevo item o el subconjunto ya escogido.
Como la idea es notar la disminucion de tiempo con
forme aumentan la cantidad de threads entonces
hacemos uso de la funcion random que nos genera
n umeros aleatorios.
Ejemplo:
Cantidad de items usados:4
Peso maximo soportado por la mochila:5
El max valor posible es V(N,W) = 8
Tiempo = 0.000007 segundos
Numero de nodos = 2
Conjunto optimo de soluciones:
item:3
Cantidad de objetos: 4
peso[1]=7 ,valor[1]=5
Matriz de valores maximos:
w=0 w=1 w=2 w=3 w=4 w=5
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 8
0 5 5 5 5 8
5.3. Caratersticas Fsicas:
Para ejecutar estos programas se hicieron uso
de una maquina local (local host) y una maquina
virtual.
Caractersticas fsicas de la maquina local:
Sistema Operativo: Windows 7 Ultimate @ 2009
Procesador:
Intel(R) Core (TM) i7-3770 CPU
@ 3.40 GHz 3.39 GHz
RAM : 4.00 GB (3.68 GB utilizable)
Tipo de Sistema: S.O. de 64 bits
Nucleos : 4
Caractersticas fsicas de la maquina virtual:
Sistema operativo: Debian
Memoria base: 1024MB
Procesadores: 4
Orden de arranque: Disco duro
Aceleracion: VT-x/AMD-V, Paginacion anidada
Memoria de video: 12MB
Almacenamiento:
Controller:IDE Controller
Controller: SATA Controller
Puerto SATA 0: DebianCC.vdi(Normal, 20GB)
9
5.4. Gracas:
Estas gracas fueron realizadas con los resul-
tados de la paralelizacion y la implementacion
secuencial, usando el programa Minitab version
16.Muestran los tiempos que le toman realizar la
funcion knapsack de acuerdo a la cantidad de hi-
los(threads) usados y el tiempo que tomo realizarlo
de forma secuencial, considerando para cada caso
la capacidad maxima soportada por la mochila y
por ultimo el peso y valor de cada item, los valores
maximos posibles tanto para el peso como para el
valor de cada item usando la funcion random.
Datos graca 1:
Paralelo:
/*Datos para funcion random en cada item*/
max valor 20
max peso 25
Secuencial: 0.00000 segundos
Figura 3: Hilos vs Tiempo(seg) I
Linea azul: Secuencial
Linea roja: Paralelo(1,2,3,4)
Datos graca 2:
Paralelo:
Datos usados:
Valores maximos usados en la funcion ran-
dom:
max valor 80
max peso 95
Tiempo de ejecucipon para la implementacion
Secuencial:
0.10000 segundos
Figura 4: Hilos vs Tiempo(seg) II
10
Datos graca 3:
Paralelo:
Datos usados:
Valores Maximos para la funcion random:
max valor 80
max peso 95
Tiempo de ejecucion para la implementacion
Secuencial:
0.20000 segundos
Figura 5: Hilos vs Tiempo(seg) III
Datos graca 4:
Paralelo:
Datos usados:
Valores Maximos para la funcion random:
max valor 80
max peso 95
Tiempo de ejecucion para la implementacion
Secuencial:
Segmentation fault
Figura 6: Hilos vs Tiempo(seg) IV
11
Datos graca 5:
Paralelo:
max valor 80
max peso 95
Secuencial: segmentation fault
Figura 7: Hilos vs Tiempo(seg) V
6. Discusiones
Como podemos observar claramente, al principio
los tiempos no disminuyen del todo pues a poca
cantidad de datos el tiempo de comunicacion es
mayor que el tiempo que se demoran en proce-
sarlo.Pero a mayor cantidad de datos el tiempo
disminuye sustancialmente al usar 1,2,3 y 4 hilos,
como se aprecian en los gracos antes mencionados.
Recordando que los valores maximos son ubicados
en la matriz vmax en el caso de la implementacion
secuencial y V en el caso de la implementacion
paralela.
En el primer caso(Figura 3) notamos que es
mas rapido trabajarlo en secuencial por el tama no
de la data a analizar pero el segundo caso nos
muestra claramente la disminucion del tiempo
entre trabajarlo en paralelo y trabajarlo a modo
secuencial.
En casos ya muy grandes como los 2 ultimos
gracos notamos que la computadora no puede
analizar por si sola tanta data ocurriendo lo ya
conocido como segmentation fault en el cual la
computadora devuelve un mensaje que anuncia
que no puede procesar los datos y procede a darles
un n abrupto.
7. Conclusiones
Se concluye que la disminucion de tiempo es
notoria al usar la programacion paralela con ayuda
de la programacion dinamica pero bajo ciertas
restricciones como la cantidad de objetos pues
al procesar poca cantidad de data es mayor el
tiempo de comunicacion que el tiempo de ejecucion.
8. Ideas a futuro
Es dicil analizar el problema de la mochila
en sus orgenes pues no es posible asegurar con
certeza cuando empezo esta idea o concepto.
Podemos aproximar y suponer que desde el hecho
de querer tomar decisiones sobre determinados
productos ya sea para compras, ventas, benecios
de algun tipo hasta temas como la salud; notamos
que estamos rodeados todo el tiempo de la idea de
tomar una decision pues lo encontramos dia a dia
desde presupuestar nuestro gasto diario hasta el
de un gobierno.
La idea es ir mas alla de lo simple buscando
y analizando casos simples pero concretos y crean-
do por ejemplo: aplicaciones para celulares que
te permitan una vez ubicada la lista de compras
segun un rango de prioridad obtener tus productos
a un costo mnimo, algo que seria muy util para
las amas de casa. Otra posible aplicacion seria
para los usuarios de redes sociales pues se podria
12
Figura 8: Aplicaciones para celulares
colocar mediante el uso de una base de datos
como facebook, segun sus preferencias ahorrarles
la necesidad de decidir sobre ir a que conciertos
contando con una cantidad de dinero especco, o
incluso un aplicativo de que cita es mejor para ti
este n de semana.
Figura 9: Ideas nuevas
Despues de todo el mundo entero esta envuelto en
decisiones, es algo que siempre implicara riezgos
por eso es mejor considerarlo como una oportuni-
dad y no como un obstaculo.
Referencias
[1] Babaio, Immorlica, Kempe, Kleinberg. A
Knapsack Secretary Problem with Applica-
tions. 2007
[2] Richard M. Karp. Reducibility Among
Combinatorial Problems.R.E.Miller,
J.W.Thatcher.Complexity of Compu-
ter.1972.Nueva York.Paginas 85-103.
[3] G.B.Mathews, On the partition of num-
bres,Proceedings of the London Mathematical
Society.1897.Paginas:486-490.
[4] Kellerer, Hans; Pferschy, Ulrich; Pisinger, Da-
vid(2004). Knapsack Problems.
[5] Eric Gosset. Discrete Mathematics with
Proof.2da Edicion.John Willey.2009.
[6] Manuel ruiz de Quintanilla Foncubierta. Di-
se no,Aplicacion y Evaluacion de un Algoritmo
Evolutivo.2008-2009.Pag:38-40.
[7] Eric B. Baumm,Dan Bonch. Running dynamic
programming algorithms on a DNA compu-
ter.NEC Research Institute.2001.Pag:1-3
[8] Steve Goddard. Dynamic programming. Data
Structures and Algorithms. 2004. Pag:1-10
[9] David Pisinger. Algorithms for Knapsack Pro-
blems.Ph.D. thesis,February 1995. Pag:11-13
[10] Wikipedia:
http : //en.wikipedia.org/wiki/Knapsack
p
roblem
[11] Amdahl, Gene M. (18-20 de abril de 1967). Va-
lidity of the single processor approach to achie-
ving large scale computing capabilities.
[12] Figura 1 : Knapsack Problem:
http://commons.wikimedia.org/wiki/ File:
Knapsack.svg
[13] Figura 2: Combinacion y mutacion de cromo-
somas:
http://www.google.com/patents/US6182057
[14] Figura 8: Aplicaciones para celulares:
http://www.chrassus.com/wp-
content/uploads/2011/06/ganar-dinero-
aplicaciones-para-celulares.jpg
13
[15] gura 9: Ideas:
http://www.loquequierasya.com/wp-
content/uploads/2013/10/ideas-de-negocio-
2013.jpg
14

Problema de La Mochila

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Problema de La Mochila

Enviado por

Direitos autorais:

Formatos disponíveis

Problema de la mochila 0/1:

de un conjunto S que cumple las

Você também pode gostar