ALGORITMO 8 REINAS
~1~
METODOLOGIA
ALGORITMO 8 REINAS Sabiendo el movimiento de la pieza de la reina en un tablero de ajedrez encontrar las posiciones de 8 reinas en el mismo tablero para que ninguna pueda comer a las otras 7 y por tanto tampoco ser comida. (Investigando un poco encuentro que para este problema clásico hay 92 soluciones)
Primera valoración del ejercicio No se No
puede repetir fila ni columna
se puede repetir diagonal
En cada En
fila solo 1 reina
cada columna sólo 1 reina
Marcar
filas y columnas ocupadas
El algoritmo se podría definir con dos líneas como. Probar a colocar la reina de la fila i-ésima en cada una de las posiciones disponibles. Colocar las reinas restantes operando de modo recursivo.
ALGORITMO 8 REINAS
Estado
METODOLOGIA
Inicial
Las reinas que hay Estado
f inal
Las posiciones que quedan libres Procesamiento
Colocar ficha en lugar permitido y no ocupado
ENT Columnas ocupadas por vacías anteriores SALIDA Columnas disponibles Creación
del pseudocódigo
Disponibles(ocup). //recibe un vector o una lista con d=[0,1,2,3,4,5,6,7] k= tamaño(ocup) Para cada c en ocup: Eliminar c de d Eliminar (c+k) de d Eliminar (c-k) de d K-devolver d caso concreto ocup=[3 5 0 4] k=4 3 2 1 d=[0 1 2 3 4 5 6 7]
~2~
ALGORITMO 8 REINAS Date:
METODOLOGIA
~3~
2010-07-29 IMPLEMENTACIÓN ALGORITMO 8 REINAS EN JAVA
Implementamos el método disponibles y comprobamos si f unciona para un caso concreto. import java.util.Iterator; import java.util.LinkedList; import java.util.List; /** * @author nessy* */ public class OchoReinas { //PSEUDOCODIGO // Disponibles(ocup). //recibe un vector o una lista con // d=[0,1,2,3,4,5,6,7] // k= tamaño(ocup) // Para cada c en ocup: // Eliminar c de d // Eliminar (c+k) de d // Eliminar (c -k) de d // K - // devolver d /**Este método sirve para determinar las columnas en las que * se puede colocar la siguiente reina, habiéndose puesto ya algunas * reinas cuyas columnas se dan * @param ocup Columnas que oc upan las reinas previas * @return Columnas disponibles sin comerse */ public static List disponibles(Listocup){ //creamos la lista de disponibles que inicialmente tiene todas las columnas // d=[0,1,2,3,4,5,6,7] List d= new LinkedList(); //podría haber utilizado un ArrayList for(int i=0;i<8;i++){ d.add(new Integer(i)); } //averiguamos cuántas reinas hay ya colocadas y lo guardamos en la variable k // k= tamaño(ocup) int k=ocup.size(); /*recorremos la lista de columnas ocupadas para ir tachando los lugares que * no nos vale. Podriamos hacerlo con un for, pero para listas mejor el Iterator*/ //Para cada c en ocup: // Eliminar c de d // Eliminar (c+k) de d // Eliminar (c -k) de d // K - for (Iterator j=ocup.iterator();j.hasNext();k --){ Integer c=j.next(); //trabajamos con objetos que contienen números enteros por eso uso el remove d.remove(c); d.remove( new Integer(c.intValue()+k)); d.remove( new Integer(c.intValue() -k)); } //finalmente devolvemos lo que nos queda //devolver d return d; }
ALGORITMO 8 REINAS
METODOLOGIA
~4~
public static void main(String[] args) { /* Creo un ejemplo para ver si la funcion disponibles funciona bien*/ /* Creamos la lista de prueba*/ LinkedList a = new LinkedList(); a.add(new Integer(3)); a.add(new Integer(5)); /* Creo otra lista para guardar lo que devuelve el método disponibles*/ List z = disponibles (a); for (Iterator j=z.iterator();j.hasNext();){ System. out.println(j.next().intValue()); } } }
ALGORITMO RESOLVER MEJORA . Pseudocódigo del método resolver que nos va a mostrar las 92 soluciones posibles de colocar las 8 reinas. resolver(ocup): si tamaño(ocup)<8: ddisponibles(ocup) para cada c en d: resolver(ocup+c) en caso contrario: mostrar solución import java.util.Iterator; import java.util.LinkedList; import java.util.List; /** * @author nessy* */ public class OchoReinas { static int cont=0;//para contar el número de soluciones del método resolver //PSEUDOCODIGO // Disponibles(ocup). //recibe un vector o una lista con // d=[0,1,2,3,4,5,6,7] // k= tamaño(ocup) // Para cada c en ocup: // Eliminar c de d // Eliminar (c+k) de d // Eliminar (c -k) de d // K - // devolver d /**Este método sirve para determinar las columnas en las que * se puede colocar la siguiente reina, habiéndose puesto ya algunas * reinas cuyas columnas se dan * @param ocup Columnas que ocupan las reinas previas * @return Columnas disponibles sin comerse */ public static List disponibles(Listocup){ //creamos la lista de disponibles que inicialmente tiene todas las columnas // d=[0,1,2,3,4,5,6,7] List d= new LinkedList(); //podría haber utilizado un ArrayList for(int i=0;i<8;i++){ d.add(new Integer(i)); } //averiguamos cuántas reinas hay ya colocadas y lo guardamos en la variable k
ALGORITMO 8 REINAS
METODOLOGIA
~5~
// k= tamaño(ocu p) int k=ocup.size(); /*recorremos la lista de columnas ocupadas para ir tachando los lugares que * no nos vale. Podriamos hacerlo con un for, pero para listas mejor el Iterator*/ //Para cada c en ocup: // Eliminar c de d // Eliminar (c+k) de d // Eliminar (c -k) de d // K - for (Iterator j=ocup.iterator();j.hasNext();k --){ Integer c=j.next(); //trabajamos con objetos que contienen números enteros por eso uso el remove d.remove(c); d.remove( new Integer(c.intValue()+k)); d.remove( new Integer(c.intValue() -k)); } //finalmente devolvemos lo que nos queda //devolver d return d; } // resolver(ocup): // si tamaño(ocup)<8: // d=disponibles(ocup) // para cada c en d: // resolver(ocup+c) // en caso contrario: // mostrar solución /** Encuentra todas las soluciones para el problema de las 8 reinas * @param ocup Lista con las ocupaciones previas, siendo su valor inicial una lista vacía * resolver(ocup): * si tamaño(ocup)<8: * d=disponibles(ocup) * para cada c en d: * resolver(ocup+c) * en caso contrario: * mostrar solución */ public static void resolver(List ocup){ // si tenemos ya 8 reinas ubicadas, es que encontramos una solución, si no, hay que iterar recursivamente if (ocup.size()<8){ // d=disponibles(ocup) List d = disponibles (ocup); // para cada c en d: for (Iterator c=d.iterator();c.hasNext();){ //resolver(ocup+c) Aquí tengo que crear una lista provisional List provisional = new LinkedList(ocup); provisional.add(c.next()); r esolver (provisional); } }else{ //mostramos la solución por pantalla como una linea String solucion= ""; for (Iterator j=ocup.iterator();j.hasNext();){ solucion += j.next().intValue(); } cont++;
ALGORITMO 8 REINAS
~6~
METODOLOGIA System. out.println( "Solucion " +
ont+" "+solucion + " ");
c
} } public static void main(String[] args) { //1 OPCION con el método disponibles /* Creo un ejemplo para ver si la funcion disponibles funciona bien*/ /* Creamos la lista de prueba*/ LinkedList a = new LinkedList(); a.add(new Integer(3)); a.add(new Integer(5)); /* Creo otra lista para guardar lo que devuelve el método disponibles*/ List z = disponibles (a); for (Iterator j=z.iterator();j.hasNext();){ System. out.println(j.next().intValue()); } // 2 OPCION con el algoritmo resolver LinkedList b = new LinkedList(); System. out.println( "La solucón con el método resolver es: " ); r esolver (b); } }
ALGORITMO 8 REINAS Date
METODOLOGIA
~7~
2010-07-30
MEJORA . Mostrar la salida del programa de f orma que muestre simbólicamente el tablero poniendo en los huecos un punto y donde hay una reina un asterisco. Para ello crearemos el método pintaTablero( ). El pseudocódigo sería. para i=0 hasta 7 fila= r= elemento i de reinas // en java seria int r=reinas.get(i).intValue(); para j=0 hasta 7 si (j = = r): fila +=* en caso contrario: fila +=. imprimir fila
El método pintaTablero tiene esta pinta: public static void pintaTablero(Listreinas){ for (int i=0;i<8;i++){ String fila= ""; int r=reinas.get(i).intValue(); for(int j=0;j<8;j++){ if (j == r){ fila += '*'; }else{ fila += '·'; } } System. out.println(fila); }
Para comprobar su f uncionamiento:
1ª Opción: Creo un ejemplo con una solución posible y luego se la envío al método pintaTablero para que la muestre Para ello en el main incluyo: //MEJORA. Visualizar el resultado en un tablero //Aqui creo "a mano" un caso concreto y luego lo pinto con //el método pintaTablero LinkedList p = new LinkedList(); p.add(new Integer(0)); p.add(new Integer(4)); p.add(new Integer(7)); p.add(new Integer(5)); p.add(new Integer(2)); p.add(new Integer(6)); p.add(new Integer(1)); p.add(new Integer(3)); pintaTabler o (p);
ALGORITMO 8 REINAS
METODOLOGIA
~8~
2ª opción. Que pinte el tablero justo después de obtener cada opción posible Para ello en el método Resolver hacemos una llamada al método pintarTablero, quedando el método: public static void resolver(List ocup){ // si tenemos ya 8 reinas ubicadas, es que encontramos una solución, si no, hay que iterar recursivamente if (ocup.size()<8){ // d=disponibles(ocup) List d = disponibles (ocup); // para cada c en d: for (Iterator c=d.iterator();c.hasNext();){ //resolver(ocup+c) Aquí tengo que crear una lista provisional List provisional = new LinkedList (ocup); provisional.add(c.next()); r esolver (provisional); } }else{ //mostramos la solución por pantalla como una linea String solucion= ""; for (Iterator j=ocup.iterator();j.hasNext();){ solucion += j.next().intValue(); } cont++; System. out.println( "Solucion " + cont+" "+solucion + " "); pintaTabler o (ocup); // con esta línea "pinta" todos los tableros posibles } }
Para mostrar solo la primera posibilidad posible que devuelve el método resolver
De momento esto queda pendiente
