MEMORIA DE LA PRÁCTICA DE PROGRAMACIÓN III CURSO

Transcripción

1 MEMORIA DE LA PRÁCTICA DE PROGRAMACIÓN III CURSO CENTRO ASOCIADO DE ALBACETE

2 Contenido: 1. RESPUESTAS A LAS CUESTIONES PLANTEADAS EN EL ENUNCIADO Características de la aplicación del esquema al problema planteado 1.2. Descripción del grafo asociado al espacio de soluciones 1.3. Función de coste para la selección del nodo más prometedor 1.4. Cálculo de una cota del valor de las soluciones generadas 1.5. Estructura de datos utilizada para el almacenamiento de los nodos no explorados 1.6. Pseudocódigo del esquema y de su instanciación al problema 1.7. Coste computacional del programa desarrollado 2. EJEMPLO DE EJECUCIÓN PARA EL CASO DE PRUEBA. 3. ESTUDIO DEL COSTE DEL ALGORITMO. 4. LISTADO DEL CÓDIGO FUENTE COMPLETO Clase Puzzle 4.2. Clase Resuelve 4.3. Clase Nodo 4.4. Clase Arbol 4.5. Clase Traduce i

3 1.- RESPUESTAS A LAS CUESTIONES PLANTEADAS EN EL ENUNCIADO Características particulares de la aplicación del esquema al problema planteado. 1.1.a.- Estructura de datos asociada al puzzle. Como estructura de datos para almacenar las fichas se ha elegido un array de n 2 enteros, dado el carácter fijo del número de fichas de los puzzles, y la facilidad de cálculo de la posición relativa de las fichas respecto a la posición final requerida. El uso de un array permite también una identificación rápida de identidad entre puzzles (con la comparación en secuencia de sus datos) e incluso la ordenación entre ellos, para facilitar su búsqueda. 1.1.b.- Adaptación del esquema general. El esquema general de ramificación y poda permite la utilización de varias estrategias a la hora de generar los nodos. Para la elección del nodo a expandir podemos seguir un recorrido del grafo de soluciones en anchura o en profundidad. O bien podemos utilizar un cálculo previo de una función de coste que nos permita seleccionar el nodo en principio más prometedor, el de menor coste. Debido al alto número de nodos diferentes posibles obtenidos al modificar el inicial adoptaremos esta última, para reducir al máximo el número de nodos a analizar. Para implementar la citada estrategia de minimización de costes, los nodos generados se almacenarán en una estructura de datos que permita la selección del nodo de menor coste de manera eficiente, que se describirá en el punto c.- Consideraciones en la expansión del grafo de soluciones. Debemos tener en cuenta la posibilidad de aparición de ciclos en la generación de los nodos. Si uno de los nodos del grafo de soluciones es igual a uno de sus ascendientes, generará en una de sus ramas un grafo igual al que se desarrolla a partir de ese antecesor repetido, lo que multiplicará los nodos a investigar de manera superflua, ya que este subgrafo, si contiene la solución, siempre tendrá un camino de mayor longitud que la de aquel del que se deriva. Para evitar la aparición de los aludidos ciclos, al generar los descendientes de cada nodo se comprobará: que ninguno de ellos es igual a su padre, mediante el descarte del movimiento opuesto al que generó el nodo evaluado, y que ninguno de ellos ha sido ya evaluado, por medio de la exploración de un árbol binario de búsqueda (ordenado por el valor de las casillas de cada puzzle comprobadas en orden ascendente). Se utiliza una estructura diferente a la de la selección del nodo más prometedor debido al diferente criterio de búsqueda a utilizar: ordenados por coste en la selección del nodo (varios nodos diferentes pueden tener el mismo coste) y por el valor de las casillas (que pretendemos que nunca sea igual). 1

4 1.2.- Descripción del grafo asociado al espacio de soluciones. Las soluciones se distribuyen en un árbol cuya raíz es el puzzle inicial. A partir de ella se desarrollan las diferentes ramas, que serán generadas expandiendo cada uno de los nodos. Los hijos de un nodo se generan al ir moviendo las fichas del puzzle padre; tomando como referencia el caso de prueba, los movimientos aparentes del hueco podrán ser: Arriba (norte), intercambio de posición con el Abajo (sur), intercambio de posición con el 8. Derecha (este), intercambio de posición con el Izquierda (oeste), intercambio de posición con el De esta manera tenemos un máximo de cuatro movimientos a partir de cada nodo. Según hemos visto en el punto 1.1.c, debemos rechazar siempre al menos uno de los movimientos posibles del hueco, aquel que deshaga el último realizado. Esto nos da un máximo de tres hijos para cada nodo distinto del raíz (que no tiene un movimiento anterior), sin tener en cuenta la posición del nodo, que puede hacer descartar a su vez los movimientos que lo puedan sacar del tablero. Por lo tanto, el árbol asociado al espacio de soluciones será un árbol ternario, con la excepción del primer nivel de descendientes, que podrá ser de cuatro hijos Función de coste para seleccionar el nodo más prometedor. Dado que lo que buscamos es la solución con menos movimientos realizados, la función de coste la estableceremos como la suma de dos factores, los movimientos realizados hasta llegar al nodo evaluado y una estimación de los movimientos restantes hasta alcanzar la solución. f coste =(movimientos realizados) + f movimientos estimados Para el cálculo aproximado de los movimientos restantes se usará la suma de las distancias de Manhattan de cada ficha a su posición final. Ésta se calcula en nuestro caso contando las filas y columnas que diferencian las posiciones actual y final de cada ficha. Dará un número de movimientos cercano al real pero no exacto, ya que no tiene en cuenta que al mover una ficha pueden descolocarse otras (y acercarse a su posición final o alejarse de la misma). 2

5 distancia=math.abs((pos/numfilas)-(posfinal/numfilas)) + Math.abs((pos%numFilas)-(posfinal%numFilas)); pos, posfinal: son las posiciones de la ficha dentro del array de datos del nodo y de la solución, respectivamente. pos/numfilas da la fila de la casilla; pos%numcolumnas da la columna. Como ejemplo presentamos el caso de prueba, resoluble en cuatro movimientos: Valores Distancias movs. hechos distancia = 4 coste = 4 Por tanto, para seleccionar el nodo más prometedor usaremos una estrategia de mínimo coste (LC), implementada en la ordenación de la estructura de datos en la que se almacenarán los nodos aún no desarrollados: la extracción del nodo a analizar en cada iteración debe proporcionar el nodo de menor coste de los almacenados Cálculo de una cota del valor de las soluciones que se encontrarán generando sucesores a un determinado nodo. Inicialmente tomaremos como cota un número de movimientos que depende de la magnitud de n; tomaremos 1 para n=1 (trivial), 6 para n=2 (1), 31 para n=3 (2), 80 para n=4 (3) y 1000 para n>4. A esta cota le añadimos un margen de trabajo de 2, dado que a veces la función de coste sobreestima ligeramente los movimientos restantes, como acabamos de ver en 1.3. Una vez encontrada la primera solución, se toma como cota el número de movimientos de la misma, para desarrollar sólamente nodos con coste menor o igual que el de la solución encontrada Estructura de datos utilizada para almacenar en orden de prioridad los nodos creados y aún no explorados. Se utiliza un montículo de mínimos, implementado mediante la clase PriorityQueue de Java 5.0. La inserción y la extracción de la raíz las realiza en O(log(n)). La comprobación de estado vacío y del número de nodos contenidos se obtiene en tiempo constante (4). Para la implementación de la estrategia LC nos bastará con extraer la raíz como selección del nodo más prometedor. Tras esa extracción, la clase automáticamente restaura la condición de montículo de mínimos. (1) (2) (3) (4) Java 2.0 Platform Standard Edition 5.0 API Specification 3

6 1.6.- Pseudocódigo correspondiente al esquema y a su instanciación al problema. El esquema general es el siguiente: fun ramificación-y-poda (ensayo) dev ensayo m montículo-vacío cota-superior cota-superior-inicial solución solución-vacía añadir-elemento (ensayo, m) mientras vacío (m) hacer nodo extraer-raíz si válido(nodo) entonces hacer si coste (nodo) < cota-superior entonces hacer solución nodo cota-superior coste (nodo) fsi si no si cota-inferior (nodo) cota-superior entonces dev solución si no para cada hijo en expandir (nodo) hacer si condiciones-de-poda(hijo) y cota-inferior(hijo)< cota-superior entonces añadir-nodo (hijo, m) fsi fpara fsi fsi fmientras ffun En nuestro caso en particular no necesitamos el uso de una cota inferior, ya que lo que buscamos es un tablero resuelto, comprobado tras la llamada a es-solución (nodo). Como hemos comentado antes, usaremos dos estructuras para almacenar los nodos, un montículo para los nodos no visitados y otro para los que ya hemos evaluado; la función expandir debe comprobar que los hijos que genere no han sido ya visitados, para evitar ciclos. Incluimos el pseudocódigo de la función expandir en la presentación de la instanciación del problema. 4

7 Esquema adaptado al problema: fun RyP (ensayo) dev ensayo m montículo-vacío a árbol-vacío cota-superior cota-superior-inicial solución solución-vacía añadir-elemento (ensayo, m) mientras vacío (m) hacer nodo extraer-raíz (m) si es-solución (nodo) entonces hacer solución nodo cota-superior coste (nodo) si cota (nodo) < cota-superior entonces para cada hijo en expandir (nodo, a) hacer añadir (hijo, m) fpara fsi añadir (nodo, a) fmientras dev solución ffun fun expandir (ensayo, a) dev lista lista lista-vacía para cada movimiento válido hacer si generar-ensayo(movimiento) Є a entonces hijo generar ensayo(movimiento) lista insertar (hijo) fsi fpara dev lista ffun Análisis del coste computacional del programa desarrollado. Para el cálculo del coste existe la dificultad de no conocer a priori el tamaño del problema. El tamaño del puzzle es siempre conocido, n = número de filas, y sabemos que el número máximo de nodos del árbol de sucesores del puzzle inicial es n 2!/2 (5). La estrategia LC pretende reducir al mínimo el número de nodos visitados (y, por lo tanto, expandidos) dentro del citado árbol mediante el uso de una función (5) 5

8 heurística h que escoge el nodo más prometedor mediante la estimación del número de movimientos necesarios. Pero no puede calcular cuántos nodos se deberán visitar para encontrar la solución. Las llamadas más costosas son las realizadas al montículo (inserción y extracción de la raíz) y al árbol de nodos visitados (inserción y búsqueda), y su coste depende en ambos casos del número de nodos generados. Por ello calcularemos el coste del programa con relación a ese número, del que inicialmente sólo conocemos su valor máximo. Llamando u al número total de nodos evaluados, m al número de nodos en cada momento en el montículo y a al de los nodos en el árbol, podemos calcular si suponemos siempre tres hijos generados: u T(u)= Σ (1 + log m + k [3 (k 2 + log a)+1]+ 3 log m + log a)+ 1 i=1 Entre corchetes se presenta la llamada a la función expandir (máximo de tres hijos) u T(n)= 7 + Σ (4 log m + k log a) i=1 Intentando una aproximación mejor, tratemos de relacionar m y a con u. Las inserciones y comprobaciones en el árbol a, de orden logarítmico, se hacen tras evaluar cada nodo, por lo que podemos afirmar que a valdrá en cada iteración i-1. Realizando los cálculos tenemos que la serie de los log a vale: log 0 + log log (u-1). Dado que la primera inserción es sobre un árbol vacío, por lo tanto de coste constante, podemos sustituir ese log 0 por k. Por tanto, k + log log (u-1); por las propiedades de los logaritmos, k + log (1 * 2 *... * (u-1))=k + log ((u-1)!) Para el cálculo de las operaicones sobre m, de coste también logarítmico, debemos tener en cuenta que este valor irá modificándose a lo largo de las pasadas por el bucle while, insertando entre 0 y 3 nodos y extrayendo uno por cada iteración. En cada momento m valdrá u-a = u-(i-1). Sustituyendo tenemos log u + log (u-1) log 1 = log (u!). Por ello T(n)= log (u!) + k 3 u + 4 (k 4 + log ((u-1)!)). Aplicando la regla del máximo, T(u) es de O(u), siendo u el número de nodos generados, tomando como valor máximo u = n 2!/2. 6

9 2.- EJEMPLO DE EJECUCIÓN PARA EL CASO DE PRUEBA. Se presenta a continuación la salida en modo traza del ejemplo de prueba, modificada para presentar datos cada nodo evaluado en lugar de cada 2000, como en una ejecución estándar. También se comenta para ilustrar el trabajo en el montículo de nodos sin visitar. Archivo: prueba.txt Traza activada. Solucionable. N= 3. Cota= 36. Analizados: 1. Coste: 4. Podados: 0. Sin analizar: 0 Analizado: Padre Montículo:{ Analizados: 2. Coste: 4. Podados: 0. Sin analizar: 3 Analizado: A Montículo:{D, B, C Analizados: 3. Coste: 4. Podados: 0. Sin analizar: 4 Analizado: AA Montículo:{AB, D, C, B Analizados: 4. Coste: 4. Podados: 0. Sin analizar: 4 Analizado: AAA Montículo:{D, AB, C, B Analizados: 5. Coste: 4. Podados: 0. Sin analizar: 5 Analizado:AAAA Mont:{AAAB,D,C,B,AB Primera solución encontrada, 4 movimientos. Cota= 4. Analizados: 6. Coste: 6. Podados: 0. Sin analizar: 4 Analizado: AAAB Montículo: {AB, D, C, B Analizados: 7. Coste: 6. Podados: 1. Sin analizar: 3 Analizado: AB Montículo: {B, D, C Analizados: 8. Coste: 6. Podados: 2. Sin analizar: 2 Analizado: B Montículo: {C, D Analizados: 9. Coste: 6. Podados: 3. Sin analizar: 1 Analizado: C Montículo: { D Analizados: 10. Coste: 6. Podados: 4. Sin analizar: 0 Analizado: D Montículo: { Mejor solucion encontrada: 4 movimientos. Tiempo: 0 seg. 0 mils. Tableros generados: 9. Tableros analizados: 10. Tableros podados: Nodo padre. Genera cuatro hijos A,B,C,D de coste 4,6,6 y 6, respectivamente. 4 * 3 Tras insertarlos, el montículo es: {A 4,B 6,C 6,D * 2 Tras extraer A, el montículo queda: {D 6,B 6,C A genera dos hijos AA, AB con coste 4 y 6, respectivamente Tras insertarlos, el montículo es: {AA 4,D 6,C 6,B 6,AB * Tras extraer AA, el montículo queda: {AB 6,D 6,C 6,B AA genera un hijo AAA de coste Tras insertarlo, el montículo es: {AAA 4,AB 6,C 6,B 6,D Tras extraer AAA, el montículo queda así: {D 6,AB 6,C 6,B * AAA genera dos hijos AAAA y AAAB, de coste 4 y 6, respectivamente Tras insertarlos, el montículo queda así: {AAAA 4,D 6,C 6,B 6,AB 6,AAAB Tras extraer AAAA, el montículo queda así: {AAAB 6,D 6,C 6,B 6,AB Se encuentra AAAA como solución, la cota pasa a ser * Al ir extrayendo los nodos restantes del montículo, no se expanden y se podan por ser su coste > 4. 7

10 3.- ESTUDIO DEL COSTE DEL ALGORITMO. Atendiendo exclusivamente al algoritmo principal, tomando como operaciones elementales las relacionadas con las estructuras de datos, tenemos : n T(n)= Σ ( [3 (1 + 1)+1]+ 3 * 1+ 1)+ 1 i=1 Es decir, coste lineal, siendo n el número de nodos desarrollados por el algoritmo. 4.- LISTADO DEL CÓDIGO FUENTE COMPLETO Clase puzzle // Clase principal public class puzzle { // parámetros de entrada public static boolean t=false,a=false,h=false,fichero=false; public static Nodo inicio=new Nodo(); //Puzzle inicial public static String nombrearchivo=""; //almacena el nombre del archivo public static void main(string[] args) { //comprobación de los argumentos pasados int parametros=args.length; //nº de parámetros if (( parametros>4)) { //si hay 0 ó más de 4 parámetros Traduce.ayuda(); //presentamos la ayuda (con la sintaxis) System.exit( 2 ) ; //Fallo 2=argumentos mal //if parametros for (int c=0;c<parametros;c++){ //leemos los parámetros if (args[c].equalsignorecase("-h")) h=true; else if (args[c].equalsignorecase("-a")) a=true; else if (args[c].equalsignorecase("-t")) t=true; else { //suponemos que si no es h,a,t es el archivo fichero=true;nombrearchivo=args[c]; //if else //for c if (h) Traduce.ayuda(); //si se pasó h, presentamos la ayuda if (!fichero){ //si no se pasa un archivo de entrada inicio=traduce.pasaatiponodo(); //leemos la entrada estándar //si se proporciona el archivo inicio=traduce.pasaatiponodo(nombrearchivo); //lo leemos 8

11 //if else if (t){ //if t //si se pasó t, comprobamos la matriz de entrada if(!inicio.compruebamatriz(t)){ //si no es correcta System.out.println ( "Matriz de entrada incorrecta."); System.exit(1); else if (parametros==1){ //si sólo se pasa t System.out.println ( "Matriz de entrada correcta."); System.exit(0); //if!inicio // si se pasa a, activamos traza y lo ponemos en pantalla if (fichero && a) System.out.println("Archivo: " + nombrearchivo); if (a) System.out.println ( "Traza activada."); Resuelve.puzzle(inicio, a); //resolvemos el puzzle //fin main //fin clase puzzle Clase Resuelve //clase que contiene los algoritmos Ramificación y poda y expandir, //los contadores y la presentación de resultados import java.util.*; public class Resuelve { static long v1,v2; static int numanalizados=0,numgenerados=0,numpodados=0; static int maxcota,cota; public static void puzzle (Nodo entrada, boolean traza) { //candidato es un clon de entrada, para no modificar el puzzle original Nodo candidato=new Nodo(); candidato= entrada; candidato.actualizapuzzle(); boolean tienesol=candidato.tienesolucion(); if ((traza)&&(tienesol)) System.out.println("Solucionable."); else if (traza) System.out.println("No solucionable."); v1=system.currenttimemillis(); //tomamos tiempo al inicio //llamamos a Ramificación y Poda Nodo resultado=ryp(candidato,traza); 9

12 v2=system.currenttimemillis(); int segundos=(int)(v2-v1)/1000; int mils=(int)(v2-v1)%1000; //tomamos el tiempo final if ((resultado==null) (!resultado.essolucion())){ //si RyP devuelve un puzzle no resuelto entrada.presentapuzzle(); System.out.println("\nNo se ha encontrado solucion."); if (traza){ //comentarios si traza=true System.out.println("Tiempo: " + segundos + " seg. " + mils + " mils."); System.out.println("Tableros analizados: " + numanalizados + ".\ntableros podados: " + numpodados + "."); //if traza System.exit(0); //salimos del programa //si está resuelto presentamos la solución if (traza){ //comentarios si traza=true System.out.println(); System.out.println("Mejor solucion encontrada: " + resultado.devuelvemovimientos()+ " movimientos."); System.out.println("Tiempo: " + segundos + " seg. " + mils + " mils."); System.out.println("Tableros generados: " + numgenerados + ".\ntableros analizados: " + numanalizados + ".\ntableros podados: " + numpodados + "."); //if traza presentasolucion(candidato,resultado.devuelvecamino()); //if candidato //fin de puzzle // algoritmo Ramificación y Poda public static Nodo RyP(Nodo candidato, boolean traza){ Arbol vistos=new Arbol(); //árbol de búsqueda para los nodos ya vistos PriorityQueue <Nodo> monticulo=new PriorityQueue <Nodo>(); //montículo para los nodos aún sin analizar ArrayList <Nodo> hijos=new ArrayList<Nodo>(); //almacena los hijos Nodo n,solucion=candidato; monticulo.offer(candidato); //añadimos candidato al montículo switch (Nodo.devuelveNumFilas()){ //ajusta la cota según n al case 1: //número máximo de movimientos cota=maxcota=1;break; //según el número de casillas case 2: //más un margen de trabajo cota=maxcota=6+5;break; 10

13 case 3: cota=maxcota=31+5;break; case 4: cota=maxcota=80+5;break; default: cota=maxcota=1000;break; //switch if (traza){ System.out.println("N= " + Nodo.devuelveNumFilas() + ". Cota= " + cota + "."); //if traza while (!monticulo.isempty()){ //mientras haya nodos sin analizar n=monticulo.poll(); numanalizados++; if ((traza)&&(numanalizados%2000==0)){ //comentarios si traza=true System.out.println("Analizados: " + numanalizados + ". Coste: " + n.devuelvecoste()+ ". Podados: " + numpodados + ". Sin analizar: " + monticulo.size()); //if traza if (n.essolucion()){ //si n es solución solucion=n; cota=solucion.devuelvemovimientos(); //ajustamos la cota al número de movimientos de la solución //para la poda posterior if (traza){ //comentarios si traza=true System.out.println("Primera solucion encontrada, " + n.devuelvemovimientos() + " movimientos. Cota= " + cota + "."); //if traza else if (n.esaceptable(cota)){ //si n es aceptable hijos=expandir(n,vistos); //expandimos el árbol //hijos= el array de hijos de n que devuelve 'expandir' while (!hijos.isempty()){ //insertamos en el montículo, ordenados según el coste try { monticulo.offer(hijos.remove(0)); catch (OutOfMemoryError e) { System.out.println("Error al insertar un nodo.2 +"Falta memoria."); System.exit(2); //try catch //while numpodados++; //poda si no es aceptable n 11

14 //(ocurre tras el ajuste de la cota con la primera solución) //if n.essolucion try { //se añade n al árbol de nodos ya vistos ordenados según los datos vistos.insertarpordatos(n); catch (OutOfMemoryError e) { System.out.println("Error al insertar un nodo. " + "Falta memoria."); System.exit(2); //try catch //RyP //while return solucion; //Devuelve la mejor solución encontrada hasta llegar al límite. //Dará error "Solución no encontrada" si devuelve el nodo inicial. // desarrolla los hijos factibles del nodo padre, y los inserta en // la lista de posibles soluciones si no han sido ya comprobados // (mediante el árblo vistos) y si son viables (mediante esaceptable se // comprueba que su coste estimado no sobrepasa la cota) // devuelve la lista de hijos generados para introducir en 'nuevos' public static ArrayList <Nodo> expandir(nodo padre,arbol vistos){ ArrayList <Nodo> lista=new ArrayList <Nodo>(); //Array para devolver los hijos generados char ultimomov; String historia = padre.devuelvecamino(); int tamaño=historia.length(); if (tamaño!=0){ //localiza el último movimiento hecho ultimomov=historia.charat(tamaño-1); ultimomov='j'; //si es el tablero inicial boolean[] movposibles=padre.devuelvemovposibles(); if ((movposibles[0]) && (ultimomov!='s')){ //mov N Nodo hijo=(nodo) padre.clone(); hijo.mueven(); if ((!vistos.buscar(hijo))&&(hijo.esaceptable(cota))){ lista.add(hijo); numgenerados++; numgenerados++; numpodados++; //mov N if ((movposibles[1])&& (ultimomov!='n')){ //mov S 12

15 Nodo hijo=(nodo) padre.clone(); hijo.mueves(); if ((!vistos.buscar(hijo))&&(hijo.esaceptable(cota))){ lista.add(hijo); numgenerados++; numgenerados++; numpodados++; //mov S if ((movposibles[2])&& (ultimomov!='o')){ //mov E Nodo hijo=(nodo) padre.clone(); hijo.muevee(); if ((!vistos.buscar(hijo))&&(hijo.esaceptable(cota))){ lista.add(hijo); numgenerados++; else{ numgenerados++; numpodados++; //mov E if ((movposibles[3])&& (ultimomov!='e')){ //mov O Nodo hijo=(nodo) padre.clone(); hijo.mueveo(); if ((!vistos.buscar(hijo))&&(hijo.esaceptable(cota))){ lista.add(hijo); numgenerados++; numgenerados++; numpodados++; //mov O return lista; //expandir // presenta la solución desde el tablero inicial, mediante el movimiento // del hueco según el camino almacenado public static void presentasolucion(nodo inicio, String camino){ inicio.presentapuzzle(); //presenta el nodo inicial int tope=camino.length(); //nº de movimientos int contador=0; while (contador<tope){ char movimiento=camino.charat(contador); switch (movimiento){ //mueve y presenta según el movimiento leído case 'N': inicio.mueven();inicio.presentapuzzle();break; case 'S': inicio.mueves();inicio.presentapuzzle();break; case 'E': inicio.muevee();inicio.presentapuzzle();break; case 'O': 13

16 inicio.mueveo();inicio.presentapuzzle();break; contador++; //while //presentasolucion //resuelve Clase Nodo. //clase que almacena los datos de los puzzles y los métodos para su manipulación public class Nodo implements Comparable, Cloneable { // constantes definidas a partir de la entrada (excepto minvalor) private static int numfilas; private static int numcolumnas; private static int numcasillas; private static int minvalor=1; //si se introduce un cero, error private static int topevalor; //rango de valores de 1 a n^2-1 private static int blanco; // atributos de instancia private String camino; private int colocadas; private int movimientos; private int coste; private int datos[]=new int[numcasillas]; private int poshueco; //almacena los movimientos del hueco //nº de fichas colocadas //nº de movimientos realizados //coste de cada nodo //array de int con las piezas //posición del hueco en el array private boolean movposibles[]=new boolean[4]; //array de booleanos con // los movimientos posibles del hueco en orden Norte, Sur, Este, Oeste. public Nodo izda, dcha; //para el árbol // constructor public Nodo(){ for (int a= 0;a<numCasillas;a++){ datos[a]=0; //for a movimientos=0; camino=""; //fin del constructor de Nodo //rellena de ceros las casillas // imprime en pantalla public void presentapuzzle(){ 14

17 String relleno; if (numcasillas<10){ relleno=""; relleno=" "; //if numfilas //define el caracter de relleno si hay //números >10 para presentar el puzzle for (int a=0;a<numcasillas;a++){ if (a%numfilas==0) System.out.println(); int numero=datos[a]; if (numero==blanco) { System.out.print(relleno + "* "); //sustituye n^2 por '*' if (numero<10){ System.out.print(relleno + numero + " " ); System.out.print(numero + " " ); //if numero<10 //if numero==blanco //for a System.out.println(); //línea en blanco por debajo del puzzle //fin de presentapuzzle // devuelve el número de casillas rellenas public int devuelvecolocadas(){ return colocadas; //fin de devuelvecolocadas // devuelve un String que almacena el camino según los movimientos del hueco public String devuelvecamino(){ return camino; //devuelvecamino // devuelve un array de booleanos con los movimientos posibles del hueco en // orden Norte, Sur, Este, Oeste. public boolean[] devuelvemovposibles(){ return movposibles; //devuelvemovposibles // dvuelve un entero con el número de movimientos realizados public int devuelvemovimientos(){ return movimientos; //devuelvemovimientos // devuelve un entero con el número de filas del puzzle 15

18 public static int devuelvenumfilas(){ return numfilas; //devuelvenumfilas // devuelve un entero con el número de columnas del puzzle public static int devuelvenumcolumnas(){ return numcolumnas; //devuelvenumcolumnas // devuelve un entero con el número total de casillas del puzzle public static int devuelvenumcasillas(){ return numcasillas; //devuelvenumcasillas // devuelve un entero el mínimo valor que puede tener una casilla. Es 1. // Se usa en la comprobación del archivo de entrada public static int devuelveminvalor(){ return minvalor; //devuelve minvalor // devuelve un entero con el máximo valor que puede tener una casilla. Es n^2-1 // Se usa en la comprobación del archivo de entrada public static int devuelvetopevalor(){ return topevalor; //devuelvetopevalor // devuelve el int coste public int devuelvecoste(){ return coste; //devuelvecoste // devuelve el array de enteros con las casillas public int[] devuelvedatos(){ return datos; //devuelvedatos // se cambia el número de filas public static void ponernumfilas(int filas){ numfilas=filas; //ponernumfilas // se cambia el número de columnas public static void ponernumcolumnas(int columnas){ numcolumnas=columnas; //ponernumcolumnas // se cambia el número de casillas public static void ponernumcasillas(int casillas){ 16

19 numcasillas=casillas; //ponernumcasillas // se cambia el valor máximo de casilla public static void ponertopevalor(int valor){ topevalor=valor; //ponertopevalor // se cambia el valor del blanco. Es n^2 public static void ponerblanco(int valor){ blanco=valor; //ponerblanco // calcula el coste del nodo. Los movimientos realizados hasta el momento mas // la suma de las distancias Manhattan de las casillas (devuelta // por calculadistancias) public void actualizacoste(){ coste=movimientos+calculadistancias(); //actualizacoste // devuelve true si el coste del nodo es inferior a la cota public boolean esaceptable(int cota){ if (this.coste>=cota) return false; else return true; //esaceptable // compara los valores de las casillas del nodo con el array de enteros 'datos' // devuelve 1 si 'datos' es mayor casilla a casilla que el nodo; -1 si es menor // y 0 si es igual. Se usa para la construcción y búsqueda en el árbol binario. public int compara(int[] datos){ for (int i=0;i<numcasillas;i++){ if (this.datos[i]<datos[i]) return 1; else if (this.datos[i]>datos[i]) return -1; return 0; //compara //inserta una ficha en una casilla public void inserta(int posit, int dato){ datos[posit]=dato; //fin inserta // actualiza los datos de cada tablero, se usa tras mover el hueco public void actualizapuzzle(){ sumacolocadas(); //cuenta las casillas en posición correcta actualizacoste(); //recalcula el coste poshueco=devuelveposhueco(); //actualiza el array de booleanos movposibles 17

20 if (poshueco/numfilas>0) {movposibles[0]=true; //norte else movposibles[0]=false; if (poshueco/numfilas<numfilas-1) {movposibles[1]=true;//sur else movposibles[1]=false; if (poshueco%numcolumnas<numcolumnas-1) {movposibles[2]=true;//este else movposibles[2]=false; if ((poshueco%numcolumnas>0) ){movposibles[3]=true;//oeste else movposibles[3]=false; //actualizapuzzle // devuelve la posición del hueco public int devuelveposhueco(){ for (int a=0;a<numcasillas;a++){ int valor=datos[a]; if (valor==blanco){ return a; //if valor //for a return blanco; //devuelveposhueco //índices de fila //si lo encontramos, devuelve la fila // calcula y devuelve las distancias Manhattan de cada ficha. Para el cálculo // del coste public int calculadistancias(){ int distancia=0,distanciaa,distanciab,dato; for (int pos=0;pos<numcasillas;pos++){ dato=this.datos[pos]; if ((dato!=blanco)&&(dato!=pos+1)){ //se compara con pos+1 al ir el array de 0 a n^2 distanciaa=(((pos/numfilas))-((dato-1)/numfilas)); distanciab=(pos%numfilas)-((dato-1)%numfilas); distancia=distancia+math.abs(distanciaa)+math.abs(distanciab); //if dato //for return distancia; //calculadistancias // calcula y devuelve las inversiones en cada tablero. public int calculainversiones(){ int inversiones=0,dato,datob; for (int pos=0;pos<numcasillas;pos++){ dato=this.datos[pos]; if (dato!=blanco) { for (int y=pos+1;y<numcasillas;y++){ datob=this.datos[y]; if ((datob!=blanco)&&(datob<dato))inversiones++; //for 18

21 //if dato //for if (numfilas%2==0){ int filahueco=(this.devuelveposhueco()/numfilas)+1; return inversiones+filahueco; else return inversiones; //calculainversiones // Devuelve true si el tablero tiene solución posible public boolean tienesolucion(){ return this.calculainversiones()%2==0; // movimientos del hueco public void mueven(){ if (movposibles[0]){ inserta(poshueco,datos[poshueco-numfilas]); inserta(poshueco-numfilas,blanco); //intercambio de posiciones poshueco=poshueco-numfilas; //actualiza poshueco movimientos++; //incrementa movimientos camino=camino+"n"; //actualiza el camino actualizapuzzle(); //actualiza los datos del tablero System.out.println("Error: movimiento al N fuera de tablero." + "No se realiza."); //si no se puede realizar el movimiento //if //fin mueven public void mueves(){ if (movposibles[1]){ inserta(poshueco,datos[poshueco+numfilas]); inserta(poshueco+numfilas,blanco); poshueco=poshueco+numfilas; movimientos++; camino=camino+"s"; actualizapuzzle(); System.out.println("Error: movimiento al S fuera de tablero. " + "No se realiza."); //if //fin mueves public void muevee(){ if (movposibles[2]){ inserta(poshueco,datos[poshueco+1]); inserta(poshueco+1,blanco); poshueco++; movimientos++; 19

22 camino=camino+"e"; actualizapuzzle(); System.out.println("Error: movimiento al E fuera de tablero." + "No se realiza."); //if //fin muevee public void mueveo(){ if (movposibles[3]){ inserta(poshueco,datos[poshueco-1]); inserta(poshueco-1,blanco); poshueco--; movimientos++; camino=camino+"o"; actualizapuzzle(); System.out.println("Error: movimiento al O fuera de tablero." + "No se realiza."); //if //fin mueveo // devuelve true si el nodo es solucion, si todas sus casillas están colocadas public boolean essolucion(){ if (this.colocadas==numcasillas){ return true; else return false; //essolucion // devuelve 'true' si no hay valores repetidos y están definidas todas las // casillas. Devuelve 'False' si hay error. // Se le pasa como parámetro el booleano 't', que indica si se está // en modo traza; si es así, se presenta el mensaje // de error (si lo hubiera) public boolean compruebamatriz(boolean t){ //comprueba si todos los números están presentes for (int a=0;a<numcasillas;a++){ //índices de fila int valor=datos[a]; if (valor==0){ if (t) System.out.println("Falta un numero de ficha."); return false; //if valor //for a //comprueba si hay números repetidos o si falta alguno for (int num=1;num<topevalor+1;num++){ boolean presente=false; for (int a=0;a<numcasillas;a++){ //índices de fila 20

23 int valor=datos[a]; if ((presente)&&(valor==num)){ //si num ya está presente if (t) { //información extra si traza activada System.out.println("El "+ num + " repetido."); presentapuzzle(); // if t return false; //matriz errónea else if (valor==num){ presente=true; //if presente //for a if (!presente){ //si no se ha encontrada el número if (t) { System.out.print("El "+ num + " sin colocar."); presentapuzzle(); //if t return false; //matriz errónea //for num return true; //matriz correcta //fin compruebamatriz // Repasa toda la tabla y cuenta las fichas colocadas public void sumacolocadas(){ int suma=0; for (int a=0;a<numcasillas;a++){ if (datos[a]==a+1) suma++; //for a colocadas=suma; //fin sumacolocadas // implementación de compareto public int compareto (Object nodo){ //ordena inicialmente por el coste int costeactual = this.devuelvecoste(); int costenuevo = ((Nodo)nodo).devuelveCoste(); int valor = costeactual > costenuevo? 1 : costeactual==costenuevo? 0 : -1; //a igualdad de coste, favorece al de menos movimientos hechos if (valor==0){ int movactual=this.devuelvemovimientos(); int movnuevo=((nodo)nodo).devuelvemovimientos(); 21

24 return movactual > movnuevo? -1 : movactual==movnuevo? 0 : 1; return valor; //compareto // sobreescritura de Object.clone para evitar variar los datos al manipular la // copia de un puzzle public Object clone() { Nodo temp; try { //para capturar posibles fallos de memoria al clonar temp = new Nodo(); for (int a=0;a<numcasillas;a++){ int dato=this.datos[a]; //insertamos los datos uno a uno temp.inserta(a,dato); //for a temp.actualizapuzzle(); temp.camino=this.camino; temp.movimientos=this.movimientos; return temp; catch (OutOfMemoryError e) { System.out.println("Error al crear un nodo. Falta memoria."); System.exit(2); return null; //trycatch //fin clone //fin clase Nodo Clase Arbol // Clase que implementa un árbol binario de búsqueda y los métodos //necesarios para su manejo public class Arbol { public Nodo raiz; public int numnodos; // Constructor public Arbol(){ raiz=null; numnodos=0; //Arbol() // devuelve true si se encuentra el nodo pedido 22

25 public boolean buscar(nodo nodo){ boolean encontrado=false; Nodo actual=raiz; //comenzamos por la raiz int []datosnodo=nodo.devuelvedatos(); while ((!encontrado)&&(actual!=null)){ //mientras queden nodos por ver int comp=actual.compara(datosnodo); if (comp>0){ //si el nuevo es mayor que actual, busca dcha actual=actual.dcha; else if (comp<0){ //si el nuevo es menor que actual, busca izda actual=actual.izda; else encontrado=true; //si es igual, encontrado //while return encontrado; //buscar // inserta ordenando por los datos del nodo (usado para el árbol de nodos // ya evaluados) public boolean insertarpordatos(nodo nodo){ boolean insertado=false; Nodo actual=raiz; //comenzamos en la raíz if (actual==null){ //si el árbol está vacío, insertamos como raíz raiz=nodo;return true; int []datosnodo=nodo.devuelvedatos(); while ((!insertado)&&(actual!=null)){ //mientras queden nodos por ver int comp=actual.compara(datosnodo); if (comp>0){ //si el nodo actual es menor if (actual.dcha!=null){ //si tiene hijo dcho,sigue búsqueda dcha actual=actual.dcha; actual.dcha=nodo; //si no tiene hijo dcho,inserta dcha insertado=true;break; //if actual.dcha else if (comp<0){ //si actual es menor if (actual.izda!=null){ //si tiene hjo izdo, busca izda actual=actual.izda; actual.izda=nodo; //si no, inserta izda insertado=true;break; //if actual.dcha else { //si el nodo es igual no se inserta break; //if comp //while if (insertado) numnodos++; 23

26 return insertado; //insertar por datos // devuelve true si el árbol está vacío public boolean esvacio(){ return (raiz==null); //esvacio // devuelve el número de nodos del árbol public int devuelvenumnodos(){ return numnodos; //devuelvenumnodos //clase Arbol Clase Traduce //Contiene los métodos para extraer los datos del archivo inicial (o pipeline) //y los introduce en la matriz de datos si están dentro de límites. import java.io.*; import java.util.vector; public class Traduce { // Si en la entrada se pasa un parámetro con el nombre del archivo public static Nodo pasaatiponodo(string nombrearchivo){ Nodo prueba=new Nodo(); try { //abrimos el archivo FileReader entrada = new FileReader(nombreArchivo) ; BufferedReader datosentrada=new BufferedReader((entrada)); prueba=traduce(datosentrada); entrada.close(); // cerramos el archivo catch ( IOException io ) { // si hay error al abrir el archivo System.out.println( "Error E/S. El archivo '" + nombrearchivo + "' no es valido o no esta en el directorio del programa." ) ; System.exit( 3 ) ; // Fallo 3= error en archivo de entrada return prueba; //devolvemos un Nodo con los valores de la entrada 24

27 // Si es a través de entrada estándar o pipeline no se le pasan argumentos. public static Nodo pasaatiponodo(){ BufferedReader datos=new BufferedReader (new InputStreamReader (System.in)); // abrimos el lector de entrada estándar try{ if (System.in.available()==0){ //si la entrada estandar esta vacía System.out.println("Entrada estandar o por 'pipe' vacia."); System.exit( 3 ) ; //Fallo 3= error en archivo de entrada catch ( IOException io ) { //si hay error en la entrada estandar System.out.println("Fallo en la entrada estandar o pipe."); System.exit( 3 ) ; //Fallo 3= error en archivo de entrada return traduce(datos); //devolvemos un TipoSudoku con los valores de la entrada // Dimensiona el array de datos con respecto al número de filas de la entrada // y fija las variables de Nodo referidas a n. Devuelve un vector public static Vector<String> dimensiona(bufferedreader datosentrada){ Vector <String> entrada = new Vector <String>(); int tamanoentrada=0; try{ String fila=datosentrada.readline(); while ( fila!= null ) { //añadimos al vector todas las líneas no vacías if ((fila.length()!=0)&&(fila.charat(0)!='#')){ entrada.addelement(fila); //y leemos la siguiente línea fila = datosentrada.readline(); //while //Definimos el tamaño del puzzle con las primera línea de la entrada for (int a=0;a<entrada.size();a++){ String linea = (String)entrada.elementAt(a); //linea es un string con la fila while ((linea.length()!=0)&&(linea.charat(0)==' ')){ linea=linea.replacefirst(" ", ""); //elimina los espacios iniciales //while 25

28 if (linea.length()==0){ errorentrada("una línea sólo contiene espacios."); String [] numero=linea.split("\\s+"); //dividimos la linea tamanoentrada=numero.length; // for a if (tamanoentrada<1) errorentrada("no hay líneas válidas."); Nodo.ponerNumFilas(tamanoEntrada); Nodo.ponerNumColumnas(tamanoEntrada); Nodo.ponerNumCasillas(tamanoEntrada*tamanoEntrada); Nodo.ponerTopeValor((tamanoEntrada*tamanoEntrada)-1); Nodo.ponerBlanco(tamanoEntrada*tamanoEntrada); if (tamanoentrada==1) { //caso especial de tamaño 1 Nodo.ponerTopeValor(1); Nodo.ponerBlanco(0); catch ( IOException io ) { //si hay error al abrir la entrada System.out.println( "Error al procesar los datos de entrada." ) ; System.exit( 2 ) ; //Fallo 2= error en entrada //try catch return entrada; //fin dimensiona // si la matriz de entrada es correcta (número de filas y columnas iguales, // los dígitos son de 1 a n^2-1 o asteriscos y las líneas que empiezan // por '#' son comentarios) devuelve una matriz de int Nodo. public static Nodo traduce(bufferedreader datosentrada){ Vector <String> entrada; entrada=dimensiona(datosentrada); //fija los límites Nodo prueba=new Nodo(); boolean yahayblanco=false; int filasentrada=entrada.size(); for (int a=0;a<filasentrada ;a++){ String linea = (String)entrada.elementAt(a); //linea es un string con la fila while ((linea.length()!=0)&&(linea.charat(0)==' ')){ linea=linea.replacefirst(" ", "");//elimina los espacios iniciales //while if (linea.length()==0){ errorentrada("una línea sólo contiene espacios."); 26

29 String [] numero=linea.split("\\s+"); //dividimos la linea if (numero.length!=nodo.devuelvenumcolumnas()) { errorentrada("incorrecto numero de datos en la fila " + (a+1) + ":\ndeberia haber " + Nodo.devuelveNumColumnas() + "."); //if for (int bb=0;bb<numero.length;bb++){ if (numero[bb].equals("*")){ if (!yahayblanco){ prueba.inserta((a*nodo.devuelvenumfilas())+ bb,nodo.devuelvetopevalor() +1); yahayblanco=true; errorentrada("mas de un blanco en el puzzle."); //if yahayblanco else { //si no es asterisco try{ int proximo=integer.parseint(numero[bb]); if ((proximo>=nodo.devuelveminvalor())&& (proximo<nodo.devuelvetopevalor()+1)){ prueba.inserta((a*nodo.devuelvenumf ilas())+bb,proximo); //fuera de rango errorentrada("valor fuera de rango: " + proximo + ". Debe estar entre " + Nodo.devuelveMinValor() + " y " + Nodo.devuelveTopeValor()+"." ); catch(exception e){ //si fallo en conversion a int errorentrada("valor extraño en la " + "entrada: '" + numero[bb] + "'"); //try catch //if numero //for bb //for a return prueba; //fin traduce //sale del programa con el mensaje recibido en el String 'error' public static void errorentrada(string error){ System.out.println("Matriz de entrada incorrecta:\n" + error); System.exit(1); //Fallo 1= matriz de entrada incompleta o incorrecta //fin errorentrada 27

30 // Muestra los créditos y la sintaxis. Se han evitado los acentos para evitar // conflictos entre la codificación UNICODE del java y el ASCII de la consola public static void ayuda(){ System.out.println("Puzzle."); System.out.println("DIEGO J. SANCHEZ CAAMAÑO. DNI J"); System.out.println("Centro Asociado de Albacete."); System.out.println(); System.out.println("Formato de la linea de parametros: " + "java puzzle [-t] [-a] [-h] [fichero]"); System.out.println(); System.out.println("-t: Realiza un test de correccion al puzzle de " + "entrada."); System.out.println(" Si es incompleto o incorrecto, devuelve 1." + "\n En caso contrario, devuelve 0."); System.out.println(); System.out.println("-a: Modo traza. "); System.out.println(" Muestra toda la secuencia de tableros que se "+ "van generando\n hasta alcanzar la solucion con menor " + "numero de movimientos."); System.out.println(); System.out.println("-h: Modo ayuda. Muestra sintaxis y creditos."); System.out.println(); System.out.println("fichero: archivo con la matriz de entrada."); System.out.println(); //fin ayuda //fin clase Traduce 28