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. 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:
1
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.
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:
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 preprocesados 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.
4
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.
5
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
6
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.
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.
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.
10
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%.
11
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
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.
12
4. Descripcin
aplicacin
de
los
problemas
de
la
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.
13
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:
m(n 1, p) 0
para 0 p c
si p pi
m(i 1, p)
m(i, p)
max( m(i 1, p), m(i 1, p pi ) bi ) si p pi
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.
14
para 1 i n, 0 p c
Diagrama de actividad:
Figura 2: Diagrama de actividad de la mochila 01
15
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:
16
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:
C (i,0) i
se borra x1 ,..., xi
C (0, j ) j
se inserta y1 ,..., y j
C (i, j 1) 1 se borra xi 1
C (i 1, j 1) min C (i 1, j ) 1 se inserta y j 1
0 si xi 1 y j 1 (no se hace nada)
C
(
i
,
j
)
1 si xi 1 y j 1 ( se sustituyexi 1 por y j 1 )
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.
17
Figura 3: Diagrama de actividad de alineacin de secuencias
18
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:
r (i,0) 0
r (i, j 1),
r (i, j ) max
para 1 i j
p(i) r (i j, i j )
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.
19
Figura 4: Diagrama de actividad de cortar una vara
20
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.
21
Ecuaciones:
m(i, i) 0
m(i, j ) min(i k j )m(i, k ) m(k 1, j ) d (i 1)d (k )d ( j ) para 1 i j n
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
22
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:
SCML(m 1, j ) 0
SCML(i, n 1) 0
si xi y j
1 SCML(i 1, j 1)
SCML(i, j )
max{SCML(i 1, j ), SCML(i, j 1)} si no
23
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
24
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
25
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
6. Confirma los datos de entrada
3. Muestra el panel 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.
26
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

3. Muestra los clculos de la iteracin
5. El usuario procesa la informacin 4. Muestra el beneficio mximo posible

visualizada
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

4.
Muestra
el
mnimo
de
5. El usuario procesa la informacin operaciones posible para convertir la

visualizada
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.
27
Flujo de eventos
(para Cortar una vara) *
ACTOR
SISTEMA

5. El usuario procesa la informacin

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

5. El usuario procesa la informacin 4. Muestra el mnimo n de productos

visualizada
para la iteracin realizada

muestra el mnimo n de productos y de qu manera se agrupan las matrices
para obtener dicho valor mnimo.
28
Flujo de eventos
(para Subsecuencia comn ms larga) *
ACTOR
SISTEMA

5. El usuario procesa la informacin 4. Muestra el n mximo de caracteres

visualizada
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 2. Muestra los clculos de la penltima
algoritmo
iteracin
4. El usuario procesa la informacin 3. Muestra el beneficio mximo posible

visualizada
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
29
Flujo de eventos
(para Alineamiento de secuencias) *
ACTOR
SISTEMA
algoritmo
iteracin
3.

visualizada
Muestra
el
mnimo
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
30
Flujo de eventos
(para Multiplicacin de matrices) *
ACTOR
SISTEMA
algoritmo
iteracin
5. El usuario procesa la informacin 4. Muestra el mnimo n de productos

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
31
Flujo de eventos
Camino bsico del caso de uso Ir a la solucin final
(para Mochila 01)
ACTOR
SISTEMA
2. Muestra el beneficio ptimo final y
1. Ejecuta ver la solucin final
los objetos introducidos en la mochila

visualizada
Flujo de eventos
(para Alineamiento de secuencias)
ACTOR
SISTEMA
2.
Muestra
el
operaciones
para
mnimo
convertir
de
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
32
Flujo de eventos
(para Multiplicacin de matrices)
ACTOR
SISTEMA
2. Muestra el mnimo n de productos
y de qu manera se agrupan las
matrices para obtener dicho valor

mnimo

visualizada
Flujo de eventos
(para Subsecuencia comn ms larga)
ACTOR
SISTEMA
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
algoritmo en su estado inicial (con los

datos del problema)
33
34
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:
35
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
36
Figura 10: Clases del subsistema de visualizacin paso a paso
37
Figura 11 Clases del subsistema de ayuda
Figura 12 La clase que gestiona la interaccin con ficheros de texto
38
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
39
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.
40
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.
41
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
42
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.
43
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.
44
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.
45
46
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.
47
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
48
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
49
Figura 15: Panel de entrada del problema del alineamiento de secuencias
Figura 16: Panel de entrada del problema de cortar una vara
50
Figura 17: Panel de entrada del problema de multiplicacin de matrices
Figura 18: Panel de entrada del problema de la SCML
51
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
52
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
53
Figura 21: Visualizacin paso a paso de la mochila
Figura 22: Solucin de la mochila
54
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
55
Figura 25: Solucin del alineamiento de secuencias
7.3.3 Visualizacin de cortar una vara
Figura 26: Inicializacin de cortar una vara
56
Figura 27: Visualizacin paso a paso de cortar una vara
Figura 28: Solucin de cortar una vara
57
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
58
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
59
Figura 33: Visualizacin pasos a paso de SCML
Figura 34: Solucin de la subsecuencia comn ms larga
60
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
61
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.
62
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.
63
64
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.
65
66
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/dynamicprogramming-set-13-cutting-a-rod/
[11] Crear un fichero en Java. Obtenido de http://lineadecodigo.com/java/crearun-fichero-en-java/
[12] Cuadros de dilogo en Java. Obtenido de http://ayudajava.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/
67
[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-getSystemResourceMethod-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/JITEv7IIP015032Rajala394.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-comunmas-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.).
68

Herramienta para La Visualización de Algoritmos Basados en Programación Dinámica

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Herramienta para La Visualización de Algoritmos Basados en Programación Dinámica

Transféré par

Droits d'auteur :

Formats disponibles

ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA

GRADO EN INGENIERA INFORMTICA

Trabajo Fin de Grado

Herramienta para la visualizacin de

Autor: Juan Antonio Sopale Thompson

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

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

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

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

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

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

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

1.1 Programacin dinmica

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

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

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

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

Proveer al alumnado de una herramienta para el aprendizaje de algoritmos

2. Herramientas de visualizacin de software

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

Las herramientas de visualizacin de software tienen como propsito la

La visualizacin de algoritmos es una abstraccin de alto nivel que

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

La animacin de algoritmos tiene las siguientes ventajas:

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

Un desarrollador se retroalimenta de la visualizacin de algoritmos de tal

La visualizacin le sirve al programador para encontrar errores en la

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

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

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

de algoritmos. Los usuarios pueden aadir sus propios

algoritmos en varios lenguajes de programacin

y generar sus propias

visualizaciones. Adems permite exportar grficos.

3. Especificacin y anlisis de requisitos

3.1 Descripcin del problema

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

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

El usuario podr introducir manualmente los datos del problema

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

3.2 Caractersticas de los usuarios

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

Introducir datos de problema: El usuario introducir los datos del

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

Avanzar en la solucin del problema: El usuario puede avanzar

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

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

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

3.3 Requisitos funcionales

Visualizacin paso a paso del algoritmo:

Avance y retroceso en la solucin del problema:

Introduccin manual de datos:

Carga y guardado de los datos del problema:

3.4 Requisitos de interfaces externos

Interfaces hardware y software: