ALGORITMO

8 REINAS METODOLOGIA ~1~

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
clsico hay 92 soluciones)

Primera valoracin del ejercicio

No se puede repetir fila ni columna

No se puede repetir diagonal

En cada fila solo 1 reina

En cada columna slo 1 reina

Marcar filas y columnas ocupadas

El algoritmo se podra definir con dos lneas 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 METODOLOGIA ~2~

Estado Inicial

Las reinas que hay

Estado final

Las posiciones que quedan libres

Procesamiento

Colocar ficha en lugar permitido y no ocupado

ENT Columnas ocupadas por vacas anteriores

SALIDA Columnas disponibles

Creacin del pseudocdigo

Disponibles(ocup). //recibe un vector o una lista con

d=[0,1,2,3,4,5,6,7]

k= tamao(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]
ALGORITMO
8 REINAS METODOLOGIA ~3~
Date: 2010-07-29

IMPLEMENTACIN ALGORITMO 8 REINAS EN JAVA

Implementamos el mtodo disponibles y comprobamos si funciona 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= tamao(ocup)
// Para cada c en ocup:
// Eliminar c de d
// Eliminar (c+k) de d
// Eliminar (c-k) de d
// K - -
// devolver d
/**Este mtodo sirve para determinar las columnas en las que
* se puede colocar la siguiente reina, habindose puesto ya algunas
* reinas cuyas columnas se dan
* @param ocup Columnas que ocupan las reinas previas
* @return Columnas disponibles sin comerse */
public static List<Integer> disponibles(List<Integer>ocup){
//creamos la lista de disponibles que inicialmente tiene todas las
columnas
// d=[0,1,2,3,4,5,6,7]
List<Integer> d= new LinkedList<Integer>();//podra haber utilizado un
ArrayList
for(int i=0;i<8;i++){
d.add(new Integer(i));
}
//averiguamos cuntas reinas hay ya colocadas y lo guardamos en la
variable k
// k= tamao(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<Integer> j=ocup.iterator();j.hasNext();k--){
Integer c=j.next();
//trabajamos con objetos que contienen nmeros 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~
}
ALGORITMO
8 REINAS METODOLOGIA ~5~
public static void main(String[] args) {
/* Creo un ejemplo para ver si la funcion disponibles funciona bien*/
/* Creamos la lista de prueba*/
LinkedList<Integer> a = new LinkedList<Integer>();
a.add(new Integer(3));
a.add(new Integer(5));
/* Creo otra lista para guardar lo que devuelve el mtodo disponibles*/
List<Integer> z = disponibles(a);
for (Iterator<Integer> j=z.iterator();j.hasNext();){
System.out.println(j.next().intValue());
}
}
}

ALGORITMO RESOLVER

MEJORA. Pseudocdigo del mtodo resolver que nos va a mostrar las 92 soluciones
posibles de colocar las 8 reinas.

resolver(ocup):
si tamao(ocup)<8:
ddisponibles(ocup)
para cada c en d:
resolver(ocup+c)
en caso contrario:
mostrar solucin
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
/** * @author nessy* */
public class OchoReinas {
static int cont=0;//para contar el nmero de soluciones del mtodo resolver
//PSEUDOCODIGO
// Disponibles(ocup). //recibe un vector o una lista con
// d=[0,1,2,3,4,5,6,7]
// k= tamao(ocup)
// Para cada c en ocup:
// Eliminar c de d
// Eliminar (c+k) de d
// Eliminar (c-k) de d
// K - -
// devolver d
/**Este mtodo sirve para determinar las columnas en las que
* se puede colocar la siguiente reina, habindose puesto ya algunas
* reinas cuyas columnas se dan
* @param ocup Columnas que ocupan las reinas previas
* @return Columnas disponibles sin comerse */
public static List<Integer> disponibles(List<Integer>ocup){
//creamos la lista de disponibles que inicialmente tiene todas las
columnas
// d=[0,1,2,3,4,5,6,7]
List<Integer> d= new LinkedList<Integer>();//podra haber utilizado un
ArrayList
for(int i=0;i<8;i++){
d.add(new Integer(i));
}
//averiguamos cuntas reinas hay ya colocadas y lo guardamos en la
variable k
// k= tamao(ocup)
ALGORITMO
8 REINAS METODOLOGIA ~6~
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<Integer> j=ocup.iterator();j.hasNext();k--){
Integer c=j.next();
//trabajamos con objetos que contienen nmeros 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 tamao(ocup)<8:
// d=disponibles(ocup)
// para cada c en d:
// resolver(ocup+c)
// en caso contrario:
// mostrar solucin
/** Encuentra todas las soluciones para el problema de las 8 reinas
* @param ocup Lista con las ocupaciones previas, siendo su valor inicial una
lista vaca
* resolver(ocup):
* si tamao(ocup)<8:
* d=disponibles(ocup)
* para cada c en d:
* resolver(ocup+c)
* en caso contrario:
* mostrar solucin
*/
public static void resolver(List<Integer> ocup){
// si tenemos ya 8 reinas ubicadas, es que encontramos una solucin, si
no, hay que iterar recursivamente
if (ocup.size()<8){
// d=disponibles(ocup)
List<Integer> d = disponibles(ocup);
// para cada c en d:
for (Iterator<Integer> c=d.iterator();c.hasNext();){
//resolver(ocup+c) Aqu tengo que crear una lista provisional
List<Integer> provisional = new LinkedList<Integer>(ocup);
provisional.add(c.next());
resolver(provisional);
}
}else{
//mostramos la solucin por pantalla como una linea
String solucion="";
for (Iterator<Integer> j=ocup.iterator();j.hasNext();){
solucion += j.next().intValue();
}
cont++;
System.out.println("Solucion " + cont+" "+solucion + " ");
ALGORITMO
8 REINAS METODOLOGIA ~7~
}
}

public static void main(String[] args) {

//1 OPCION con el mtodo disponibles
/* Creo un ejemplo para ver si la funcion disponibles funciona bien*/
/* Creamos la lista de prueba*/
LinkedList<Integer> a = new LinkedList<Integer>();
a.add(new Integer(3));
a.add(new Integer(5));
/* Creo otra lista para guardar lo que devuelve el mtodo disponibles*/
List<Integer> z = disponibles(a);
for (Iterator<Integer> j=z.iterator();j.hasNext();){
System.out.println(j.next().intValue());
}
// 2 OPCION con el algoritmo resolver
LinkedList<Integer> b = new LinkedList<Integer>();
System.out.println("La solucn con el mtodo resolver es: ");
resolver(b);
}
}