Solucin de un laberinto mediante la aplicacin de un algoritmo de Backtracking ptimo.

Alberto Corisco Nieto

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

Gunther Calvo Atance

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.

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.

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

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. 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). 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. 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

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. 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. Este tipo de algoritmos pueden encontrar una o todas las soluciones, siguiendo los siguientes esquemas:

4.1

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

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).

4.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.5

El Problema de la Mochila

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.

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.

5. 5.1

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

Algoritmo

Figura 6.posicin inicial Y para obtener la solucin del problema se debe llegar a este estado:

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. 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.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).

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.

* 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[]; //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
5.5.1

Cdigo Fuente
BTAlgorithm

package backtracker; 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(); } /*

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); } }

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.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;

5.5.4

BackTracker

i=Integer.parseInt(alto.getText()); j=Integer.parseInt(ancho.getText()); k=Integer.parseInt(pisos.getText()); 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]);

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;

} } mapa[kk].doLayout(); } tablero.doLayout(); doLayout(); } public void actionPerformed(ActionEvent arg0) { String buttonName=((Button)arg0.getSource()).getName(); 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);

ancho.setText(""); ancho.setEnabled(true); pisos.setText(""); pisos.setEnabled(true); } repaint(); } public void mouseClicked(MouseEvent arg0) { Casilla source=(Casilla)arg0.getSource(); 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(); } 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.
[1] [2] [3]

REFERENCIAS
http://www.algoritmia.net/ http://en.wikipedia.org http://www.uhu.es/nieves.pavon/pprogramacion/te mario/tema4/tema4.html

Apuntes IRC uc3m 2006