Solucin de un laberinto mediante la aplicacin de un

algoritmo de Backtracking ptimo.

Alberto Corisco Nieto

Gunther Calvo Atance

100021578@alumnos.uc3m.es 100029567@alumnos.uc3m.es

1.

INTRODUCTION

Se utilizara un algoritmo heurstico (CSP) para obtener la

solucin ptima de un laberinto. El algoritmo que se ha
implementado es el algoritmo de backtracking.

2.

OBJETIVOS

Nuestro principal objetivo ser solucionar un laberinto, el cual se

podr crear de diferentes formas, ya sea por medio de la
aplicacin creada o por un fichero de texto, encontrando la
salida optima del mismo, esto es, en el caso de que el laberinto
tuviera varias salidas se dara por buena aquella que tenga un
menor nmero de pasos, entendiendo por pasos cada una de las
posiciones de la matriz donde mapearemos el laberinto para
poder operar con el.

3.

ESTRATEGIA

estudiar todo el espacio del laberinto sino que una vez

encontrada una salida solo se consideraran caminos validos
aquellos con menor longitud que la salida actual.
De modo que esto ultimo se puede entender como una poda del
rbol de todas aquellas ramas cuya profundidad (numero de
nodos por los que se ha pasado) es igual a la profundidad de la
solucin encontrada hasta el momento de modo que solo se
tomara como valida otra solucin que no pueda ser detenida por
la poda del rbol, lo que viene a significar otra solucin con una
profundidad menor que la de la solucin actual.
Otros problemas para los que tambin es til utilizar este tipo de
algoritmo son, por ejemplo, obtener la solucin de un sudoku o
el mnimo cableado de un circuito.

4.

RESOLUCION DE PROBLEMAS

El algoritmo utilizado ser el algoritmo de backtracking,

optimizado para encontrar la solucin con menor coste, esto es
el camino a recorrer que tiene un menor numero de pasos.

Los problemas a solucionar por este tipo de algoritmos, son

aquellos que se pueden representar como un rbol, el algoritmo
de backtracking lo recorrer en profundidad.

El backtracking es un algoritmo que utiliza una estrategia de

bsqueda en profundidad y busca la mejor combinacin de las
variables para solucionar el problema. Durante la bsqueda, si se
encuentra una alternativa incorrecta, la bsqueda retrocede hasta
el paso anterior y toma la siguiente alternativa. Cuando se han
terminado las posibilidades, se vuelve a la eleccin anterior y se
toma la siguiente opcin. Si no hay ms alternativas la bsqueda
falla. De esta manera, se crea un rbol implcito, en el que cada
nodo es un estado de la solucin (solucin parcial en el caso de
nodos interiores o solucin total en el caso de los nodos hoja).

En algunas ocasiones el rbol que genera el problema es muy

grande y encontrar una solucin o la solucin ptima es
computacionalmente muy costoso. En estos casos se suele podar
el rbol, es decir no se recorrern ciertos nodos porque debido a
ciertas caractersticas en los mismos ya sabemos que no se
obtendr una mejor solucin a la que ya se tiene o que
simplemente no se obtendr solucin.

Hemos implementado el algoritmo de forma recursiva, a cada

llamada le asignamos una direccin posible en la que
desplazarse a una nueva posicin de la matriz donde se volver a
evaluar los posibles movimientos, si llega un momento que no
puede acceder a ninguna posicin no visitada ya desde el lugar
actual, se considera q se llego a un punto muerto y se vuelve al
nodo anterior donde se mover a la siguiente posicin posible.

4.1

De este modo el algoritmo ira recorriendo todo el espacio del

laberinto hasta encontrar una salida, y una vez encontrada
volver hacia atrs para ver si es posible encontrar otro camino
con un menor numero de pasos, con lo que no es necesario

Este tipo de algoritmos pueden encontrar una o todas las

soluciones, siguiendo los siguientes esquemas:

Esquema para una solucin

procedimiento ensayar (paso)

repetir
|seleccionar candidato
|if aceptable then
|begin
| anotar_candidato
| if solucion_incompleta then
| begin
| ensayar (paso_siguiente)
| if no_acertado then borrar_candidato
| end

| else begin
| anotar_solucion
| acertado cierto
| end
hasta que (acertado = cierto ) o (candidatos agotados)
fin procedimiento

4.2

Esquema para todas las soluciones

procedimiento ensayar (paso)

para cada candidato hacer
|seleccionar candidato
|if aceptable then
|begin
| anotar_candidato
| if solucion_incompleta then
| begin
| ensayar (paso_siguiente)
| else
| almacenar_solucion
| borrar_candidato
| end
hasta que (candidatos agotados)
fin procedimiento

4.3

Figura 2.solucin de la vuelta del caballo.

4.3.2

El Problema de las Ocho Reinas

Consiste en colocar en un tablero ocho reinas de tal modo que

ninguna pueda comer a otra, es decir se colocan de tal forma que
ninguna reina esta en la misma fila, en la misma columna o en
cualquiera de las diagonales de cualquiera del resto de las reinas.
A continuacin ilustramos con un dibujo una posible solucin a
este problema (Figura 3).

Algunos Ejemplos

Adems del problema del laberinto, existen otros muchos

problemas que pueden ser solucionados por medio del algoritmo
del backtracking como son:

4.3.1

La Vuelta del Caballo

Consiste en que partiendo de un tablero de ciertas dimensiones,

y una posicin inicial cualquiera una pieza de ajedrez, en este
caso un caballo, debe pasar por cada posicin del tablero una
sola vez y recorrerlo completamente. Todo esto siguiendo el
movimiento que corresponde a dicha pieza en el ajedrez.
A continuacin mostramos un tablero con dicha pieza colocada
en el centro, y las posibles posiciones a las que podr acceder
partiendo de la posicin inicial (Figura 1)

Figura 3.posicin de las ocho reinas.

4.3.3

El Problema del Sudoku

Consiste en rellenar un cuadrado de 9x9 formado a su vez por 9

cuadrados de 3x3. En cada cuadrado pequeo se debe colocar un
nmero del 1 al 9, pero sin que se repita en filas o en columnas.
Un ejemplo de un sudoku es el siguiente:

Figura 1.Movimientos posibles.

A continuacin se mostrara una solucin a dicho problema en la
que el caballo parte de la esquina superior izquierda (pudiendo
ser la posicin inicial cualquiera del tablero)
Se puede ver por medio de los nmeros en cada una de las
posiciones como efectivamente el caballo recorre todo el tablero
pasando nicamente una vez por cada casilla (Figura 2).
Figura 4.Sudoku

Y aplicando el algoritmo se obtiene:

Figura 7.posicin final

Figura 5. Sudoku resuelto

4.3.4

Torres de Hanoi

El juego consta de tres varillas verticales y un nmero

indeterminado de discos que determinarn la complejidad de la
solucin. No hay dos discos iguales, estn colocados de mayor a
menor en la primera varilla ascendentemente, y no se puede
colocar ningn disco mayor sobre uno menor a l en ningn
momento. El juego consiste en pasar todos los discos a la tercera
varilla colocados de mayor a menor ascendentemente.
Inicialmente las varillas y los discos estn colocados de cierta
forma vase Figura 6 y se debe llegar a colocarlos de la siguiente
forma Figura 7.

4.3.5

5.
5.1

Y para obtener la solucin del problema se debe llegar a este

estado:

IMPLEMENTACION
Descripcin General

La implementacin se divide en dos bloques claramente

diferenciados: la implementacin del algoritmo propiamente
dicho y la de la interfaz grfica o GUI.

5.2

Figura 6.posicin inicial

El Problema de la Mochila

Consiste en llenar una mochila con una serie de objetos que

tienen una serie de pesos con un valor asociado. Es decir, se
dispone de n tipos de objetos y no hay un nmero limitado de
cada tipo de objeto. Cada tipo i de objeto tiene un peso wi
positivo y un valor vi positivo asociados. La mochila tiene una
capacidad de peso igual a W. Se trata de llenar la mochila de tal
manera que se maximice el valor de los objetos incluidos pero
respetando al mismo tiempo la restriccin de capacidad. Notar
que no es obligatorio que una solucin ptima llegue al lmite de
capacidad de la mochila.

Algoritmo

La implementacin se ha llevado a cabo mediante llamadas

recursivas partiendo de la casilla origen. El diagrama de flujo
correspondiente se muestra en la Figura 8. El mtodo se
inicializa sobre la posicin de la casilla origen y un paso de 1. A
partir de ah se mira si dicha casilla es la final, en caso
afirmativo se introduce la posicin en el camino solucin que se
devuelve a la funcin llamante. En caso negativo, se comprueba
que no se pueda llegar a dicha casilla por un camino ms corto
(menor nmero de pasos).
En dicho caso se devuelve null al mtodo llamante pues ste
camino no es una posibilidad viable; de no ser as, se actualiza la
distancia de sta casilla al origen, se obtienen los movimientos
posibles desde dicha casilla y se llama al mtodo de forma
recurrente para cada uno de ellos.
Se comparan las distancias relativas hasta la meta para cada una
de las posibilidades; se aade la casilla actual al camino de la
mejor de las soluciones y se devuelve dicho camino al mtodo
llamante.

Debido a la naturaleza basada en eventos intrnseca a las

interfaces grficas y al carcter secuencial de la definicin de un
laberinto (definicin del mapa, de los puntos de salida y
llegada,) hemos optados por un diseo basado en estados.

Figura 8.Diagrama de flujo del algoritmo

Mediante sta implementacin del algoritmo no solo se obtiene
un camino entre el origen y el final, si no que ste es ptimo (es
un camino que implica un nmero mnimo de pasos). Esto se
consigue gracias a la comparacin de los caminos obtenidos para
cada una de las posibilidades. Un algoritmo ms eficiente pero
menos ptimo empleara sta segunda estrategia.

5.3

Interfaz Grfico

El objetivo de sta prctica era la implementacin de un

algoritmo ptimo de Backtracking; sin embargo, se hace
necesario demostrar su funcionalidad y para ello decidimos huir
de la esterilidad de la lnea de comandos y disear un interfaz
grfico agradable que permitiese de forma sencilla poner a
prueba las capacidades del algoritmo (vease figura 9).

Figura 10. Diagrama de estados de la GUI

Los estados definidos son:

Cero: sistema iniciado y preparado para cargar un

mapa desde un fichero o generar una cuadrcula en
blanco de dimensiones definidas.

Uno: a la espera de que el usuario realice cambios en

la topologa del mapa (aadir/eliminar casillas muro o
pasillo).

Dos: emplazamiento de la casilla de salida (marcada

en azul).

Tres: emplazamiento de la casilla de llegada (marcada

en verde).

Cuatro: muestra de la resolucin del problema

marcando el camino ptimo en rojo.
La transicin de unos estados a otros se realiza mediante los
eventos generados al presionar los botones (reset y general)
presentes en la parte inferior de la ventana de acuerdo con el
diagrama de flujo de la Figura 10.

5.4

Codificacin

Como Lenguaje de programacin escogimos Java por la amplia

experiencia que tenemos con dicho entorno. El programa se
compone de cuatro clases:

Posicion - representa un punto en coordenadas

cartesianas.

Casilla - La clase Casilla representa una casilla en el

mapa del laberinto a resolver. Se compone
bsicamente de un elemento Posicion que define su
situacin en el mapa, un entero para almacenar el
numero de pasos mnimos necesarios para alcanzar
dicha Posicion desde la Casilla de salida y un
booleano indicador de si dicha Casilla forma parte de
la solucin. Al ser parte fundamental de la GUI,
Figura 9. Resolucin de un laberinto de 20x10x2

Casilla es un tipo Canvas extendido. Los colores

mostrados por cada casilla significan:
- gris - muro
- blanco - pasillo
- azul - casilla de salida
- verde - casilla de llegada
- rojo - casilla perteneciente al camino solucin
BTAlgorithm implementa el algoritmo Backtracking
ptimo utilizado para resolver el laberinto.
BackTracker sta clase compone la parte grfica de
la aplicacin.

5.5

Cdigo Fuente

5.5.1

BTAlgorithm

package backtracker;

* Metodo que implementa de forma recursiva el algoritmo de

backtracking.
* p - es la posicion de la Casilla a analizar
* paso - el numero de saltos necesarios para alcanzar dicha Casilla por
el camino analizado
*/
public Vector<Posicion> camino(Posicion p,int paso){
Vector<Posicion> miCamino=new Vector<Posicion>(1,1);
//Comprueba que no se haya encontrado el final
if(mapa[p.getX()][p.getY()][p.getZ()].isNotTheEnd()){
//Comprueba que no se pueda llegar a esta Casilla con un
numero menor de pasos
if((mapa[p.getX()][p.getY()][p.getZ()].getStep())>=(paso)){
//parametros utilizados para encontrar el camino mas corto de
enter todos los posibles desde esta casilla
int mejordistancia=Integer.MAX_VALUE;
Vector<Posicion> suMejorCamino=null;
Vector<Posicion> suCamino;
Object movs[];

import java.util.Vector;
/*
* Esta case implementa el algoritmo de BackTracking optimo
*/
public class BTAlgorithm{
//dimensiones del mapa
private int dim_x;
private int dim_y;
private int dim_z;
//sucesion de casillas que conforman la solucion
Vector movP;
//mapa del laberinto
Casilla mapa [][][];
public BTAlgorithm(Casilla mapa[][][]) {
this.mapa=mapa;
dim_x=mapa.length;
dim_y=mapa[0].length;
dim_z=mapa[0][0].length;
movP=new Vector();
}
/*
* Este etodo analiza las Casilla circundantes y devuelve un array con
las posiciones donde hay pasillo
*/
Object[] movPosibles(Posicion p){
Vector<Posicion> m=new Vector<Posicion>(3,1);
if(p.getY()>0 && mapa[p.getX()][(p.getY()-1)][p.getZ()].isNotWall()){
m.addElement(new Posicion(p.getX(),(p.getY()-1),p.getZ()));
}
if(p.getY()<(dim_y-1) &&
mapa[p.getX()][(p.getY()+1)][p.getZ()].isNotWall()){
m.addElement(new Posicion(p.getX(),(p.getY()+1),p.getZ()));
}
if(p.getX()>0 && mapa[(p.getX()-1)][p.getY()][p.getZ()].isNotWall()){
m.addElement(new Posicion((p.getX()-1),p.getY(),p.getZ()));
}
if(p.getX()<(dim_x-1) &&
mapa[(p.getX()+1)][p.getY()][p.getZ()].isNotWall()){
m.addElement(new Posicion((p.getX()+1),p.getY(),p.getZ()));
}
if(p.getZ()>0 && mapa[p.getX()][(p.getY())][p.getZ()-1].isNotWall()){
m.addElement(new Posicion(p.getX(),(p.getY()),p.getZ()-1));
}
if(p.getZ()<(dim_z-1) &&
mapa[p.getX()][(p.getY())][p.getZ()+1].isNotWall()){
m.addElement(new Posicion(p.getX(),(p.getY()),p.getZ()+1));
}
m.trimToSize();
return m.toArray();
}
/*

//se actualiza el valor de paso de la casilla actual

mapa[p.getX()][p.getY()][p.getZ()].setStep(paso);
//se buscan los posibles movimientos se puedan hacer desde
aqui
movs=movPosibles(p);
//para cada posible camino
for(int i=0;i<movs.length;i++){
//calcular la solucion
suCamino=camino((Posicion)movs[i],paso+1);
//si se encontro una solucion, comparar el numero de pasos
necesarios para esta solucion con las otras posibilidades
if( (suCamino!=null) && (mejordistancia>suCamino.size())
){
//por ahora es el mejor camino, actualizar mejor
distancia
suMejorCamino=suCamino;
mejordistancia=suCamino.size();
}
}
//si no se encontro ninguna solucion
if(suMejorCamino==null)
return null;
//si se encontro, aadir esta casilla a la solucion
miCamino=suMejorCamino;
miCamino.add(p);
}
else{
return null;
}
}
else{
miCamino.addElement(p);
}
return miCamino;
}
}

5.5.2

Posicion

package backtracker;
/*
* La clase Posicion representa un punto en coordenadas cartesianas
*/
public class Posicion {
private int x;
private int y;
private int z;
public Posicion(int x,int y,int z) {
this.x=x;
this.y=y;
this.z=z;
}
public void setX(int nx){
x=nx;
}

public int getX(){

return x;
}
public void setY(int ny){
y=ny;
}
public int getY(){
return y;
}
public void setZ(int nz){
z=nz;
}
public int getZ(){
return z;
}
public String toString(){
return "x=" + String.valueOf(x) + " y=" + String.valueOf(y) + " z=" +
String.valueOf(z);
}
}

5.5.3

Casilla

package backtracker;
import java.awt.Color;
import java.awt.*;
/*
* La clase Casilla representa una casilla en el mapa del laberinto a
resolver.
* Se compone bsicamente de un elemento Posicion que define su
situacin en el mapa,
* un entero para almacenar el numero de pasos minimos necesarios para
alcanzar dicha
* posicion desde la Casilla de salida y un booleano indicador de si dicha
Casilla
* forma parte de la solucin.
* Al ser parte fundamental de la GUI, Casilla es un tipo Canvas extendido.
*/
public class Casilla extends Canvas{
//elemento Posicion que define su situacin en el mapa. Valores
especiales son:
private Posicion pos;
/*
* numero de pasos minimos necesarios para alcanzar dicha posicion
desde la Casilla de salida
* -1 si es representa un elemento no navegable (muro)
* 0 si representa la casilla de llegada
* 1 si representa la casilla de salida
*/
private int step;
//indicador de si dicha Casilla forma parte de la solucin
private boolean marked;
public Casilla(int x, int y, int z){
setBackground(Color.LIGHT_GRAY);
pos=new Posicion(x,y,z);
step=-1;
marked=false;
}
public String toString(){
return pos.toString() + " step= " + String.valueOf(step) + " marked= "
+ String.valueOf(marked);
}
//reinicia la casilla a su valor previo al calculo de la solucin
public void reset(){
if(isNotWall()){
unmark();
step=Integer.MAX_VALUE;
}
}
//cambia la naturaleza de la Casilla entre muro y pasillo
public void changeState(){
if(isNotWall()){
step=-1;
setBackground(Color.LIGHT_GRAY);
}
else{
step=Integer.MAX_VALUE;

setBackground(Color.WHITE);
}
}
public void mark(){
if(isNotTheEnd() & isNotTheBeginning() & isNotWall()){
setBackground(Color.RED);
marked=true;
}
}
public void unmark(){
if(marked)
setBackground(Color.WHITE);
}
public boolean isWall(){
return step == -1;
}
public boolean isNotWall(){
return step != -1;
}
public boolean isTheEnd(){
return step==0;
}
public boolean isNotTheEnd(){
return step!=0;
}
public void setAsEnd(){
step=0;
setBackground(Color.GREEN);
}
public void unsetAsEnd(){
step=Integer.MAX_VALUE;
setBackground(Color.WHITE);
}
public boolean isTheBeginning(){
return step==1;
}
public boolean isNotTheBeginning(){
return step!=1;
}
public void setAsBeginning(){
step=1;
setBackground(Color.BLUE);
}
public void unsetAsBeginning(){
step=Integer.MAX_VALUE;
setBackground(Color.WHITE);
}
public void setStep(int i){
step=i;
}
public int getStep(){
return step;
}
public void setPosicion(Posicion p){
pos=p;
}
public Posicion getPosicion(){
return pos;
}
public void setX(int nx){
pos.setX(nx);
}
public void setY(int ny){
pos.setY(ny);
}
public void setZ(int nz){
pos.setZ(nz);
}
public int getX(){
return pos.getX();
}
public int getY(){
return pos.getY();
}
public int getZ(){
return pos.getZ();
}

5.5.4

BackTracker

i=Integer.parseInt(alto.getText());
j=Integer.parseInt(ancho.getText());
k=Integer.parseInt(pisos.getText());

package backtracker;
import java.awt.event.*;
import java.awt.*;
import java.util.Vector;
import java.io.*;
/*
* Esta clase implementa la GUI
*/
public class BackTracker extends java.applet.Applet implements
MouseListener, ActionListener, ItemListener{
private static final long serialVersionUID = 1L;
int state;
boolean endMarked, beginningMarked;
Casilla beginningTile, endTile;
Casilla maze[][][];
Panel tablero;
Panel control;
Panel mapa[];
Button reset;
Button general;
Checkbox ffile;
TextField alto;
TextField ancho;
TextField pisos;
Label altoL;
Label anchoL;
Label pisosL;
public void init() {
state=0;
endMarked=false;
beginningMarked=false;
setSize(500,600);
reset=new Button("Resetear");
reset.setName("reset");
reset.setEnabled(false);
reset.addActionListener(this);
general=new Button("Siguiente");
general.setName("general");
general.addActionListener(this);
ffile=new Checkbox("File",false);
ffile.addItemListener(this);
alto=new TextField(3);
ancho=new TextField(3);
pisos=new TextField(2);
altoL=new Label("Alto");
anchoL=new Label("Ancho");
pisosL=new Label("Pisos");
setLayout(new BorderLayout());
tablero=new Panel();
tablero.setBackground(Color.RED);
add(tablero,BorderLayout.CENTER);
control=new Panel();
control.setBackground(Color.BLUE);
add(control,BorderLayout.SOUTH);
control.add(reset);
control.add(general);
control.add(ffile);
control.add(altoL);
control.add(alto);
control.add(anchoL);
control.add(ancho);
control.add(pisosL);
control.add(pisos);
doLayout();
}
public String getAppletInfo() {
return "Title: BackTracker";
}
private void loadWithoutFile(){
int i,ii, j,jj, k,kk;

maze=new Casilla[i][j][k];
mapa=new Panel[k];
setSize(k*500,600);
for(kk=0; kk<k; kk++){
mapa[kk]=new Panel();
mapa[kk].setSize(500,500);
mapa[kk].setBackground(Color.BLACK);
mapa[kk].setLayout(new GridLayout(i,j,1,1));
tablero.setLayout(new GridLayout(1,k,5,5));
tablero.add(mapa[kk]);
for(ii=0; ii<i; ii++){
for(jj=0; jj<j; jj++){
maze[ii][jj][kk]=new Casilla(ii,jj,kk);
maze[ii][jj][kk].addMouseListener(this);
mapa[kk].add(maze[ii][jj][kk]);
}
}
mapa[kk].doLayout();
}
tablero.doLayout();
doLayout();
}
private void loadFromFile(){
BufferedReader br;
FileDialog fd;
Vector<String> lines=new Vector<String>();
String line;
char marcas[][];
int i,ii, j,jj, k,kk;
fd=new FileDialog(new Frame(),"Abrir",FileDialog.LOAD);
fd.setVisible(true);
try {
br=new BufferedReader(new
FileReader(fd.getDirectory().concat(fd.getFile()) ));
line=br.readLine();
while(line!=null){
lines.add(line);
line=br.readLine();
}
br.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
}
marcas=new char[lines.size()][((String)lines.elementAt(0)).length()];
for(int merlo=0;merlo<marcas.length;merlo++)
marcas[merlo]=((String)lines.elementAt(merlo)).toCharArray();
i=marcas.length;
j=marcas[0].length;
k=1;
maze=new Casilla[i][j][k];
mapa=new Panel[k];
setSize(k*500,600);
for(kk=0; kk<k; kk++){
mapa[kk]=new Panel();
mapa[kk].setSize(500,500);
mapa[kk].setBackground(Color.BLACK);
mapa[kk].setLayout(new GridLayout(i,j,1,1));
tablero.setLayout(new GridLayout(1,k,5,5));
tablero.add(mapa[kk]);
for(ii=0; ii<i; ii++){
for(jj=0; jj<j; jj++){
maze[ii][jj][kk]=new Casilla(ii,jj,kk);
if(marcas[ii][jj]!='*')
maze[ii][jj][kk].changeState();
maze[ii][jj][kk].addMouseListener(this);
mapa[kk].add(maze[ii][jj][kk]);

ancho.setText("");
ancho.setEnabled(true);
pisos.setText("");
pisos.setEnabled(true);

}
}
mapa[kk].doLayout();
}
tablero.doLayout();
doLayout();

}
repaint();
}
public void mouseClicked(MouseEvent arg0) {
Casilla source=(Casilla)arg0.getSource();

}
public void actionPerformed(ActionEvent arg0) {
String buttonName=((Button)arg0.getSource()).getName();

switch(state){
case 1:
source.changeState();
break;
case 2:
if(beginningMarked){
if(source.isTheBeginning()){
source.unsetAsBeginning();
beginningTile=null;
beginningMarked=false;
}
}else if(source.isNotWall()){
source.setAsBeginning();
beginningTile=source;
beginningMarked=true;
}
break;
case 3:
if(endMarked){
if(source.isTheEnd()){
source.unsetAsEnd();
endTile=null;
endMarked=false;
}
}else if(source.isNotWall()){
source.setAsEnd();
endTile=source;
endMarked=true;
}
break;
}
source.repaint();

if( buttonName.equals("general") ){
switch(state){
case 0:
if(ffile.getState())
loadFromFile();
else
loadWithoutFile();
general.setLabel("definir");
state=1;
reset.setEnabled(true);
ffile.setEnabled(false);
alto.setEnabled(false);
ancho.setEnabled(false);
pisos.setEnabled(false);
break;
case 1:
general.setLabel("salida?");
state=2;
break;
case 2:
general.setLabel("llegada?");
if(beginningMarked)
state=3;
break;
case 3:
general.setLabel("resolver");
if(endMarked){
Posicion p;
BTAlgorithm solver=new BTAlgorithm(maze);
Vector
elCamino=solver.camino(beginningTile.getPosicion(),1);
elCamino.trimToSize();
for(int pp=0;pp<elCamino.size();pp++){
p=(Posicion)elCamino.elementAt(pp);
maze[p.getX()][p.getY()][p.getZ()].mark();
}
solver=null;
elCamino=null;
state=4;
}
break;
case 4:
general.setLabel("definir");
for(int a=0; a<maze.length;a++)
for(int b=0;b<maze[0].length;b++)
for(int c=0;c<maze[0][0].length;c++)
maze[a][b][c].reset();
state=1;
beginningTile.unsetAsBeginning();
beginningMarked=false;
endTile.unsetAsEnd();
endMarked=false;
break;
}
}else if( buttonName.equals("reset") ){
tablero.removeAll();
state=0;
maze=null;
mapa=null;
beginningMarked=false;
endMarked=false;
setSize(500,600);
reset.setEnabled(false);
general.setLabel("definir");
ffile.setState(false);
ffile.setEnabled(true);
alto.setText("");
alto.setEnabled(true);

}
public void itemStateChanged(ItemEvent arg0) {
if(((Checkbox)arg0.getSource()).getState()){
alto.setEnabled(false);
ancho.setEnabled(false);
pisos.setEnabled(false);
}else{
alto.setEnabled(true);
ancho.setEnabled(true);
pisos.setEnabled(true);
}
}
public void mouseEntered(MouseEvent arg0) {}
public void mouseExited(MouseEvent arg0) {}
public void mousePressed(MouseEvent arg0) {}
public void mouseReleased(MouseEvent arg0) {}
}

6.

REFERENCIAS

[1]

http://www.algoritmia.net/

[2]

http://en.wikipedia.org

[3]

http://www.uhu.es/nieves.pavon/pprogramacion/te
mario/tema4/tema4.html

Apuntes IRC uc3m 2006