Monografia - Problema de la Mochila

UNIVERSIDAD NACIONAL DE TRUJILLO

Facultad de Ciencias Físicas y

Matemáticas

Escuela Profesional de Informática

MONOGRAFIA

PROBLEMA DE LA MOCHILA

Autores :

Malpartida Aranda Vanessa Jaqueline

Sánchez Aranda Erwin Joao

TRUJILLO- PERU

2014

P á g i n a | 2

INDICE 1. Dedicatoria ...................................................................................................................... 3

2. Introducción ..................................................................................................................... 4

3. Marco Teórico ................................................................................................................. 5

3.1. Realidad Problemática ............................................................................................. 5

4. Capítulo I: Conceptos y Algoritmos ................................................................................ 5

4.1. Backtracking ............................................................................................................ 5

4.2. Algoritmo Voraz ...................................................................................................... 6

5. Capítulo II: Problema de la Mochila ............................................................................... 8

5.1. Definición ................................................................................................................ 8

5.2. Planteamiento del problema ..................................................................................... 8

5.3. Solución Óptima ...................................................................................................... 8

5.4. Código en Prolog ..................................................................................................... 9

6. Conclusiones ................................................................................................................. 11

7. Anexos ........................................................................................................................... 11

8. Referencias .................................................................................................................... 12

8.1. Bibliográficas ......................................................................................................... 12

8.2. Webgráficas ........................................................................................................... 12

P á g i n a | 3

1. Dedicatoria

A los estudiantes de

Ciencias de la Computación,

investigadores interesados en la

resolución de problemas computacionales

y personas interesadas en el lenguaje de

programación Prolog.

A nuestros docentes, familiares que día a

día nos apoyan en nuestra formación no

solo académica sino también social y a

nuestros compañeros, con quienes

intercambiamos valioso conocimiento.

P á g i n a | 4

2. Introducción El problema de la mochila, comúnmente abreviado por KP (proveniente del inglés Knapsack Problem), es un problema de optimización combinatoria, es decir, que busca la mejor solución entre un conjunto de posibles soluciones a un problema.

Este problema es uno de los 21 problemas NP-completos de Richard Karp, establecidos por el informático teórico en un famoso artículo de 1972. Ha sido intensamente estudiado desde mediados del siglo XX y se hace referencia a él en el año 1897, en un artículo de George Mathews Ballard.

En teoría de la complejidad computacional, NP es el acrónimo en inglés de nondeterministic polynomial time ("tiempo polinomial no determinista"). Es el conjunto de problemas que pueden ser resueltos en tiempo polinómico por una máquina de Turing no determinista.

La importancia de esta clase de problemas de decisión es que contiene muchos problemas de búsqueda y de optimización para los que se desea saber si existe una cierta solución o si existe una mejor solución que las conocidas. En esta clase están por ejemplo, el problema del viajante (también llamado "problema del viajante de comercio" o "problema del agente viajero") donde se quiere saber si existe una ruta óptima que pasa por todos los nodos en un cierto grafo y el problema de satisfacibilidad booleana en donde se desea saber si una cierta fórmula de lógica proposicional puede ser cierta para algún conjunto de valores booleanos para las variables.

Dada su importancia, se han hecho muchos esfuerzos para encontrar algoritmos que decidan algún problema de NP en tiempo polinómico. Sin embargo, pareciera que para algunos problemas de NP (los del conjunto NP-completo) no es posible encontrar un algoritmo mejor que simplemente realizar una búsqueda exhaustiva.

La clase de complejidad NP-completo es el subconjunto de los problemas de decisión en NP tal que todo problema en NP se puede reducir en cada uno de los problemas de NP-completo. Se puede decir que los problemas de NP-completo son los problemas más difíciles de NP y muy probablemente no formen parte de la clase de complejidad P. La razón es que de tenerse una solución polinómica para un problema NP-completo, todos los problemas de NP tendrían también una solución en tiempo polinómico.

Si bien la formulación del problema es sencilla, su resolución es más compleja. Algunos algoritmos existentes pueden resolverlo en la práctica para casos de un gran tamaño. Sin embargo, la estructura única del problema, y el hecho de que se presente como un subproblema de otros problemas más generales, lo convierten en un problema frecuente en la investigación.

En esta monografía se abordarán algoritmos utilizados para resolver el problema de la mochila para luego explicar paso a paso su implementación en lenguaje Prolog.

P á g i n a | 5

3. Marco Teórico

3.1. Realidad Problemática

Actualmente se ha visto una decadencia en lo referente a investigación de los problemas computacionales convencionales, poco interés de parte de los estudiantes de Ciencias de la Computación . Sin embargo, el problema abordado en esta monografía, resulta de mucha utilidad para poder entender mejor algoritmos de búsquedas y selección, ya que resulta no muy complicado de analizar y posteriormente sencillo de implementar. Esto será logrado mediante el lenguaje de programación Prolog, que gracias a su proceso de Backtracking, nos permitirá un mejor manejo de los procedimiento para la obtención de resultados, siendo ventajoso al mismo tiempo el aumento de nivel de conocimiento que brinda a los estudiantes, quienes posteriormente al utilizar esta tecnología serán capaces de resolver problemas de este tipo sin la complejidad que podrían haber tenido antes.

4. Capítulo I: Conceptos y Algoritmos

4.1. Backtracking

También llamado Vuelta Atrás, es una estrategia para encontrar soluciones a problemas que satisfacen restricciones. El término "backtrack" fue acuñado por primera vez por el matemático estadounidense D. H. Lehmer en la década de 1950. En su forma básica, la idea de backtracking se asemeja a un recorrido en profundidad dentro de un grafo dirigido. El objetivo del recorrido es encontrar soluciones para algún problema. La ejecución en Prolog se basa en el concepto del backtracking así como de la unificación, gracias a la segunda, cada objetivo determina un subconjunto de cláusulas susceptibles de ser ejecutadas. Cada una de ellas se denomina punto de elección. Prolog selecciona el primer punto de elección y sigue ejecutando el programa hasta determinar si el objetivo es verdadero o falso. En caso de ser falso entra en juego el backtracking que funciona de la siguiente manera:

Cuando se va ejecutar un objetivo, Prolog sabe de antemano cuantas soluciones alternativas puede tener. Cada una de las alternativas se denomina punto de elección. Dichos puntos de elección se anotan internamente y de forma ordenada. Para ser exactos, se introducen en una pila.

Se escoge el primer punto de elección y se ejecuta el objetivo eliminando el punto de elección en el proceso.

Si el objetivo tiene éxito se continúa con el siguiente objetivo aplicándole estas mismas normas.

Si el objetivo falla, Prolog da vuelta atrás recorriendo los objetivos que anteriormente sí tuvieron éxito y deshaciendo las ligaduras de sus variables. Es decir, comienza el backtracking.

P á g i n a | 6

Cuando uno de esos objetivos tiene un punto de elección anotado, se detiene el backtracking y se ejecuta de nuevo dicho objetivo usando la solución alternativa. Las variables se ligan a la nueva solución y la ejecución continúa de nuevo hacia adelante. El punto de elección se elimina en el proceso.

El proceso se repite mientras haya objetivos y puntos de elección anotados. De hecho, se puede decir que un programa Prolog ha terminado su ejecución cuando no le quedan puntos de elección anotados ni objetivos por ejecutar en la secuencia. Además, los puntos de elección se mantienen aunque al final la conjunción tenga éxito. Esto permite posteriormente conocer todas las soluciones posibles.

El siguiente es un algoritmo genérico de backtracking:

Donde:

Solución? (·) es una función que retorna verdadero si su argumento es una solución. procesarSolucion (·), depende del problema y que maneja una solución. Sucesores (·) es una función que dado un candidato, genera todos los candidatosque son extensiones de este. Terminar?es una variable global booleana inicialmente es falsa, pero que puedeser hecha verdadera por procesarSolucion, en caso que solo interesa encontrar una solución.

4.2. Algoritmo Voraz

Un algoritmo voraz también conocido como ávido, devorador o goloso es aquel que, para resolver un determinado problema, sigue una heurística consistente en elegir la opción óptima en cada paso local con la esperanza de llegar a una solución general óptima. Una forma de ver los algoritmos voraces es considerar la estrategia de Vuelta atrás, en la cual se vuelve recursivamente a decisiones anteriormente tomadas para variar la elección entonces tomada, pero eliminando esa recursión y eligiendo la mejor opción. Los algoritmos voraces tienden a ser bastante eficientes y pueden implementarse de forma relativamente sencilla. Su eficiencia se deriva de la forma en que trata los datos, llegando a alcanzar muchas veces una complejidad de orden lineal. Sin embargo, la mayoría de los intentos de crear un algoritmo voraz correcto fallan a menos que exista previamente una prueba precisa que demuestre la correctitud del algoritmo.

P á g i n a | 7

Un algoritmo voraz funciona por pasos:

Inicialmente partimos de una solución vacía.

En cada paso se escoge el siguiente elemento para añadir a la solución, entre los candidatos.

Una vez tomada esta decisión no se podrá deshacer.

El algoritmo acabará cuando el conjunto de elementos seleccionados

constituya una solución.

Esquema general de un algoritmo voraz:

Donde: solución(S).Comprueba si un conjunto de candidatos es una solución

(independientemente de que sea óptima o no).

seleccionar(C). Devuelve el elemento más “prometedor” del conjunto de candidatos pendientes.

factible (S, x). Indica si a partir del conjunto S y añadiendo x, es posible construir una solución.

insertar (S, x). Añade el elemento x al conjunto solución. Además, puede ser necesario hacer otras cosas.

P á g i n a | 8

5. Capítulo II: Problema de la Mochila

5.1. Definición Se modela una situación análoga al de llenar una mochila, incapaz de soportar más de un peso determinado, con todo o parte de un conjunto de objetos, cada uno con un peso y valor específicos. Los objetos colocados en la mochila deben maximizar el valor total sin exceder el peso máximo. El problema de la mochila es definido formalmente como: “Se tiene una determinada instancia de KP con un conjunto de objetos N, que consiste de n objetos j con ganancia pj y peso wj, y una capacidad C, usualmente, los valores son tomados como números enteros positivos. El objetivo es seleccionar un subconjunto de N tal que la ganancia total de esos objetos seleccionados es maximizado y el total de los pesos no excede a c.”

El problema se puede expresar matemáticamente por medio del siguiente programa

lineal:

5.2. Planteamiento del problema

"Se tiene una mochila de emergencia que es capaz de soportar un peso máximo P, así como un conjunto de objetos, cada uno de ellos con un peso y un valor de prioridad. La solución pasa por conseguir introducir el máximo valor en la mochila, eligiendo los objetos adecuados. Cada objeto debe tomarse completo”.

5.3. Solución Óptima

Si los objetos ingresados a la mochila, cumplen con la restricción de que la suma de sus pesos es menor o igual a la capacidad de la mochila y que la suma de sus valores es el máximo valor posible.

P á g i n a | 9

5.4. Código en Prolog

P á g i n a | 10

Donde al ejecutar por ejemplo lo siguiente:

Nos brindara la solución óptima, siendo para este caso:

Que maximiza el valor, obteniendo al final 136 con el peso de 4, en vez de una solución por fuerza bruta, que elegiría al primer elemento, completando el peso 4 pero con solo 92 de valor.

P á g i n a | 11

6. Conclusiones

Podemos concluir que si bien, se encuentra una solución óptima con la ayuda de los algoritmos voraces, esto solo es posible si es que la cantidad de objetos no es demasiado grande, caso contrario, el tiempo en que se tardaría para encontrar una solución sería enorme o simplemente podría fallar la búsqueda.

Nos damos cuenta, que el uso del lenguaje de programación Prolog, nos da ventajas debido a su proceso de Backtracking, el cual nos permite hallar el conjunto de soluciones de una manera entendible y rápida.

Finalmente tenemos que si se encuentra alguna forma de desarrollar un algoritmo para resolver los problemas de tipo NP-Completo, que no sea de la forma exhaustiva, se habrá hecho un gran hallazgo en el campo de las Ciencias de la Computación, además de que ese algoritmo creado, permitirá también su aplicación para todos los demás problemas de tipo NP-Completo de acuerdo a su definición.

7. Anexos

Glosario de Términos:

NP: En teoría de la complejidad computacional, NP es el acrónimo en inglés de nondeterministic polynomial time (tiempo polinomial no determinista). Es el conjunto de problemas que pueden ser resueltos en tiempo polinómico por una máquina de Turing no determinista.

NP-Completo: En teoría de la complejidad computacional, la clase de complejidad NP-completo es el subconjunto de los problemas de decisión en NP tal que todo problema en NP se puede reducir en cada uno de los problemas de NP-completo.

Prolog: proveniente del francés PROgrammation en LOGique, es un lenguaje para programar mediante el paradigma lógico con técnicas de producción final interpretada. Es bastante conocido en el área de la Ingeniería Informática para investigación en Inteligencia Artificial.

Backtracking: es una estrategia para encontrar soluciones a problemas que satisfacen restricciones. El término "backtrack" fue acuñado por primera vez por el matemático estadounidense D. H. Lehmer en la década de 1950.

Heurística: se define como un conjunto de reglas metodológicas no necesariamente forzosas, positivas y negativas, que sugieren o establecen cómo proceder y qué problemas evitar a la hora de generar soluciones y elaborar hipótesis

P á g i n a | 12

8. Referencias

8.1. Bibliográficas

1. Campos J, “Esquemas algorítmicos: Algoritmos voraces”. Consultado el 2104.

2. Tomas Bruno, “Modelos y Optimización”, Facultad de Ingeniería de la Universidad de Buenos Aires, 2013.

3. Velasco Álvarez Jonás, “Combinatoria”, Universidad Autónoma de Nuevo León. Consultado el 2014

4. Christos H. Papadimitriou, “Computational Complexity", USA, 1994.

5. Vijay V. Vazirani, “Approximation Algorithms”, Berlin, Germany, 2001.

6. Hans Kellerer, Ulrich Pferschy, David Pisinger, “Knapsack Problem", Berlin, Germany, 2004.

8.2. Webgráficas

1. http://es.wikibooks.org/wiki/Algoritmia/Algoritmos_voraces

2. http://es.wikipedia.org/wiki/Algoritmo_voraz

3. http://www.genbetadev.com/respuestas/que-es-el-backtracking

4. http://programacion.net/articulo/tutorial_basico_de_programacion_en_prolog_58/4

5. http://es.wikipedia.org/wiki/Vuelta_atr%C3%A1s

6. http://es.wikibooks.org/wiki/Programaci%C3%B3n_din%C3%A1mica/Problema_de_la_mochila