Universidad Autónoma Gabriel René Moreno

Facultad de Ciencias de la Computación

Materia: Inteligencia Artificial.

Tema: El Problema de las nReinas.

Algoritmo de backTrack(…).

Docente: Lic. Edwin Vargas Yapura.

Algoritmo de backTrack.
El Algoritmo de backTrack(), es una función lógica recursiva (llamada recursiva dentro de un ciclo),
que devuelve True, si ha encontrado el primer camino solución, devuelve False si no existe camino
del estado inicial al estado final.

boolean backTrack (DATOS){

if(terminacion(DATOS)) return true; DATOS
Lista L1 = reglasAplicables(DATOS);
R
while(!L1.vacia()){
R = elegirMejorRegla(L1, Datos); RDATOS
RDATOS = aplicarRegla(R, DATOS);
if(backtrack(RDATOS)) return true;
}
return false;
}

Observar que este Algoritmo, solo encuentra el primer camino solución del estado inicial al estado final, éste
camino no necesariamente es el camino óptimo (camino de costo mínimo). Como su nombre indica, el
Algoritmo explora caminos, en caso de no encontrar camino solución, regresa y sigue otro camino.
 El problema de las nReinas.
Dado una matriz cuadrada de n x n (n-filas por n-columnas) y n-Reinas, que se desea ubicar en el
tablero, tales que entre ellas no se puedan atrapar.

Para n = 1 Existe Solución Para n = 4 Existe Solución

Para n = 2 No Existe Solución

Para n = 5 Existe Solución

Para n = 3 No Existe Solución
 L1 = [11, 12, 13, 14]
(4)

11 12

L1 = [23, 24] L1 = [24]

(1)
(3)
23 24 24

L1 = [] L1 = [31]
L1 = [32]

(2) 32 31

L1 = [] L1 = [43]

43

El problema de las nReinas, Búsqueda de Camino . . .

El Problema de las nReinas.
Aplicando el Algoritmo de backTrack(), al problema de las nReinas, es similar a los Algoritmos analizados en los
problemas anteriores, a diferencia que éste algoritmo es función lógica y busca hasta encontrar el primer
camino solución.
public static boolean nReinas(int m[][], int i){
if(i >= m.length) return true;
LinkedList<Regla> L1 = reglasAplicables(m, i);

while(!L1.isEmpty()){
Regla R = elegirRegla(L1);
m[R.fil][R.col] = i + 1;
if(nReinas(m, i + 1)) return true;
m[R.fil][R.col] = 0;
}
return false;
}

En la ejecución de éste Algoritmo, buscaremos algunos indicadores para medir la eficacia de las
búsquedas utilizando heurísticas en la elección de la regla a apliar.
El Problema de las nReinas.
Para sistematizar el llenado de las reinas en el tablero, realizaremos de fila en fila, desde la primera hasta la
última. Es decir; encontraremos todas las reglas aplicables para la fila-i, luego fila-i+1, etc..

public static LinkedList<Regla> reglasAplicables(int m[][], int i){

LinkedList<Regla> L1 = new LinkedList();
for(int j = 0; j < m[i].length; j++){
if(posValido(m, i, j)) L1.add(new Regla(i, j));
}
return L1;
}

public static boolean posValido(int m[][], int i, int j){

return filValido(m, i) && colValido(m, j) &&
diagSupIzq(m, i, j) && diagSupDer(m, i, j) &&
diagInfIzq(m, i, j) && diagInfDer(m, i, j);
}

Para verificar si la posición i, j es válido, recorrer por toda la fila, toda la columna, y las diagonales
incluidos la posición i, j.
 El Problema de las nReinas.
public static boolean diagSupDer(int m[][], int i1, int j1){
int i = i1, j = j1;
while(i >= 0 && j < m[i1].length){ Existen cuatro posibles
if(m[i][j] != 0) return false; diagonales, para cada uno
i = i - 1; de ellos se debe recorrer
j = j + 1; para verificar si no existe
} otra reina en el camino.
return true;
}

// Sin heurística... Elegir una casilla, en lo posible al

public static Regla elegirReglaA(LinkedList<Regla> L1){ medio de la fila, es buena
return L1.removeFirst();
elección, dado que afectará
}
menos casillas en sus diagonales.
// Con heurística... Con esta heurística, la diferencia
public static Regla elegirReglaB(LinkedList<Regla> L1){ en la búsqueda es significativa.
return L1.remove(L1.size() / 2);
}
 Conclusiones
• Para problemas dónde existen múltiples combinaciones o permutaciones de resultados que nos guían a las
metas durante la búsqueda de soluciones, existen millones de posibilidades y es impracticable buscar todos
los caminos posibles.

• El Algoritmo de backTrack(), resuelve el problema de buscar todas las soluciones, busca el primer camino
que se encuentra desde el estado inicial al estado final, aunque no necesariamente es la mejor solución.

• Los indicadores utilizados para medir la eficiencia de las búsquedas de caminos solución es la longitud de
camino y/o la cantidad de vueltas (caminos seguidos innecesariamente, que no llevan a la solución).

• Para el problema de las nReinas, utilizar como heurística elegir una casilla en lo posible del centro de la
matriz es mejor opción que elegir una casilla que se encuentra en los extremos de la matriz, ésta heurística
reduce considerablemente seguir caminos innecesarios. Sin embargo, la mejor heurística será aquella que
indique seleccionar una regla que se conduce directo a la solución. Esta heurística existe, pero no se conocer
sino que nos aproximamos a ella.