Herramienta para la visualización de algoritmos basados en programación dinámica

ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA

GRADO EN INGENIERA INFORMTICA

Curso acadmico 2014/2015

Trabajo Fin de Grado

Herramienta para la visualizacin de algoritmos basados en programacin

dinmica

Autor: Juan Antonio Sopale Thompson

Tutor: Manuel Rubio Snchez

Resumen

El siguiente trabajo trata sobre el desarrollo de una aplicacin orientada a la

resolucin de problemas de programacin dinmica. El desarrollo de esta

herramienta supone cubrir el ecosistema de aplicaciones pensadas en el

aprendizaje de algoritmos. El contexto de uso de la aplicacin ser educativo, es

decir, los alumnos podrn reforzar sus conocimientos en la materia mediante la

ejecucin de las visualizaciones.

Desde el punto de vista de la usabilidad, se trata de crear una aplicacin sencilla,

minimalista, que sea intuitiva de cara al usuario final. Con el diseo se busca

practicidad sin descuidar el estilo grfico.

NDICE 1. Introduccin .................................................................................................. 1

1.1 Programacin dinmica ............................................................................. 1

1.2 Objetivos ................................................................................................... 2

2. Herramientas de visualizacin de software ................................................... 3

3. Especificacin y anlisis de requisitos .......................................................... 9

3.1 Descripcin del problema .......................................................................... 9

3.2 Caractersticas de los usuarios .................................................................. 9

3.3 Requisitos funcionales ............................................................................. 10

3.4 Requisitos de interfaces externos ............................................................ 11

3.5 Requisitos de rendimiento ....................................................................... 11

3.6 Requisitos de desarrollo .......................................................................... 12

3.7 Requisitos tecnolgicos ........................................................................... 12

4. Descripcin de los problemas de la aplicacin ........................................... 13

4.1 Mochila 01 ............................................................................................... 13

4.2 Alineamiento de secuencias .................................................................... 16

4.3 Cortar una vara ....................................................................................... 19

4.4 Multiplicacin de matrices ........................................................................ 21

4.5 Subsecuencia comn ms larga .............................................................. 23

5. Modelo de negocio ..................................................................................... 25

5.1 Diagrama de casos de uso ...................................................................... 25

5.1.1 Detalle de casos de uso (flujo de eventos)........................................ 26

6. Diseo de la aplicacin ............................................................................... 35

6.1 Diagramas de clases ............................................................................... 35

6.2 Diagramas de clases en detalle ............................................................... 39

6.2.1 Subsistema de entrada de datos ...................................................... 39

6.2.2 Subsistema de visualizacin paso a paso ......................................... 42

6.2.3 Subsistema de ayuda ....................................................................... 44

6.2.4 Fichero ............................................................................................. 45

7. Diseo de la interfaz grfica ....................................................................... 47

7.1 Diseo del panel principal ........................................................................ 47

7.2 Diseo de los paneles de entrada ........................................................... 48

7.3 Diseo de los paneles de visualizacin paso a paso ............................... 52

7.3.1 Visualizacin de la mochila 0,1 ......................................................... 53

7.3.2 Visualizacin del alineamiento de secuencias .................................. 55

7.3.3 Visualizacin de cortar una vara ....................................................... 56

7.3.4 Visualizacin de multiplicacin de matrices ...................................... 58

7.3.5 Visualizacin de la subsecuencia comn ms larga ......................... 59

7.4 Diseo de los paneles de ayuda .............................................................. 61

7.5 Tipografas .............................................................................................. 63

Conclusiones ...................................................................................................... 65

Bibliografa ......................................................................................................... 67

NDICE DE ILUSTRACIONES

Figura 1: Proceso de visualizacin de datos........................................................ 4 Figura 2: Diagrama de actividad de la mochila 01 ............................................. 15 Figura 3: Diagrama de actividad de alineacin de secuencias .......................... 18 Figura 4: Diagrama de actividad de cortar una vara .......................................... 20 Figura 5: Diagrama de actividad de multiplicacin de matrices ......................... 22 Figura 6: Diagrama de actividad de subsecuencia comn ms larga ................ 24 Figura 7: Diagrama de casos de uso ................................................................. 25 Figura 8: Relacin de los subsistemas de la aplicacin ..................................... 36 Figura 9: Clases del subsistema de entrada de datos ....................................... 36 Figura 10: Clases del subsistema de visualizacin paso a paso........................ 37 Figura 11 Clases del subsistema de ayuda ....................................................... 38 Figura 12 La clase que gestiona la interaccin con ficheros de texto ................ 38 Figura 13: Panel principal de la aplicacin ........................................................ 48 Figura 14: Panel de entrada del problema de la mochila ................................... 49 Figura 15: Panel de entrada del problema del alineamiento de secuencias ...... 50 Figura 16: Panel de entrada del problema de cortar una vara ........................... 50 Figura 17: Panel de entrada del problema de multiplicacin de matrices .......... 51 Figura 18: Panel de entrada del problema de la SCML ..................................... 51 Figura 19: Panel de entrada con casillas en rojo sin completar ......................... 52 Figura 20: Inicializacin de la mochila ............................................................... 53 Figura 21: Visualizacin paso a paso de la mochila .......................................... 54 Figura 22: Solucin de la mochila ...................................................................... 54 Figura 23: Inicializacin del alineamiento de secuencias ................................... 55 Figura 24: Visualizacin paso a paso del alineamiento de secuencias .............. 55 Figura 25: Solucin del alineamiento de secuencias ......................................... 56 Figura 26: Inicializacin de cortar una vara ....................................................... 56 Figura 27: Visualizacin paso a paso de cortar una vara .................................. 57 Figura 28: Solucin de cortar una vara .............................................................. 57 Figura 29: Inicializacin de la multiplicacin de matrices ................................... 58 Figura 30: Visualizacin paso a paso de la multiplicacin de matrices .............. 58 Figura 31: Solucin de la multiplicacin de matrices ......................................... 59 Figura 32: Inicializacin de la subsecuencia comn ms larga .......................... 59 Figura 33: Visualizacin pasos a paso de SCML ............................................... 60 Figura 34: Solucin de la subsecuencia comn ms larga ................................ 60 Figura 35: Informacin del problema ................................................................. 61 Figura 36: Informacin de cargar y guardar ....................................................... 62 Figura 37: Caracterizacin de colores ............................................................... 63

1

1. Introduccin

La programacin dinmica es uno de los paradigmas ms importantes de diseo

de algoritmos, pero es compleja y por ello se pretende disear una herramienta

que favorezca el aprendizaje de este paradigma. Para ello nos centraremos en

algunos de los problemas que se pueden resolver valindonos de la programacin

dinmica, y mediante la herramienta se podr visualizar la ejecucin completa del

algoritmo.

1.1 Programacin dinmica

La programacin dinmica [7] [8], que fue inventada por Richard Bellman en 1953,

es una tcnica que se aplica generalmente para resolver problemas de

optimizacin. Constituye adems una optimizacin de algoritmos recursivos en los

que la solucin al problema implica la repeticin de subproblemas. La

programacin dinmica se vale de la utilizacin de tablas, de modo que en ellas

se guardan las soluciones a los subproblemas ya calculados, por lo que la

subsolucin slo es calculada una vez. La ventaja principal de esta tcnica reside

en que reducimos el coste de tiempo; la desventaja est en que con el uso de la

tabla se aumente el espacio de almacenamiento en memoria.

La programacin dinmica tiene dos enfoques:

Top-down (memoizacin): La estructura del algoritmo sigue siendo

recursiva. Sin embargo, antes de resolver un problema se verifica si la

solucin ya est calculada. En el caso de que no est an calculada la

solucin entonces se calcula y se guarda en una tabla.

Bottom-up: Este algoritmo es iterativo. Se van resolviendo los problemas

desde el caso base, de menor a mayor tamao por etapas, de modo que

las soluciones menores sirven para el clculo de subproblemas de mayor

tamao. Para ello, como en memoizacin, se emplea una tabla donde se

almacenan las soluciones a los subproblemas. En general los pasos

necesarios para resolver un problema mediante este enfoque son los

siguientes:

2

1. Hallar la definicin recursiva del problema (incluyendo los casos base),

plantendolo mediante ecuaciones.

2. Inicializar la tabla de soluciones (normalmente un vector o una matriz),

rellenando las casillas que corresponden a los casos base.

3. Mediante la iteracin con bucles, calcular el resultado para otros casos

empleando la definicin recursiva.

1.2 Objetivos

El objetivo del desarrollo de esta herramienta de software es dotar al alumnado de

una aplicacin prctica para entender los algoritmos de programacin dinmica

mediante la resolucin por etapas de los diversos problemas planteados.

Esta aplicacin est basada en otra herramienta de software enfocada tambin en

la programacin dinmica, vase [26]. Buscamos por tanto, con esta versin,

mejorar en aspectos como el diseo de la herramienta, la visualizacin de los

algoritmos o la mejora de las funcionalidades de la interfaz de usuario.

Anteriormente, en el apartado 1.1, mencionbamos los dos enfoques desde los

cuales se puede estudiar la programacin dinmica. En nuestro caso, la

herramienta est basada en el procedimiento bottom-up. Por tanto, el tablero de

la solucin est representado con una matriz cuyas casillas van siendo rellenadas

desde las soluciones parciales hasta la solucin final, de modo que se puedan

visualizar las dependencias de las soluciones posteriores con las anteriores

calculadas.

Resumen de las caractersticas de la aplicacin:

Interfaz accesible para todo tipo de usuarios.

Potenciar el minimalismo, la sencillez, la facilidad de uso.

Visualizar y comprender paso a paso el funcionamiento de los algoritmos

de programacin dinmica. Desde el uso de las ecuaciones, pasando por

el clculo de los subproblemas, hasta la obtencin de la solucin final

ptima.

Proveer al alumnado de una herramienta para el aprendizaje de algoritmos

de programacin dinmica, facilitndole de este modo el estudio de esta

tcnica.

3

2. Herramientas de visualizacin de software

Desde hace un tiempo, en el mbito educativo existen herramientas con fines de

aprendizaje, pero nunca han llegado a tener un gran impacto en los centros

educativos por la falta de eficacia de sus resultados o el elevado coste de

implantacin.

La usabilidad es un factor importante a la hora de probar la efectividad de una

herramienta de aprendizaje. De hecho, la facilidad con la que se interaccione con

el sistema y la manera en la que se interpretan las visualizaciones determinan el

xito o fracaso de la herramienta [32].

Hasta hace poco el trmino visualizacin significaba construir una imagen visual

en nuestra mente. Hoy da significa algo ms que una representacin grfica de

datos o conceptos. La visualizacin tiene la capacidad de comunicar conceptos

abstractos de una forma familiar y accesible. De hecho, las visualizaciones tienen

un importante rol en el sistema cognitivo. Nosotros, los seres humanos,

adquirimos ms informacin a travs de la vista que de los otros sentidos

combinados, vase [34].

Uno de los grandes beneficios de la visualizacin est en que permite rpidamente

poder interpretar una gran cantidad de informacin si dicha informacin est bien

representada [34]. Tambin facilita la comprensin de la estructura de las partes

de los datos como un todo. Permite observar desde diferentes perspectivas la

apariencia de los datos.

Segn Colin Ware [34], el proceso de visualizacin de datos se compone por

cuatro fases, combinadas en un nmero de lazos de realimentacin, segn se

ilustra en la siguiente figura:

4

Figura 1: Proceso de visualizacin de datos

Esas cuatro fases consisten en lo siguiente:

La recoleccin y almacenaje de los datos

El pre-proceso para transformar los datos en algo que podamos entender

Generacin de la representacin grfica

El sistema humano perceptor y cognitivo

Hay tres lazos de realimentacin que son la recoleccin, manipulacin y

exploracin de datos. El analista de la informacin puede recolectar datos y

aadirlos para que stos sean pre-procesados y representados grficamente.

Tambin puede manipular la manera grfica en la que se muestran los datos pre-

procesados y transformados. Mediante la exploracin de datos puede elegir

diferentes pre-procesos o transformar datos existentes para obtener datos

derivados.

Finalmente, tanto el entorno fsico como el entorno social estn involucrados en el

proceso de realimentacin. El entorno fsico es una fuente de datos, mientras que

el entorno social determina la manera en la que son recolectados e interpretados

los datos.

El concepto de algoritmo es un tema fundamental en la computacin, pero para

los alumnos representa un concepto abstracto por lo que les dificulta su

aprendizaje [13]. Por ello, las tcnicas de visualizacin pueden llegar a esclarecer

la eficiencia de los algoritmos.

5

Las herramientas de visualizacin de software tienen como propsito la

representacin esttica o dinmica de programas y algoritmos. Segn el nivel de

abstraccin, vase [32], podemos diferenciar entre dos tipos: visualizacin de

programas (bajo nivel) y visualizacin de algoritmos (alto nivel).

Hay que diferenciar tambin entre visualizacin y animacin de algoritmos:

La visualizacin de algoritmos es una abstraccin de alto nivel que

describe el software.

La animacin de algoritmos muestra cmo se comporta un algoritmo. La

ejecucin del algoritmo se divide en estados y cada estado se representa

con una visualizacin grfica.

La animacin de algoritmos tiene las siguientes ventajas:

Desde el punto de vista educativo sirve a profesores para mostrar a sus

alumnos el funcionamiento de algoritmos.

Un desarrollador se retroalimenta de la visualizacin de algoritmos de tal

manera que pueden mejorar la representacin de dicha visualizacin. Los

desarrolladores visualizan los algoritmos para entender mejor cmo

funcionan.

La visualizacin le sirve al programador para encontrar errores en la

representacin de la informacin y poder corregirlos.

En el contexto en el que nos encontramos existen pocas herramientas para el

aprendizaje de la algoritmia. Sin embargo, es necesaria la proliferacin de este

tipo de herramientas ya que la visualizacin del funcionamiento de un algoritmo

podra llegar a ser una manera ms rpida y efectiva de aprendizaje que la forma

tradicional.

Existen algunas herramientas enfocadas en la visualizacin de algoritmos y

programas. A continuacin destacamos alguna de estas herramientas:

SRec, vase [27] y [30], es una herramienta de visualizacin, con fines

educativos, enfocada en proporcionar visualizaciones animadas e interactivas

sobre problemas de recursividad en Java. Adems cuenta con la posibilidad

de guardar visualizaciones generadas que luego pueden ser cargadas, de

exportar grficos y de mostrar informacin detallada. Ofrece tres maneras de

visualizar la recursin: traza, pila de control y rbol de recursin.

6

La aplicacin genera las visualizaciones a partir de pre-proceso de una clase

en Java. El usuario puede avanzar, detenerse, retroceder en la visualizacin

paso a paso del algoritmo mediante los controles de navegacin.

GreedEx, vase [13] y [16], es una herramienta de visualizacin que est

centrada en la resolucin de algoritmos voraces. El objetivo de la herramienta

est en la comprensin de cmo funcionan los algoritmos voraces y qu

incidencia tienen las funciones de seleccin en dicho algoritmo.

Las visualizaciones generadas son el resultado de aplicar las funciones de

seleccin a los datos de entrada introducidos. El usuario puede ejecutar paso

a paso las animaciones mediante los controles de navegacin. Adems

permite guardar datos y resultados, y exportar visualizaciones.

GraphsJ [15] es una herramienta didctica orientada a la resolucin y

aprendizaje de algoritmos de grafos. Permite la ejecucin paso a paso de

estos algoritmos ofreciendo en cada paso informacin detallada para el

usuario. La aplicacin incluye cuatro problemas de algoritmos de grafos: el

rbol de recubrimiento del coste mnimo, los caminos ms cortos, el flujo

mximo y el camino crtico. No obstante cualquier desarrollador puede aadir

nuevos problemas a la herramienta.

Jeliot [21] es una herramienta de visualizacin de programas en Java. Su

propsito es visualizar la manera en que un cdigo en Java es interpretado

cuando se lanza su ejecucin. Llamadas a mtodos, variables y operaciones

son mostradas por pantalla en la visualizacin de modo que el usuario pueda

observar paso a paso la ejecucin del programa. Esto representa una manera

didctica de familiarizarse con las caractersticas bsicas de Java.

Las visualizaciones se generan automticamente cuando se ejecuta el

programa en Java. La herramienta muestra un panel con dos secciones: el

cdigo escrito en Java y los grficos de la ejecucin de dicho cdigo. El

usuario tiene la posibilidad de pausar, avanzar y retroceder en el proceso de

visualizacin.

ViLLE [29] es una herramienta de visualizacin de programas diseada con

el propsito de mostrar los conceptos generales bsicos de programacin.

Est aplicacin tiene principalmente un enfoque didctico de tal manera que

profesores pueden mostrar a sus alumnos el comportamiento de la ejecucin

7

de un programa. ViLLE contiene una serie de ejercicios de ejemplo

organizados por categoras. No obstante la aplicacin permite aadir ms

ejercicios.

Uno de los puntos fuertes de esta herramienta es que soporta la visualizacin

de los programas en diferentes lenguajes de programacin. Adems un

usuario puede ejecutar el cdigo de un programa simultneamente en dos

diferentes lenguajes de programacin, de este modo el usuario puede ver las

diferencias sintcticas entre ambos lenguajes.

Otra destacada caracterstica es que el usuario puede editar el cdigo en una

visualizacin para observar los cambios que se producen en la ejecucin y

visualizacin.

AlgoViz [1] es un portal web cuyo propsito es la representacin de las

animaciones de algoritmos. Los usuarios pueden aadir sus propios

algoritmos en varios lenguajes de programacin y generar sus propias

visualizaciones. Adems permite exportar grficos.

BlueJ [3] es una herramienta que ofrece un entorno desarrollo de programas

en Java. Facilita el aprendizaje del paradigma de la orientacin de objetos a

travs del lenguaje Java. Posee un editor que te permite visualizar el cdigo

de una manera ms rpida debido al coloreado de las partes del cdigo. En

la ejecucin del cdigo, los objetos pueden ser inspeccionados para poder

analizar el comportamiento del programa. Al igual que se pueden inspeccionar

los objetos en tiempo de ejecucin tambin se pueden crear nuevos objetos

e invocar sus mtodos. Tambin se pueden aadir breakpoints en el cdigo

para parar la ejecucin en el punto indicado y poder as ver el estado de las

variables.

BlueJ ofrece una representacin UML cuando tenemos un proyecto con

diversas clases. De este modo podemos visualizar las relaciones entre las

clases.

Hemos visto ejemplos de herramientas enfocadas a problemas recursivos, a

algoritmos voraces o a algoritmos de grafos. Sin embargo, en el mbito de la

programacin dinmica hay carencia de herramientas de visualizacin y por ello,

uno de los requisitos con este trabajo es el de completar el ecosistema de

aplicaciones pensadas para el aprendizaje de algoritmos.

9

3. Especificacin y anlisis de requisitos

Este apartado consiste en desglosar los requerimientos de la aplicacin que se va

a desarrollar. Esta es una parte fundamental del proceso de desarrollo ya que a

partir de aqu se tomarn las decisiones de diseo.

3.1 Descripcin del problema

El sistema debe permitir al usuario la visualizacin paso a paso del

desarrollo del algoritmo de programacin dinmica para cada problema.

El usuario podr avanzar o retroceder en la visualizacin paso a paso del

algoritmo aplicado al problema seleccionado.

El usuario podr introducir manualmente los datos del problema

seleccionado.

El usuario podr cargar y guardar los datos del problema seleccionado.

3.2 Caractersticas de los usuarios

El tipo de usuario que maneja esta aplicacin debe estar familiarizado con

aplicaciones de esta ndole; debe tener algn conocimiento mnimo sobre

programacin dinmica. La interfaz es intuitiva y fcil de usar por lo que la curva

de aprendizaje para un usuario con conocimientos bsicos es muy pequea.

Tenemos el siguiente tipo de usuario que utilizar la aplicacin:

Usuario, compuesto por dos subtipos (alumno, profesor).

El usuario podr disponer de las siguientes funcionalidades al acceder a la interfaz

de la aplicacin:

Seleccionar un problema: El usuario selecciona uno de los problemas de

la lista que muestra la interfaz de inicio.

10

Introducir datos de problema: El usuario introducir los datos del

problema previamente seleccionado completando las casillas

correspondientes.

Cargar datos del problema: El usuario puede cargar desde un archivo de

texto los datos del problema seleccionado.

Guardar datos del problema: El usuario puede guardar los datos del

problema, previamente introducidos, en un archivo de texto.

Avanzar en la solucin del problema: El usuario puede avanzar

subproblema a subproblema hasta la solucin final.

Retroceder en la solucin del problema: El usuario puede retroceder a

un subproblema anterior.

Obtener la solucin final: El usuario puede obtener y visualizar el

resultado de la solucin final del problema.

Reiniciar solucin: El usuario puede volver desde la etapa en la que se

encuentre hasta el estado inicial.

3.3 Requisitos funcionales

Visualizacin paso a paso del algoritmo:

Se requiere de la visualizacin, a travs de la interfaz, de la tabla que

contiene las soluciones parciales de los subproblemas de modo que el

usuario pueda en todo momento saber qu soluciones se han calculado.

Tambin se requiere de la visualizacin de las ecuaciones usadas, y sus

respectivos clculos, para hallar la solucin subptima de cada etapa.

Finalmente, al acabar con los clculos parciales obtenidos en cada

iteracin, debe mostrarse la solucin final ptima.

Avance y retroceso en la solucin del problema:

Se requiere que la aplicacin permita al usuario poder interactuar con la

interfaz de modo que puede tanto avanzar como retroceder a lo largo de

las etapas de la resolucin del problema. El usuario podr avanzar desde

el estado inicial hasta que se alcanza la solucin final. Del mismo modo,

el usuario puede retroceder siempre y cuando no se halle en el estado

inicial. Directamente, el usuario puede obtener la solucin final del

problema y tambin reiniciar el problema hasta el estado inicial.

11

Introduccin manual de datos:

Se requiere que el usuario pueda introducir manualmente, mediante el

uso de teclado y ratn, los datos correspondientes al problema

seleccionado. Se verificar si los datos introducidos por el usuario son

vlidos de modo que se garantice el correcto funcionamiento de la

aplicacin.

Carga y guardado de los datos del problema:

Se requiere que el usuario pueda tanto cargar datos desde un archivo de

texto, con extensin .txt, como guardarlos. Para cada problema se

verificar que el archivo desde donde se cargan los datos del problema

lleva un formato vlido para la lectura de dichos datos.

3.4 Requisitos de interfaces externos

Interfaces de usuario:

La interfaz de usuario estar orientada a ventanas y se manejar

mediante teclado y ratn. La interfaz debe cumplir con los requisitos

accesibilidad y usabilidad.

Interfaces hardware y software:

No se han definido.

Interfaces de comunicacin:

No son necesarias para la aplicacin.

3.5 Requisitos de rendimiento

Los tiempos de espera y respuesta deben ser rpidos, de 2 segundos como

mucho. Al ejecutar la aplicacin y sus funcionalidades, el uso de la CPU no debe

sobrepasar el 20%.

12

3.6 Requisitos de desarrollo

El ciclo de vida elegido para desarrollar la aplicacin tendr en cuenta que se

puedan incorporar fcilmente cambios y nuevas funciones, as como aprovechar

las ventajas de reusabilidad proporcionada por el paradigma de orientacin a

objetos. La metodologa de desarrollo a utilizar ser el proceso unificado de

desarrollo y el lenguaje UML.

3.7 Requisitos tecnolgicos

La aplicacin debe correr como mnimo en ordenadores con Windows. Tambin

est pensado para el uso en las plataformas Mac y Linux.

La configuracin mnima del equipo para ejecutar la aplicacin es:

Procesador: Pentium 100 Mhz.

Memoria ram: 16 Mb

Espacio libre en disco: 1 Mb mnimo

Para la ejecucin de la aplicacin se proporcionar el archivo ejecutable y sus

dependencias.

13

4. Descripcin de los problemas de la

aplicacin

En este apartado, para cada uno de los problemas se explica en qu consisten,

las ecuaciones usadas que representan la manera iterativa con la que se van

calculado los valores que se almacenan en la tabla desde los casos base hasta

los de mayor tamao, y el diagrama de actividad muestra cmo se comporta el

algoritmo, es decir, conseguimos con ello mostrar una visin dinmica del

algoritmo.

4.1 Mochila 01

Problema:

El problema de la mochila, vase [28] y [19], es un problema de optimizacin

combinatoria, es decir, que busca la mejor solucin posible entre un conjunto de

posibilidades.

Este es un problema que consiste en decidir de entre n objetos de pesos p1, p2,...,

pn y beneficios b1, b2,..., bn, cules hay que incluir en una mochila de capacidad c

sin superar dicha capacidad y de forma que se maximice la suma de los beneficios

de los elementos escogidos.

Primero debemos plantear el problema como una secuencia de decisiones que

verifique el principio ptimo. De aqu seremos capaces de deducir una expresin

recursiva de la solucin. Por ltimo habr que encontrar una estructura de datos

donde se almacenarn los clculos de los subproblemas.

Sea m(i,p) el valor del beneficio mximo de la mochila con capacidad p

considerando los n-i+1 ltimos objetos de los n totales, siendo 0 p c y 1 i

n. Entonces, podemos definir el problema de forma recurrente en funcin de si se

usa o no el objeto i-simo:

Si se usa el objeto i-simo entonces la subsecuencia de decisiones

tomadas para obtener m(i+1,p-pi) ha de ser ptima.

14

Si no se usa el objeto i-simo entonces la subsecuencia de decisiones

tomadas para obtener m(i+1,p).

Por tanto, el valor que toma m(i,p) ser el mayor entre m(i+1,p), que indica que el

elemento i no se introduce, y m(i+1,p-pi) + bi, que es el resultado de introducirlo,

para cuando la capacidad p es mayor que pi. Si no se introduce el objeto i debido

a que tiene un peso pi p, entonces m(i,p) toma el valor de m(i+1,p).

Finalmente, en los casos base el beneficio es 0, para cuando i=n+1, es decir, no

se introducira ningn objeto.

La solucin del problema original sera m(1,c) y se necesitara una tabla con n+1

filas y c+1 columnas para almacenar cada una de las soluciones subptimas.

Ecuaciones:

Donde:

p: es la capacidad parcial de la mochila.

pi: es el peso del objeto i.

bi: es el beneficio del objeto i.

c: es la capacidad total de la mochila.

n: es el nmero de objetos.

m: es la tabla donde se almacenan los resultados.

cpniparappsibppimpim

ppsipimpim

cpparapnm

iii

i

0,1)),1(),,1(max(

),1(),(

00),1(

15

Diagrama de actividad:

Figura 2: Diagrama de actividad de la mochila 01

16

4.2 Alineamiento de secuencias

Problema:

El problema del alineamiento de secuencias, vase [2] y [19], consiste en lo

siguiente: dadas dos secuencias de caracteres, sean x e y, se busca encontrar el

mnimo nmero de operaciones para convertir la secuencia x en la y. El mnimo

nmero de operaciones permitidas son del siguiente tipo: borrar un carcter,

insertar un carcter, y sustituir un carcter.

Llamaremos m a la longitud de la cadena x, n a la longitud de la cadena y, y C(m,n)

indicar el nmero de operaciones bsicas mnimo para transformar una cadena

x de longitud m en otra cadena y de longitud n.

Para resolver el problema es necesario plantearlo como una sucesin de

decisiones que satisfaga el principio ptimo.

Empezaremos por fijarnos en el ltimo carcter de cada una de las cadenas.

Entonces tendremos que escoger la situacin ms beneficiosa de entre tres

posibilidades:

1. Considerar la primera cadena y la segunda pero sin el ltimo elemento.

Esta opcin se correspondera con la operacin de insertar un carcter.

2. Considerar la primera cadena menos el ltimo elemento y la segunda

cadena. Esta opcin se correspondera con la operacin de borrar un

carcter.

3. Considerar las dos cadenas sin el ltimo elemento. En caso de que no

coincidiesen los ltimos caracteres de ambas cadenas, xm yn, se

correspondera con una operacin de sustitucin. En caso contrario no se

realizara ninguna operacin.

Esto dara lugar a las siguientes relaciones de recurrencias para C(m,n):

xm yn: C(m,n) = min{ 1 + C(m,n-1), 1 + C(m-1,n), 1 + C(m-1,n-1) }

xm = yn: C(m,n) = min{ 1 + C(m,n-1), 1 + C(m-1,n), C(m-1,n-1) }

Respecto a los casos base tendramos dos situaciones:

17

Que el nmero de caracteres de la secuencia x, fuese m, y el nmero de

caracteres de la secuencia y fuese 0, en ese caso habra que hacer m,

operaciones de borrado, o lo que es lo mismo, C(m,0) = m.

Que el nmero de caracteres de la secuencia x, fuese 0, y el nmero de

caracteres de la secuencia y fuese n, en ese caso habra que hacer n,

operaciones de insercin, o lo que es lo mismo, C(0,n) = n.

La solucin del problema original sera C(m,n) y se necesitara una tabla con m+1

filas y n+1 columnas para almacenar cada una de las soluciones subptimas.

Ecuaciones:

Donde:

x: es la secuencia de caracteres X; cada xi representa un carcter.

y: es la secuencia de caracteres Y; cada yi representa un carcter.

i: toma valores desde 0 hasta el nmero total de caracteres de la secuencia X - 1.

j: toma valores desde 0 hasta el nmero total de caracteres de la secuencia Y - 1.

C: es la tabla donde se almacenan los resultados.

)(1

)(0),(

1),1(

1)1,(

min)1,1(

,...,),0(

,...,)0,(

1111

11

1

1

1

1

jiji

ji

j

i

j

i

yporxsustituyeseyxsi

nadahacesenoyxsijiC

yinsertasejiC

xborrasejiC

jiC

yyinsertasejjC

xxborraseiiC

18


Figura 3: Diagrama de actividad de alineacin de secuencias

19

4.3 Cortar una vara

Problema:

Se requiere cortar una vara (de longitud n) en varios trozos de determinadas

longitudes para luego poder venderlos.

El problema de cortar una vara, vase [8], [9] y [10], busca encontrar la cantidad

ptima de cortes a lo largo de una vara en trozos de una determinada longitud que

maximice el precio de venta de los trozos cortados.

Denominaremos p1, p2, , pn a los precios de particin de la vara segn la longitud

indicada por el subndice. Definimos r(i,j) como el beneficio mximo obtenido de

cortar una vara, para 1 i j n, donde i representa la longitud de la vara en un

instante dado, y j representa la descomposicin en trozos de la vara.

Por ejemplo, para una vara de longitud m habra m posibilidades de descomponer

una vara, por lo que 1 j m. Cuando j = m ya se habra llegado a la ltima

descomposicin posible y se comparara con la mejor descomposicin obtenida

hasta el momento, es decir, con las m-1 descomposiciones previas. Esto dara la

siguiente relacin de recurrencia:

r(i,m) = max{ r(i,m-1), pi + r(i-m, i-m) }

El caso base vendra dado por r(i,0) = 0, ya que no habra ninguna

descomposicin.

La solucin del problema original sera r(n,n) y se necesitara una tabla con n filas

y n columnas para almacenar cada una de las soluciones subptimas.

Ecuaciones:

Donde:

p(i): es el valor del precio al cortar la vara una longitud i.

i: toma valores desde 0 hasta el valor de la longitud de la vara.

j: toma valores desde 0 hasta el valor de la longitud de la vara.

r: es la tabla donde se almacenan los resultados.

jiparajijirip

jirjir

ir

1),()(

),1,(max),(

0)0,(

20


Figura 4: Diagrama de actividad de cortar una vara

21

4.4 Multiplicacin de matrices

Problema:

Supongamos que tenemos las matrices M1, M2,..., Mn, que queremos multiplicar:

M = M1 M2 ... Mn

Puesto que el producto es asociativo, habr muchas formas de realizar las

multiplicaciones. Cada colocacin de los parntesis indica un orden en el que se

realizan las operaciones. Segn el orden de las multiplicaciones, el nmero de

total de multiplicaciones escalares necesarias puede variar considerablemente.

Sea una matriz A de dimensin pxq y B de qxr, entonces el producto AB requiere

pqr multiplicaciones escalares. Entonces, el problema de multiplicacin

encadenada de matrices busca encontrar un orden de multiplicacin que minimice

el nmero de multiplicaciones escalares [19].

Definimos m(i,j) como el nmero de productos escalares necesarios para realizar

la multiplicacin entre la matriz i y la matriz j, para i j, tal que m(i,j) = Mi Mi+1 ...

Mj. Denominaremos d1, d2, ..., dn a las dimensiones de las matrices donde la

matriz Mi sera de dimensin dixdi+1

Entonces, tenemos los siguientes casos base:

Si i = j, entonces m(i,j) = 0. No necesitamos hacer ninguna operacin.

Si i = j - 1, entonces m(i,j) = di di+1 di+2. Slo existe una forma de hacer

el producto.

Si no se da ninguno de los anteriores casos base, entonces podemos hacer la

primera multiplicacin por una posicin k, para i k < j:

(Mi ... Mk) (Mk+1 ... Mj).

Por lo tanto, el valor mnimo sera:

m(i,j) = min{ m(i,j) + m(i,j) + di dk dj }, para i k < j.

La solucin del problema original sera m(1,n) y se necesitara una tabla con una

posicin para cada i, j, para 1 i j n, es decir, una tabla con n filas y n columnas.

El algoritmo usara la mitad de la tabla.

22

Ecuaciones:

Donde:

n: es el nmero de matrices encadenadas.

d: es el vector de dimensiones; por ejemplo, si tenemos 4 matrices de dimensiones

5x2, 2x4, 4x1, 1x7, entonces el vector de dimensiones sera {5, 2, 4, 1, 7}.

m: es la tabla donde se almacenan los resultados.


Figura 5: Diagrama de actividad de multiplicacin de matrices

njiparajdkdidjkmkimjkijimiim

1)()()1(),1(),()min(),(

0),(

23

4.5 Subsecuencia comn ms larga

Problema:

Sean dos secuencias de caracteres, X = { x1 x2 xm } e Y = { y1 y2 yn } se debe

encontrar la subsecuencia de caracteres ms larga contenida tanto en X como en

Y , vase [19] y [31].

Definiremos SCML(i,j) a la longitud de la secuencia mxima de las dos secuencias

Xi e Yj, siendo Xi el i-simo prefijo de X (esto es, Xi = { x1 x2 xi }) e Yj el j-simo

prefijo de Y, (Yj = { y1 y2 yj }).

Podemos plantear la solucin como una sucesin de decisiones en las que en

cada paso determinaremos si un carcter forma parte de la subsecuencia comn

mxima. Escogemos la estrategia hacia atrs, es decir, comenzamos teniendo en

cuenta los ltimos caracteres de ambas secuencias, por lo que llegamos a las

siguientes posibilidades:

Si i = m + 1 j = n + 1: no se considerara ningn carcter de la secuencia

X y/o no se considerara ningn carcter de la secuencia Y por lo que no

habra ninguna subsecuencia en comn, es decir, SCML(i,j) = 0. Se

correspondera con los casos base.

Si i m + 1, j n + 1: en este caso debemos verificar si los caracteres xi e

yj coinciden. Si coinciden entonces se aaden a la solucin y calculamos

el ptimo para las mismas secuencias menos el ltimo carcter de ambas,

es decir, SCML(i,j) = SCML(i-1,j-1) + 1. Si no coinciden entonces SCML(i,j)

= max{ SCML(i,j-1) SCML(i-1,j), }, es decir, consideraramos la

subsecuencia comn mxima, entre la secuencia Xi y la secuencia Yj-1, y

entre la secuencia Xi-1 y la secuencia Yj.

La solucin del problema original sera SCML(1,1) y se necesitara una tabla con

m+1 filas y n+1 columnas para almacenar cada una de las soluciones subptimas.

Ecuaciones:

nosijiSCMLjiSCML

yxsijiSCMLjiSCML

niSCML

jmSCML

ji

)}1,(),,1(max{

)1,1(1),(

0)1,(

0),1(

24

Donde:

x: es la secuencia de caracteres X; cada xi representa un carcter.

y: es la secuencia de caracteres Y; cada yj representa un carcter.

i: toma valores desde 1 hasta el nmero total de caracteres de la secuencia X + 1.

j: toma valores desde 1 hasta el nmero total de caracteres de la secuencia Y + 1.

m: es el nmero de caracteres de la secuencia Y.

n: es el nmero de caracteres de la secuencia X.

SCML: es la tabla donde se almacenan los resultados.


Figura 6: Diagrama de actividad de subsecuencia comn ms larga

25

5. Modelo de negocio

5.1 Diagrama de casos de uso

El diagrama de casos de uso representa la vista externa del comportamiento del

sistema desde el punto de vista del usuario.

Figura 7: Diagrama de casos de uso

26

5.1.1 Detalle de casos de uso (flujo de eventos)

Aqu se muestra la secuencia de acciones que determinan la interaccin del

usuario con el sistema para cada caso de uso.

Flujo de eventos

Camino bsico del caso de uso Obtener datos de entrada del problema

ACTOR SISTEMA

2. Selecciona el problema 1. Muestra el men de inicio

4. Introduce datos de entrada por

teclado 3. Muestra el panel de entrada

6. Confirma los datos de entrada 5. Comprueba los datos de entrada

7. Valida los datos de entrada

8. Muestra el panel de ejecucin del

algoritmo con los datos del problema

Caminos alternativos

Evento 4: El usuario introduce los datos de entrada desde fichero.

Evento 5: Los datos de entrada, por teclado o desde fichero, son errneos por

lo que confirma el error.

Flujo de eventos

Camino bsico del caso de uso Guardar datos de entrada

ACTOR SISTEMA

2. Selecciona el problema 1. Muestra el men de inicio

4. Introduce datos de entrada por

teclado 3. Muestra el panel de entrada

6. Selecciona guardar datos en fichero 5. Comprueba los datos de entrada

7. Confirma guardado de datos


Evento 4: El usuario introduce los datos de entrada desde fichero.

Evento 5: Los datos de entrada son errneos por lo que devuelve error.

27

Flujo de eventos

Camino bsico del caso de uso Ejecutar un paso hacia adelante

(para Mochila 01) *

ACTOR SISTEMA

2. Ejecuta una iteracin del algoritmo 1. Muestra el panel de ejecucin del


3. Muestra los clculos de la iteracin

5. El usuario procesa la informacin

visualizada

4. Muestra el beneficio mximo posible

para la iteracin realizada


Evento 4: El sistema detecta que es la ltima iteracin del algoritmo por lo que

muestra el beneficio ptimo final y los objetos introducidos en la mochila.

*Los pasos de 2-5 los puede ejecutar el usuario hasta llegar a la solucin final

Flujo de eventos


(para Alineamiento de secuencias) *

ACTOR SISTEMA





visualizada

4. Muestra el mnimo n de

operaciones posible para convertir la

subsecuencia X en la subsecuencia

Y para la iteracin realizada



muestra el n mnimo de operaciones para convertir las secuencia X en la

secuencia Y, y las operaciones realizadas para llevar a cabo la conversin.


28

Flujo de eventos


(para Cortar una vara) *

ACTOR SISTEMA





visualizada

4. Muestra el valor del precio de la

particin subptima para la iteracin

realizada



muestra el valor del precio de la mejor particin posible para la vara

especificando en cuantos trozos se ha de partir la vara.


Flujo de eventos


(para Multiplicacin de matrices) *

ACTOR SISTEMA





visualizada

4. Muestra el mnimo n de productos

para la iteracin realizada



muestra el mnimo n de productos y de qu manera se agrupan las matrices

para obtener dicho valor mnimo.


29

Flujo de eventos


(para Subsecuencia comn ms larga) *

ACTOR SISTEMA





visualizada

4. Muestra el n mximo de caracteres

en comn para la iteracin realizada



muestra la subsecuencia comn ms larga.


Flujo de eventos

Camino bsico del caso de uso Ejecutar un paso hacia atrs

(para Mochila 01) *

ACTOR SISTEMA

1. Ejecuta una iteracin hacia atrs del

algoritmo

2. Muestra los clculos de la penltima

iteracin


visualizada

3. Muestra el beneficio mximo posible

para la penltima iteracin realizada


Evento 2: El sistema detecta que se ha llegado al estado inicial, por lo que

muestra el panel de ejecucin en su estado inicial.

*Los pasos de 1-4 los puede ejecutar el usuario hasta llegar al estado inicial

30

Flujo de eventos


(para Alineamiento de secuencias) *

ACTOR SISTEMA


algoritmo


iteracin


visualizada

3. Muestra el mnimo n de

operaciones posible para convertir la

subsecuencia X en la subsecuencia

Y para la penltima iteracin

realizada





Flujo de eventos


(para Cortar una vara) *

ACTOR SISTEMA


algoritmo


iteracin


visualizada


particin subptima para la penltima

iteracin realizada





31

Flujo de eventos


(para Multiplicacin de matrices) *

ACTOR SISTEMA


algoritmo


iteracin


visualizada


para la penltima iteracin realizada





Flujo de eventos


(para Subsecuencia comn ms larga) *

ACTOR SISTEMA


algoritmo


iteracin


visualizada

3. Muestra el n mximo de caracteres

en comn para la penltima iteracin

realizada





32

Flujo de eventos

Camino bsico del caso de uso Ir a la solucin final

(para Mochila 01)

ACTOR SISTEMA

1. Ejecuta ver la solucin final 2. Muestra el beneficio ptimo final y

los objetos introducidos en la mochila


visualizada

Flujo de eventos


(para Alineamiento de secuencias)

ACTOR SISTEMA

1. Ejecuta ver la solucin final

2. Muestra el n mnimo de

operaciones para convertir las

secuencia X en la secuencia Y, y las

operaciones realizadas para llevar a

cabo la conversin.


visualizada

Flujo de eventos


(para Cortar una vara)

ACTOR SISTEMA



mejor particin posible para la vara

especificando en cuantos trozos se ha

de partir la vara


visualizada

33

Flujo de eventos


(para Multiplicacin de matrices)

ACTOR SISTEMA



y de qu manera se agrupan las

matrices para obtener dicho valor

mnimo


visualizada

Flujo de eventos


(para Subsecuencia comn ms larga)

ACTOR SISTEMA

1. Ejecuta ver la solucin final 2. Muestra la subsecuencia comn

ms larga


visualizada

Flujo de eventos

Camino bsico del caso de uso Ir al inicio

ACTOR SISTEMA

1. Ejecuta ir al estado inicial

2. Muestra el panel de ejecucin del

algoritmo en su estado inicial (con los

datos del problema)

35

6. Diseo de la aplicacin

La aplicacin ha sido desarrollada bajo el lenguaje de programacin Java usando

la librera swing para el desarrollo de la interfaz grfica. La librera swing contiene

una serie de layouts, vase [6], [17] y [18], que nos servirn para distribuir los

elementos que componen la interfaz. De este modo organizaremos las reas de

textos, los botones, y las casillas de datos [22] a lo largo de la composicin de los

paneles.

El entorno de desarrollo empleado ha sido Netbeans.

6.1 Diagramas de clases

Aqu expondremos la distribucin interna de las clases que conforman la

aplicacin desarrollada.

Principalmente hay dos subsistemas que desempean el funcionamiento principal

de la herramienta. Por un lado tenemos el subsistema de clases que permiten al

usuario introducir datos para el problema seleccionado, y por otro lado tenemos el

subsistema de clases responsables de la visualizacin paso a paso del algoritmo

seleccionado. Estos dos subsistemas, anteriormente citados, en comn usan las

clases de ayuda que son las responsables de mostrar al usuario la informacin de

ayuda respectiva de la aplicacin y del problema seleccionado. Finalmente, el

subsistema de entrada de datos se relaciona tambin con la clase que maneja la

carga y guardado de datos en fichero de texto.

A continuacin, la figura 8, nos muestra un resumen de la relacin entre los

subsistemas:

36

Figura 8: Relacin de los subsistemas de la aplicacin

Ahora proseguiremos a entrar en detalle en cada subsistema mostrando mediante

diagramas la relacin existente entre las clases de conforman cada subsistema.

Figura 9: Clases del subsistema de entrada de datos

37

Figura 10: Clases del subsistema de visualizacin paso a paso

38

Figura 11 Clases del subsistema de ayuda

Figura 12 La clase que gestiona la interaccin con ficheros de texto

39

6.2 Diagramas de clases en detalle

En este apartado procederemos a explicar en detalle los diagramas de clases

representados en el apartado anterior.

6.2.1 Subsistema de entrada de datos

EntradaDatosAbstracta: Esta es una clase abstracta que dispone de los mtodos

que permiten el funcionamiento de la interfaz de entrada de datos. La mayora de

mtodos son abstractos, es decir, las clases que heredan de esta clase

implementaran esos mtodos. Los nicos mtodos implementados son atras() y

getIconImage() ya que funcionan igual en todas las interfaces de entrada de

datos.

Funcionamiento bsico de los mtodos:

getIconImage(): este mtodo carga el icono de la aplicacin, vase [4].

comprobarEntradaClickPanel(): este mtodo verifica si hay casillas de

entrada vacas al hacer click en el panel de la interfaz.

siguiente(): este mtodo se activa al hacer click en el botn siguiente de la

interfaz. El propsito de este mtodo es el de llevarnos a la interfaz de

visualizacin del algoritmo siempre y cuando se hayan introducido datos

de entrada adecuados.

atras(): este mtodo se activa al hacer click en el botn atrs de la interfaz.

La labor que desempea este mtodo es el de cerrar la ventana de la

interfaz de entrada de datos.

leerDesdeArchivo(): este mtodo es el responsable de cargar los datos

desde un fichero de texto. Esta funcin se activa cuando el usuario accede

a Archivo -> Cargar datos y selecciona un archivo de texto con los datos

para el problema seleccionado. Para cada problema, se comprueba que el

archivo de texto cargado cumple con el formato de entrada, de tal modo

que si el formato es correcto entonces se cargan los datos en la interfaz.

Si el formato no es correcto saldr un mensaje de error.

guardarEnArchivo(): este mtodo es el responsable de guardar los datos

de entrada introducidos en un archivo de texto. Esta funcin se activa

cuando el usuario accede a Archivo -> Guardar datos y selecciona una

ubicacin donde guardar los datos de entrada. El archivo se guardar

40

correctamente si los datos de entrada introducidos en la interfaz son

correctos. Si no, se mostrar un error.

mostrarAyuda(): este mtodo muestra al usuario la interfaz de ayuda

personalizada en funcin del problema seleccionado cuando se hace click

en el botn de icono de ayuda.

entradadatosSec: esta clase hereda de EntradaDatosAbstracta, por lo que

implementa los mtodos abstractos de dicha clase. Esta clase representa la

interfaz de entrada de datos para los problemas que usan secuencias de

caracteres.

Mtodos asociados a la clase:

seleccionarSecx() y seleccionarSecy(): estos mtodos tienen la funcin de

activar el nmero de casillas de entrada para los caracteres.

nuevoSecx() y nuevoSecy(): estos mtodos activan o desactivan casillas

de entrada, para introducir los caracteres de las secuencias, cuando

detecta que ha habido un cambio en el nmero mximo de caracteres

posible para cualquiera de las secuencias.

entradadatosMochila: esta clase hereda de EntradaDatosAbstracta, por lo que


interfaz de entrada de datos para el problema de la mochila 0,1.


seleccionarNumObjetos(): este mtodo activa las casillas de entrada de los

pesos y beneficios de los objetos.

nuevoNumObjetos(): este mtodo activa o desactiva casillas de entrada

cuando el usuario modifica el nmero mximo de objetos en la mochila

mediante el selector.

activarCapacidad(): El propsito de este mtodo es el de activa el selector

para que el usuario pueda establecer la capacidad mxima de la mochila.

41

entradadatosMultMat: esta clase hereda de EntradaDatosAbstracta, por lo que


interfaz de entrada de datos para el problema de la multiplicacin encadenada de

matrices.


seleccionarLongVector(): este mtodo activa las casillas de entrada del

vector de dimensiones.

nuevaLongVector(): este mtodo actualiza el nmero de casillas de

entrada disponibles cuando el usuario modifica el nmero mximo de

dimensiones del vector mediante el selector.

entradadatosCortarVara: esta clase hereda de EntradaDatosAbstracta, por lo

que implementa los mtodos abstractos de dicha clase. Esta clase representa la

interfaz de entrada de datos para el problema de cortar una vara.


seleccionarLongVara(): este mtodo activa las casillas de entrada de los

precios de las longitudes.

nuevaLongVara(): este mtodo actualiza el nmero de casillas de entrada

disponibles cuando el usuario modifica el nmero mximo de longitud de

la vara.

LimitadorCaracteres: esta clase es la responsable de limitar a caracteres

numricos, [33], las casillas de entrada de datos. De este modo se evita que el

usuario introduzca datos errneos y previene de tal manera cualquier

comportamiento anmalo de la herramienta. Esta clase es usada por los

problemas cuyos datos de entrada son nicamente caracteres numricos.

LimitadorCaracteresSec: esta clase tiene una responsabilidad similar a la

anteriormente citada. La diferencia radica en que esta clase limita las casillas de

entrada de datos a caracteres alfanumricos. Esta clase es usada por los

problemas de secuencia de caracteres.

42

Para la limitacin de caracteres de las clases LimitadorCaracteres y

LimitadorCaracteresSec seguiremos el procedimiento descrito en [24]

6.2.2 Subsistema de visualizacin paso a paso

Mochila_01: esta clase engloba el clculo del algoritmo correspondiente al

problema de la mochila 0,1.

AlineacionSecuencias: esta clase engloba el clculo del algoritmo

correspondiente al problema del alineamiento de secuencias.

CutRod: esta clase engloba el clculo del algoritmo correspondiente al problema

de cortar una vara.

MultiplicacionMatrices: esta clase engloba el clculo del algoritmo

correspondiente al problema de la multiplicacin encadenada de matrices.

SCML: esta clase engloba el clculo del algoritmo correspondiente al problema de

la subsecuencia comn ms larga.

Las cinco clases anteriores comparten ciertas caractersticas:

Por un lado en cada iteracin de los respectivos algoritmos guardamos en

un vector el estado de las operaciones realizadas. De este modo, al ir

registrando en cada iteracin las soluciones subptimas, conseguimos

almacenar todas las operaciones que sern visualizadas en la interfaz de

visualizacin paso a paso. Con el mtodo getPap() nos devuelve el vector

con todas las operaciones

Los mtodos mochila01_matriz(), alineacin(), cutrod_tab2(),

multiplicarOptimo(), SCML(), hacen respectivamente los clculos desde el

caso base hasta la solucin final del algoritmo. Todos estos mtodos

devuelven una tabla de soluciones del problema calculado.

Finalmente tenemos el mtodo decisin() que para cada problema nos

desvuelve los resultados de la solucin ptima final. En el caso de la

mochila nos devolvera qu objetos han sido introducidos en la mochila.

En el caso de la alineacin de secuencias nos devolvera qu operaciones

(insercin, borrado, sustitucin) se realizaron para alinear la secuencias.

En el caso de cortar una vara nos devolvera la cantidad de trozos en los

43

que ha sido cortada la vara. En el caso de la multiplicacin encadenada de

matrices, devolvera la agrupacin ptima de multiplicacin de las

matrices. Y por ltimo, en el caso de la subsecuencia comn ms larga,

devolvera una secuencia con los caracteres en comn.

Cuadricula y Solucion: El panel Solucion representa la interfaz grfica sobre la

que se visualizar paso a paso el algoritmo. Este panel est compuesto por una

Cuadricula, la cual representa grficamente la tabla de soluciones del problema

seleccionado y est implementada mediante GridLayout [17]. Tambin contiene

varias reas de texto donde respectivamente va informacin acerca de los datos

del problema, el estado de iteracin y la decisin de la solucin ptima. Finalmente

dispone de una serie de botones que permiten al usuario avanzar y retroceder en

la ejecucin del algoritmo.

SolucionAbstracta: Esta clase abstracta contiene la declaracin de los mtodos

abstractos que tienen como finalidad hacer funcionar la visualizacin por etapas

del algoritmo. Las clases que heredan de sta implementaran los mtodos

abstractos en funcin de las particularidades de cada problema respectivamente.

Esas clases reciben los datos del problema de sus respectivos paneles de entrada

de datos que tienen asociados.


getIconImage(): este mtodo carga el icono de la aplicacin [4].

controlador(): este es un mtodo que se ejecuta en la inicializacin de la

clase y desempea la responsabilidad de activar el funcionamiento de los

botones de la interfaz

avanzar(): este mtodo se activa tanto para cuando el usuario hace click

en el botn de ir hacia adelante como para cuando hace click en el botn

de ir hacia atrs. Recibe como argumento un valor booleano de tal modo

que cuando dicho valor es verdadero entonces se realiza una animacin

de avance en el algoritmo, y cuando el valor el falso entonces sucede el

caso contrario, una animacin de retroceso en el algoritmo. Las

animaciones de avance y retroceso implican la llamada a otros mtodos

que permiten el repintado de las casillas de la tabla de resultados y la

visualizacin de las operaciones realizadas en la iteracin.

44

reiniciar(): este mtodo reinicia la visualizacin paso a paso del algoritmo

a su estado inicial cuando el usuario pulsa el botn de reinicio.

solucin(): este mtodo muestra directamente la visualizacin de la

solucin final del algoritmo cuando el usuario hace el click en el botn

correspondiente a dicha accin.

insercioncolor(): este mtodo es llamado cuando se produce una

animacin de avance. La labor que desempea este mtodo es el de

repintar las casillas que intervienen en el clculo de la solucin subptima

en la etapa en la que nos encontremos.

borradocolor(): este mtodo es llamado cuando se produce una animacin

de avance o de retroceso en la que se necesita borrar el color de una

casilla pintada con anterioridad.

insercinpap(): este mtodo, en cada iteracin, se encarga de mostrar la

visualizacin de las operaciones realizadas en el estado actual de

ejecucin del algoritmo.

mostrarAyuda(): este mtodo tienen el mismo funcionamiento que en la

clase EntradaDatosAbstracta.

6.2.3 Subsistema de ayuda

AyudaTextos: esta clase nicamente contiene los textos de informacin de ayuda

para cada problema.

Ayuda: esta clase representa el panel de la informacin de ayuda. Dicha

informacin de ayuda ser suministrada por la clase AyudaTextos. El mtodo

setText() tiene la finalidad de aadir la informacin de ayuda al rea de texto del

panel.

AyudaFrame: esta clase representa la ventana de la interfaz de informacin de

ayuda y lleva contenida el panel Ayuda.

45

6.2.4 Fichero

La clase Fichero es la que se encarga de gestionar la interaccin con ficheros de

textos. Se encarga tanto de guardar los datos de un problema en un fichero de

texto como de cargarlos desde l. Tanto la lectura como la escritura de datos en

un fichero de texto se realiza mediante el procedimiento explicado en [23].


leer(): a partir de una ruta de fichero dada se leer la informacin contenida

en el fichero y se devolver el valor de dicho contenido.

escribir(): a partir de unos datos especificados en una variable y una ruta

donde guardar esos datos se procede mediante este mtodo a crear un

nuevo fichero de texto [11] (o sobrescribir uno ya existente) con la

informacin dada por la variable de datos.

Los mtodos comprobar() verifican, para cada uno de sus respectivos

problemas, que la informacin leda desde un fichero de texto tiene el

formato adecuado para el problema seleccionado.

ruta(): es un mtodo que funciona a modo preventivo ya que este mtodo

asegura que cuando se vayan a guardar datos en un fichero, ese fichero

acabe teniendo extensin .txt.

47

7. Diseo de la interfaz grfica

En este apartado mostraremos como ha sido diseada la interfaz grfica de la

aplicacin. Iremos desde el diseo del panel principal hasta el diseo del panel de

visualizacin de los algoritmos, pasando antes por los paneles de entrada de

datos.

Los colores que se usan en la interfaz han sido obtenidos de [5], y los iconos de

los botones de control corresponden a una librera de iconos [20].

7.1 Diseo del panel principal

La figura 13 muestra el diseo del primer panel cuando se ejecuta la herramienta.

Ese panel principal se compone bsicamente de las opciones para seleccionar

uno de los problemas de programacin dinmica.

La imagen de fondo tiene como propsito representar un contexto educativo, con

los dos alumnos apuntando a la pizarra sobre la que se muestran las opciones a

los problemas.

Los botones de Salir y Siguiente estn precedidos por iconos sencillos que

representan las metforas de cerrar y pasar al siguiente panel respectivamente.

48

Figura 13: Panel principal de la aplicacin

7.2 Diseo de los paneles de entrada

Los paneles de entrada mantienen un diseo unificado, es decir, todas las

pantallas de entrada tienen la misma estructura visual.

El objetivo del diseo de los paneles de entrada es el de establecer un equilibrio

visual entre los elementos que lo forman. Por ello, lo primero era decidir la

distribucin de los elementos principales:

La parte central es el lugar idneo para las casillas de entrada y los selectores ya

que estos son los elementos ms importantes del panel. Luego definimos la

ubicacin de los botones. Para mantener la coherencia respecto al panel principal,

los botones de Atrs y Siguiente estn colocados en la esquina inferior

derecha, precedidos de sus respectivos iconos. En la parte superior ubicaremos,

por un lado en la parte izquierda el botn de Archivo para acceder a las opciones

49

de Cargar datos y Guardar datos, y por otro lado en la parte derecha el icono

de Ayuda. Para conseguir el equilibrio visual, en la parte inferior izquierda aado

el dibujo del alumno mirando hacia las casillas de entrada, as evitamos la

sensacin de espacios vacos en la composicin, o de espacios ms poblados que

otros.

En general el diseo de los paneles de entrada es minimalista, limpio, ya que el

propsito es tener una aplicacin cuyo diseo busque la sencillez. De ah la

eleccin de los colores blanco (de fondo) y negro (de contenido), y uso de

tonalidad gris (para indicar por ejemplo las casillas no habilitadas). El color rojo

rompe intencionadamente con el diseo global ya que es un color usado para

destacar las casillas que no han sido correctamente completadas, es decir, el rojo

es usado a modo de alerta.

Figura 14: Panel de entrada del problema de la mochila

50

Figura 15: Panel de entrada del problema del alineamiento de secuencias

Figura 16: Panel de entrada del problema de cortar una vara

51

Figura 17: Panel de entrada del problema de multiplicacin de matrices

Figura 18: Panel de entrada del problema de la SCML

52

Figura 19: Panel de entrada con casillas en rojo sin completar

7.3 Diseo de los paneles de visualizacin paso a paso

Al igual que en los paneles de entrada, aqu planteamos un diseo unificado para

todos los problemas, ya que todos se resuelven de manera similar por

programacin dinmica. Analizamos el posicionamiento de los elementos grficos

que forman parte de la composicin del panel.

Por un lado tenemos la parte de datos del problema en la zona central superior

del panel. Es necesario que el usuario en todo momento tenga en cuenta los datos

ya que son usados en la visualizacin por etapas del algoritmo.

Justo debajo de los datos del problema tenemos la matriz donde se guardan las

soluciones a los subproblemas. La construccin de esta matriz en cuanto al

nmero de casillas que la forman es variable en funcin de los datos dados del

problema. Las casillas de la matriz toman dos tipos de colores: por un lado,

amarillo indica las casillas tenidas en cuenta para calcular la solucin de un

subproblema; por otro lado, verde indica la casilla en la que se ha resuelto el

53

subproblema. Segn se vaya avanzando las casillas se pintarn y despintarn

hasta llegar a la solucin final.

En la parte derecha tenemos dos reas de texto. La primera, la de la zona superior,

registrar los clculos hechos en cada etapa, clculos que tambin se reflejan en

la matriz de resultados. La segunda rea de texto, que aparece justo debajo de la

anterior, muestra la decisin ptima tomada para la resolucin final al problema.

Respecto a los controles, quedan ubicados en la parte inferior derecha porque

considero que es la zona ms confortable teniendo en cuenta que la matriz y datos

del problema ocupan prcticamente dos tercios del panel de visualizacin.

Finalmente, tambin disponemos de un botn de ayuda en la esquina superior

derecha con el que acceder al panel de ayuda, al igual que en los paneles de

entrada de datos.

En general, esta composicin visual trata de darle importancia a la matriz donde

se almacenan los resultados a los subproblemas, ya que la caracterstica

fundamental de la programacin dinmica recae en el uso de las tablas. El objetivo

es que el usuario capte el concepto de cmo se resuelven este tipo de algoritmos

y esta composicin visual est pensada para facilitarle esa labor.

7.3.1 Visualizacin de la mochila 0,1

Figura 20: Inicializacin de la mochila

54

Figura 21: Visualizacin paso a paso de la mochila

Figura 22: Solucin de la mochila

55

7.3.2 Visualizacin del alineamiento de secuencias

Figura 23: Inicializacin del alineamiento de secuencias

Figura 24: Visualizacin paso a paso del alineamiento de secuencias

56

Figura 25: Solucin del alineamiento de secuencias

7.3.3 Visualizacin de cortar una vara

Figura 26: Inicializacin de cortar una vara

57

Figura 27: Visualizacin paso a paso de cortar una vara

Figura 28: Solucin de cortar una vara

58

7.3.4 Visualizacin de multiplicacin de matrices

Figura 29: Inicializacin de la multiplicacin de matrices

Figura 30: Visualizacin paso a paso de la multiplicacin de matrices

59

Figura 31: Solucin de la multiplicacin de matrices

7.3.5 Visualizacin de la subsecuencia comn ms larga

Figura 32: Inicializacin de la subsecuencia comn ms larga

60

Figura 33: Visualizacin pasos a paso de SCML

Figura 34: Solucin de la subsecuencia comn ms larga

61

7.4 Diseo de los paneles de ayuda

El diseo del panel, que muestra la ayuda respectiva al problema seleccionado,

est tambin unificado para todos los problemas. El objetivo con el diseo es

mostrar de manera sencilla y resumida las caractersticas del problema, como

cargar y guardar los datos en archivo de texto, y la caracterizacin de los colores.

La distribucin de los elementos busca un buen equilibrio de la composicin.

Principalmente colocamos el rea de texto, donde se visualizar la informacin de

ayuda, ocupando dos tercios de panel de manera que se da prioridad a una

visualizacin clara de la informacin de ayuda. El formato con el que est

implementado el contenido de esta rea de texto es mediante html/css para poder

darle el estilo deseado.

Los botones aparecen en el lado izquierdo y debajo de ellos un dibujo de un

alumno mirando hacia el rea de texto. La composicin con el dibujo del alumno,

al igual que en los paneles de entrada, busca transmitir un contexto educativo.

La figura 35 representa cmo se muestra la informacin relativa al problema. Por

un lado tenemos una descripcin breve del problema, y por otro lado las

ecuaciones de resolucin mediante programacin dinmica. Las ecuaciones estn

introducidas mediante una imagen que las contiene y dndole los estilos

necesarios mediante css, para adaptar la imagen al rea de texto.

Figura 35: Informacin del problema

62

La figura 36 muestra el panel con la informacin de cmo cargar y guardar datos

del problema. Se explica el formato que debe tener el contenido de un archivo de

texto para poder cargar la informacin al panel de entrada.

Figura 36: Informacin de cargar y guardar

La figura 37 muestra el panel con la informacin de la caracterizacin de los

colores. Las palabras Rojo, Amarillo, y Verde estn coloreados mediante el

uso de estilos css.

63

Figura 37: Caracterizacin de colores

7.5 Tipografas

La tipografa usada, mediante el uso de las fuentes en Java [14], para los ttulos

de los paneles es Franklin Gothic Book ya que es un tipo de letra que se ve bien.

Respecto a la tipografa del contenido, se hace uso de la tipografa Verdana y

Tahoma, que son un tipo de letra estndar de gran legibilidad. Se ha buscado

una relacin de armona entre la tipografa de los ttulos y la del contenido de tal

manera que favorezca el diseo de la composicin.

65

Conclusiones

La herramienta apoya las principales caractersticas de la programacin dinmica

ya que permite visualizar la siguiente informacin:

Visualizacin de la tabla de resultados.

Visualizacin de los clculos subptimos en cada una de las iteraciones.

Visualizacin de la subdivisin de problemas, ya que en cada iteracin se

muestra qu casillas se tienen en cuenta para el clculo del subproblema.

Finalmente, visualizacin de la estrategia final ptima para la resolucin

del problema.

La correcta visualizacin de los algoritmos de los problemas facilita al usuario la

comprensin de los mismos.

Se ha conseguido disear una interfaz minimalista e intuitiva de modo que, el

usuario en todo momento es consciente de las acciones que puede realizar y de

la informacin que se le presenta.

El resultado final es una aplicacin liviana, de fcil ejecucin y manejo.

La herramienta cuenta con lo bsico para mostrar a un usuario el funcionamiento

de un algoritmo de programacin dinmica. Sin embargo, se pueden presentar las

siguientes lneas de trabajo:

Ampliar el nmero de problemas de la aplicacin.

Aadir la posibilidad de exportar resultados.

Hacer que la aplicacin sea adaptativa a toda clase de pantallas, es decir,

que el tamao de la ventana se adapte al tamao del monitor.

Hacer un estudio en profundidad sobre la usabilidad de la herramienta.

Probar la eficacia de la herramienta en un contexto educativo.

Este trabajo me ha exigido tanto a nivel tcnico como a nivel artstico. He mejorado

mi capacidad de abstraccin, y tambin he puesto a prueba mi creatividad. El

desarrollo de esta herramienta me ha permitido adentrarme de manera ms

profunda en el mundo de las interfaces grficas de usuario, y al mismo tiempo he

ampliado mis conocimientos en Java. He puesto atencin a todos los detalles

grficos de la aplicacin, para que quedase todo bien definido, y esto me ayuda

para seguir en esta misma lnea en futuros trabajos. En general ha sido una

experiencia gratificante en la cual he podido mostrar mis mejores cualidades.

67

Bibliografa

[1] AlgoViz. Obtenido de http://www.algoviz.net/

[2] Alineamiento de secuencias. Obtenido de

http://es.wikipedia.org/wiki/Alineamiento_de_secuencias#Alineamiento_m

.C3.BAltiple_de_secuencias

[3] BlueJ. Obtenido de http://www.bluej.org/about.html

[4] Cambiar cono a un JFrame. Obtenido de

http://www.apuntesdejava.com/2008/11/cambiar-icono-un-jframe.html

[5] Colores para la interfaz. Obtenido de http://www.colourlovers.com/

[6] Cmo usar BoxLayout. Obtenido de

http://docs.oracle.com/javase/tutorial/uiswing/layout/box.html

[7] Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Clifford, S. (2001).

Introduction to algorithms (2nd ed.).

[8] Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Clifford, S. (2009).

Introduction to algorithms (3rd ed.).

[9] Cortar una vara (1). Obtenido de

http://www.radford.edu/~nokie/classes/360/dp-rod-cutting.html

[10] Cortar una vara (2). Obtenido de http://www.geeksforgeeks.org/dynamic-

programming-set-13-cutting-a-rod/

[11] Crear un fichero en Java. Obtenido de http://lineadecodigo.com/java/crear-

un-fichero-en-java/

[12] Cuadros de dilogo en Java. Obtenido de http://ayuda-

java.blogspot.com.es/2007/07/cmo-hacer-cuadros-de-dilogo-simples.html

[13] Debdi, O. (2014). Aprendizaje interactivo de algoritmos voraces: del enfoque

individual al colaborativo. Tesis doctoral.

[14] Fuentes en Java. Obtenido de

http://docs.oracle.com/javase/6/docs/api/java/awt/Font.html

[15] GraphsJ. Obtenido de http://gianlucacosta.info/software/graphsj/

[16] GreedEx. Obtenido de http://www.lite.etsii.urjc.es/greedex/

[17] GridLayout API. Obtenido de

http://download.java.net/jdk7/archive/b123/docs/api/java/awt/GridLayout.h

tml#GridLayout%28int,%20int,%20int,%20int%29

[18] GroupLayout API. Obtenido de

http://docs.oracle.com/javase/6/docs/api/javax/swing/GroupLayout.Group.

html

[19] Guerequeta, R. V. (2000). Tcnicas de diseo de algoritmos (2 ed.).

[20] Iconos para la interfaz. Obtenido de https://www.iconfinder.com/

68

[21] Jeliot. Obtenido de http://cs.joensuu.fi/jeliot/index.php

[22] JTextField API. Obtenido de

http://docs.oracle.com/javase/7/docs/api/javax/swing/JTextField.html

[23] Lectura y Escritura de Ficheros en Java. Obtenido de

http://chuwiki.chuidiang.org/index.php?title=Lectura_y_Escritura_de_Fich

eros_en_Java

[24] Limitar los caracteres de un JTextField. Obtenido de

http://www.chuidiang.com/java/ejemplos/JTextField/limita_caracteres.php

[25] Mtodo para obtener un recurso. Obtenido de

http://www.herongyang.com/JVM/ClassLoader-getSystemResource-

Method-Find-File.html

[26] Morata Palacios, M. (2010). Asistente interactivo para el aprendizaje de

algoritmos enmarcados en la programacin dinmica. Proyecto Fin de

Grado.

[27] Prez Carrasco, A. (2011). Sistema Generador de Animaciones Interactivas

para la Docencia de Algoritmos Recursivos. Tesis doctoral.

[28] Problema de la mochila. Obtenido de

http://es.wikipedia.org/wiki/Problema_de_la_mochila

[29] Rajala, T., Laakso, M.-J., Kaila, E., & Salakoski, T. ViLLE. Obtenido de

http://www.jite.informingscience.org/documents/Vol7/JITEv7IIP015-

032Rajala394.pdf

[30] SRec. Obtenido de http://www.lite.etsii.urjc.es/srec/

[31] Subsecuencia comn ms larga. Obtenido de

http://xcodigoinformatico.blogspot.com.es/2012/09/subsecuencia-comun-

mas-larga-con.html

[32] Urquiza Fuentes, J., & Velzquez Iturbe, J. . (2009). A Survey of

Successful Evaluations of Program Visualization and Algorithm Animation

Systems.

[33] Validar si un dato es numerico en Java. Obtenido de

http://lineadecodigo.com/java/validar-si-un-dato-es-numerico-en-java/

[34] Ware, C. (2004). Information Visualization: Perception for Design (2nd ed.).

Herramienta para la visualización de algoritmos basados en programación dinámica

Documents

Transcript of Herramienta para la visualización de algoritmos basados en programación dinámica