Problema de la ocho reinas. Implementación en Prolog.

Universidad Nacional de Trujillo
Facultad de Ciencias Físicas y
Matemáticas
Escuela Profesional de
Informática
Monografía.
Problema de la ocho reinas. Implementación
en Prolog.
Autores:
- Vallejos Bardales Gian Piere.
- Vela Fernández Jesús Luiscin.
- Villanueva Ruiz Mayra Isabel.
Trujillo – Perú
2014

Universidad Nacional de Trujillo – Escuela de Informática
Problema de las ocho reinas
2
Índice
Dedicatoria ........................................................................................................................3
Introducción ......................................................................................................................4
1. Capítulo I: Marco Teórico ......................................................................................5
1.1 Realidad Problemática.....................................................................................5
2. Capítulo II: Conceptos y Algoritmos Asociados.....................................................6
2.1 Definición.........................................................................................................6
2.1.1 Suposiciones sobre el espacio de soluciones....................................6
2.1.2 Algoritmo Genérico de Backtracking ................................................6
2.1.3 State Space Tree (Arbol de espacio de estados)...............................6
2.2 Búsqueda en Profundidad ...............................................................................7
2.2.1 Definición ..........................................................................................7
2.2.2 Backtracking y DFS............................................................................7
2.2.3 Algoritmo ..........................................................................................7
2.2.4 Pseudocódigo....................................................................................8
2.3 Problema de las 8 reinas ....................................................................................8
2.3.1 Definición ..........................................................................................8
2.3.2 Historia..............................................................................................8
2.3.3 Planteamiento del Problema ............................................................9
2.3.4 Algoritmo ........................................................................................11
2.4 Programa en Prolog.......................................................................................12
Conclusiones....................................................................................................................14
Referencias ......................................................................................................................15
Anexos .............................................................................................................................16

3
A nuestros compañeros estudiantes
que buscan saber un poco más de Prolog,
a nuestra escuela y a nuestra Universidad.
A nuestros padres, familiares y amigos
que confían en lo que podemos hacer y
esperan lo mejor de nosotros.

4
Introducción
El problema de las 8 reinas, propuesto por el ajedrecista alemán Max Bezzel en 1948, es uno
de muchos (Mochila, Jarras de Agua, etc.), que buscan en desafiar la habilidad, la abstracción y
la lógica de aquellos que intentan darle solución.
En pocas palabras, este problema trata sobre cómo se deberían ubicar 8 reinas en un tablero
de ajedrez de dimensión 8 de tal forma que ninguna amenace a la otra. Un requisito simple al
ser leído pero que hizo pensar a muchos matemáticos de aquella época como Gauss y Georg
Cantor.
En la actualidad este problema se ha generalizado y ya no solo son 8 reinas, sino N-reinas
sobre un tablero de dimensión N, donde se busca la misma idea, evitar que las reinas se
amenacen entre sí.
Para nosotros, los informáticos, no nos es suficiente obtener una solución en papel, buscamos
que con la ayuda de un computador, al cual le ingresemos como dato de entrada el número de
N reinas, de como respuesta las posibles soluciones en cada caso.
Los lenguajes de programación en los que se ha implementado este problema son distintos,
pero en esta monografía nos centraremos en el lenguaje Prolog (Programación Lógica), que
con sus conceptos de unificación y backtracking (vuelta atrás) hacen de la implementación de
este problema, algo mucho más sencillo.
En el primer capítulo se detalla una vista general de la realidad problemática sobre cómo es
que la educación está caminando y cómo es que con Prolog esto puede cambiar. Y el segundo
capítulo da alcances de conceptos necesarios para el entendimiento de nuestra
implementación, detallamos el seudocódigo y el código del programa en sí.
No es necesario saber mucho de Prolog para entender nuestra aplicación, así que para
cualquiera que quiera iniciarse en este mundo o que ya tenga conocimiento alguno de este
lenguaje, le será sencillo de entender y porque no, optimizarlo.

5
I. Capítulo 1: Marco Teórico
1.1. Realidad Problemática
La situación actual en los centros educativos e instituciones, señala un
deterioro del clima escolar, que considera acelerado, y una desmotivación
del profesorado y del alumnado, calificando la situación de grave, de alcance
internacional.
Algunas de las causas del problema, es la nueva realidad social de la escuela
("con culturas, niveles curriculares y hasta idiomas diferentes"), la
inadecuación del currículo a esta realidad, la revolución tecnológica en la
que estamos inmersos.
Finalmente se proponen algunas medidas educativas y convivenciales; como
hemos visto, en nuestro ámbito de la programación como Ingenieros
Informáticos el programar en Prolog abre nuestras mentes a un nuevo modo
de ver la computación. Puede que nos resulte difícil comprender esta técnica,
pero nos preocupa, finalmente, más que su dificultad, su utilidad, ya que
muchas veces nos preguntamos para qué aprender conceptos que puede que
en el futuro no sirvan.
Trataremos de mostrar con un ejemplo de forma general la importancia
actual que este tipo de paradigmas tiene. En concreto, el paradigma
declarativo lógico y, por supuesto, el lenguaje Prolog.
Prolog se puede utilizar para resolver, básicamente, cualquier tipo de
problema. Principalmente es útil en la gestión de Juegos, en Inteligencia
Artificial y Sistemas Expertos, como lenguaje especialmente pensado para
construir bases de conocimientos basados en la lógica que forman parte
importante de cualquier agente inteligente, en la construcción de
Compiladores e Intérpretes, en el Reconocimiento del Lenguaje Natural, etc.

6
II. Capítulo 2: Conceptos y Algoritmos Asociados.
2.1. Backtracking:
2.1.1. Definición:
También llamada búsqueda atrás, es una técnica de programación para
hacer búsqueda sistemática a través de todas las configuraciones
posibles dentro de un espacio de búsqueda.
Para lograr esto, los algoritmos de tipo backtracking construyen
posibles soluciones candidatas de manera sistemática. En general, dado
una solución candidata s:
a) Verifican si s es solución. Si lo es, se procesa esta solución
(dependiendo del problema).
b) Construyen todas las posibles extensiones de s, e invocan
recursivamente al algoritmo con todas ellas.
A veces los algoritmos de tipo backtracking se usan para encontrar una
solución, pero otras veces interesa que las revisen todas (por ejemplo,
para encontrar la más corta).
2.1.2. Suposiciones sobre el espacio de soluciones:
a. Supondremos que una solución se puede modelar como un vector
𝑎 = (𝑎1, 𝑎2, … , 𝑎 𝑛), donde cada elemento 𝑎𝑖 es tomado de un
conjunto ordenado finito 𝑆𝑖.
b. Representamos a una solución candidata como un vector
𝑎 = (𝑎1, … , 𝑎𝑘).
c. Las soluciones candidatas se extenderán agregando un elemento al
final.
2.1.3. Algoritmo Genérico de Backtracking.
2.1.4. State Space Tree (Árbol de espacio de estados):
En la teoría de sistemas dinámicos discrétos, un state space es un
conjunto de valores tales que el siguiente proceso puede seguir.
En backtracking podemos crear un state space tree para ver los posibles
candidatos que se deben recorrer para generar una solución.

7
2.2. Búsqueda en Profundidad (Depth First Search).
2.2.1. Definición:
Una búsqueda en profundidad o Depth First Search en inglés es un
algoritmo que permite recorrer todos los nodos de un grafo o árbol de
manera ordenada pero no uniforme. Su funcionamiento consiste en ir
expandiendo todos y cada uno de los nodos que va localizando, de forma
recurrente, en un camino concreto. Cuando ya no quedan más nodos que
visitar en dicho camino, regresa (Backtracking), de modo que repite el
mismo proceso con cada uno de los hermanos del nodo ya procesado.
Análogamente existe el algoritmo de búsqueda en anchura (BFS –
Breadth First Search).
2.2.2. Backtracking y DFS:
La principal diferencia entre el backtracking y el DFS es que el
backtracking va generando sus propias soluciones mientras la búsqueda
en profundidad recorre un grafo ya realizado.
Para poder crear una solución efectiva de backtracking se puede generar
un state space tree y aplicar una búsqueda en profundidad para poder
obtener los resultados que se deseen.
2.2.3. Algoritmo.
Sea G = (V, A) un grafo convexo, V’ = V un conjunto de vértices, A’ un
vector de arcos inicialmente vacío y P un vector auxiliar inicialmente
vacío:
a) Se introduce el vértice inicial en P y se elimina del conjunto V’.
b) Mientras V’ no sea vacío repetir los puntos 3 y 4. En otro caso
parar.
c) Se toma el último elemento de P como vértice activo.
d) Si el vértice activo tiene algún vértice adyacente que se
encuentre en V’:
- Se toma el de menor índice.
- Se inserta en P como último elemento.
- Se elimina de V’.
- Se inserta en A’ el arco que le une con el vértice activo.
- Si el vértice activo no tiene adyacentes se elimina de P.

8
2.2.4. Pseudocódigo:
2.3. Problema de las 8 reinas.
2.3.1. Definición:
El problema de las ocho reinas es un pasatiempo propuesto por el
ajedrecista alemán Max Bezzel en 1848. En el juego de ajedrez la reina
amenaza a aquellas piezas que se encuentren en su misma fila, columna
o diagonal.
El juego de las ocho reinas consiste en colocar sobre un tablero de
ajedrez ocho reinas sin que estas se amenacen entre ellas.
Para resolver este problema se necesita emplear el paradigma de
backtracking.
2.3.2. Historia
El problema fue originalmente propuesto en 1848 por el ajedrecista Max
Bezzel, y durante los años, muchos matemáticos, incluyendo a Gauss y a
Georg Cantor, han trabajado en este problema y lo han generalizado a n-
reinas. Las primeras soluciones fueron ofrecidas por Franz Nauck en
1850. Nauck también se abocó a las n-reinas (en un tablero de nxn de
tamaño arbitrario). En 1874, S. Günther propuso un método para hallar
las soluciones usando determinantes, y J.W.L. Glaisher redefinió su
aproximación.

9
2.3.3. Planteamiento del Problema
Como cada reina puede amenazar a todas las reinas que estén en la
misma fila, cada una ha de situarse en una fila diferente. Podemos
representar las 8 reinas mediante un vector [1-8], teniendo en cuenta que
cada índice del vector representa una fila y el valor una columna. Así cada
reina estaría en la posición (i, v[i]) para i = 1-8.
Por ejemplo el vector (3, 1, 6, 2, 8, 6, 4, 7) significa que la reina 1 está en
la columna 3, fila1; la reina 2 en la columna 1, fila 2; la reina 3 en la
columna 6, fila 3; la reina 4 en la columna 2, fila 4; etc... Como se puede
apreciar esta solución es incorrecta ya que estarían la reina 3 y la 6 en la
misma columna. Por tanto el vector correspondería a una permutación
de los ocho primeros números enteros.
Un asunto importante que tenemos que tener en cuenta es cómo saber si
dos damas no se comen entre ellas diagonalmente. Para las posiciones
sobre una misma diagonal descendente se cumple que tienen el mismo
valor (fila – columna), mientras que para las posiciones en la misma
diagonal ascendente se cumple que tienen el mismo valor (fila +
columna). Entonces, si tenemos dos reinas colocadas en las posiciones (i,
j) y (k, l) entonces están en la misma diagonal si y sólo si cumple:
i – j == k – l ó i + j == k + l
j – l == i – k ó j – l = k – i
Teniendo en cuenta estas consideraciones, podemos aplicar un esquema
retroactivo para implementar las ocho reinas de una manera realmente
eficiente. Para ello, reformulamos el problema como un problema de
búsqueda en un árbol. Decimos que en un vector V1…k de enteros entre
1 y 8 es k-prometedor, para 0 <= k <= 8, si ninguna de las k reinas
colocadas en las posiciones (1, V1), (2, v2),…, (k, Vk) amenaza a ninguna
de las otras. Las soluciones a nuestro problema se corresponden con
aquellos vectores que son 8-prometedores.

10
Figura 01. Explicación de 8 reinas.

11
2.3.4. Algoritmo.
Sea N el conjunto de vectores de k-prometedores, 0 <= k <= 8, sea G = (N,
A) el grafo dirigido tal que (U, V) pertenece a A si y sólo si existe un entero
k, con 0 <= k <= 8 tal que:
- U es k-prometedor
- V es (k+1) prometedor
- Ui = Vi para todo i que pertenece a {1, …, k}
Este grafo es un árbol. Su raíz es el vector vacío correspondiente a k = 0
sus hojas son o bien soluciones (k = 8), o posiciones sin salida (k < 8). Las
soluciones del problema de las ocho reinas se pueden obtener
explorando este árbol. Sin embargo no generamos explícitamente el
árbol para explorarlo después. Los nodos se van generando y
abandonando en el transcurso de la exploración mediante un recorrido
en profundidad.
Hay que decidir si un vector es k-prometedor, sabiendo que es una
extensión de un vector (k – 1 )-prometedor, únicamente necesitamos
comprobar la última reina que haya que añadir. Este se puede acelerar
si asociamos a cada nodo prometedor el conjunto de columnas, el de
diagonales positivas y el de diagonales negativas controlados por las
reinas que ya están puestas.
Figura 02. Esquema reducido del árbol de soluciones.

12
2.4. Programa en Prolog.
Predicados:
a) nreinas (N, S).
Primer predicado y usado para consultar en el intérprete de Prolog.
𝑛𝑟𝑒𝑖𝑛𝑎𝑠(𝑁, 𝑆): − 𝑐𝑟𝑒𝑎𝑟𝑇𝑎𝑏𝑙𝑒𝑟𝑜(𝑁, 𝑇𝑎𝑏𝑙𝑒𝑟𝑜),
𝑝𝑒𝑟𝑚𝑢𝑡𝑎𝑟(𝑇𝑎𝑏𝑙𝑒𝑟𝑜, 𝑆),
𝑡𝑎𝑏𝑙𝑒𝑟𝑜𝐶𝑜𝑟𝑟𝑒𝑐𝑡𝑜(𝑆).
𝒏𝒓𝒆𝒊𝒏𝒂𝒔(𝑵, 𝑺): − 𝒄𝒓𝒆𝒂𝒓𝑻𝒂𝒃𝒍𝒆𝒓𝒐(𝑵, 𝑻𝒂𝒃𝒍𝒆𝒓𝒐),
𝒑𝒆𝒓𝒎𝒖𝒕𝒂𝒓(𝑻𝒂𝒃𝒍𝒆𝒓𝒐, 𝑺),
𝒕𝒂𝒃𝒍𝒆𝒓𝒐𝑪𝒐𝒓𝒓𝒆𝒄𝒕𝒐(𝑺).
𝒄𝒓𝒆𝒂𝒓𝑻𝒂𝒃𝒍𝒆𝒓𝒐(𝟎, []).
𝒄𝒓𝒆𝒂𝒓𝑻𝒂𝒃𝒍𝒆𝒓𝒐(𝑿, [𝑿|𝑹]):−𝑿𝑴𝒆𝒏𝒐𝒔𝟏 𝒊𝒔 𝑿 − 𝟏,
𝑿𝑴𝒆𝒏𝒐𝒔𝟏 >= 𝟎,
𝒄𝒓𝒆𝒂𝒓𝑻𝒂𝒃𝒍𝒆𝒓𝒐(𝑿𝑴𝒆𝒏𝒐𝒔𝟏, 𝑹).
𝒑𝒆𝒓𝒎𝒖𝒕𝒂𝒓([],[]).
𝒑𝒆𝒓𝒎𝒖𝒕𝒂𝒓(𝑿,[𝑪|𝒁])
∶ − 𝒔𝒆𝒍𝒆𝒄𝒄𝒊𝒐𝒏𝒂𝒓(𝑿, 𝑪, 𝑹), 𝒑𝒆𝒓𝒎𝒖𝒕𝒂𝒓(𝑹, 𝒁).
𝒔𝒆𝒍𝒆𝒄𝒄𝒊𝒐𝒏𝒂𝒓([𝑿|𝑹], 𝑿, 𝑹).
𝒔𝒆𝒍𝒆𝒄𝒄𝒊𝒐𝒏𝒂𝒓([𝑪|𝑹], 𝑿, [𝑪|𝒀])
∶ − 𝒔𝒆𝒍𝒆𝒄𝒄𝒊𝒐𝒏𝒂𝒓(𝑹, 𝑿, 𝒀).
𝒕𝒂𝒃𝒍𝒆𝒓𝒐𝑪𝒐𝒓𝒓𝒆𝒄𝒕𝒐([]).
𝒕𝒂𝒃𝒍𝒆𝒓𝒐𝑪𝒐𝒓𝒓𝒆𝒄𝒕𝒐([𝑪|𝑹]): − 𝒏𝒐𝒕(𝒂𝒎𝒆𝒏𝒂𝒛𝒂(𝑪, 𝑹)),
𝒕𝒂𝒃𝒍𝒆𝒓𝒐𝑪𝒐𝒓𝒓𝒆𝒄𝒕𝒐(𝑹).
𝒂𝒎𝒆𝒏𝒂𝒛𝒂(𝑿, 𝑷𝒓𝒐𝒇, [𝑪|_]): − 𝑿 𝒊𝒔 𝑪
+ 𝑷𝒓𝒐𝒇;
𝑿 𝒊𝒔 𝑪 − 𝑷𝒓𝒐𝒇;
𝑿 = 𝑪.
𝒂𝒎𝒆𝒏𝒂𝒛𝒂(𝑿, 𝑷𝒓𝒐𝒇, [_|𝑹]): − 𝑷𝒓𝒐𝒇𝑴𝒂𝒔𝟏 𝒊𝒔 𝑷𝒓𝒐𝒇 + 𝟏,
𝒂𝒎𝒆𝒏𝒂𝒛𝒂(𝑿, 𝑷𝒓𝒐𝒇𝑴𝒂𝒔𝟏, 𝑹).
𝒂𝒎𝒆𝒏𝒂𝒛𝒂(_,[]): − 𝒇𝒂𝒊𝒍.
𝒂𝒎𝒆𝒏𝒂𝒛𝒂(𝑿, 𝒀): − 𝒂𝒎𝒆𝒏𝒂𝒛𝒂(𝑿, 𝟏, 𝒀).

13
b) crearTablero (X, Y).
Genera un tablero de dimensión X, además testea que Y es una lista
de X elementos que contiene los números enteros comprendido
entre 1 y X (pueden ser ambos).
𝑐𝑟𝑒𝑎𝑟𝑇𝑎𝑏𝑙𝑒𝑟𝑜(0,[]).
𝑐𝑟𝑒𝑎𝑟𝑇𝑎𝑏𝑙𝑒𝑟𝑜(𝑋, [𝑋|𝑅]): −𝑋𝑀𝑒𝑛𝑜𝑠1 𝑖𝑠 𝑋 − 1,
𝑋𝑀𝑒𝑛𝑜𝑠1 >= 0,
𝑐𝑟𝑒𝑎𝑟𝑇𝑎𝑏𝑙𝑒𝑟𝑜(𝑋𝑀𝑒𝑛𝑜𝑠1, 𝑅).
Se debe tener en cuenta que dentro del tablero cada reina debe estar
ubicada en una columna distinta, por tanto el tablero (tableros)
solución será (serán) en donde se de una permutación de este tipo.
El tablero tiene la forma [𝑁, 𝑁 − 1, 𝑁 − 2, … , 1].
c) permutar (LX, LY).
Se comprueba si LY es una permutación de los elementos de LX.
𝑝𝑒𝑟𝑚𝑢𝑡𝑎𝑟([],[]).
𝑝𝑒𝑟𝑚𝑢𝑡𝑎𝑟(𝑋, [𝐶|𝑍]) ∶ − 𝑠𝑒𝑙𝑒𝑐𝑐𝑖𝑜𝑛𝑎𝑟(𝑋, 𝐶, 𝑅), 𝑝𝑒𝑟𝑚𝑢𝑡𝑎𝑟(𝑅, 𝑍).
Para permutar, se selecciona el primer valor de la lista y se permuta
con el resto de la lista.
d) seleccionar (L, X, R).
Se comprueba si X es un elemento de L y R es la lista L sin el elemento
X.
𝑠𝑒𝑙𝑒𝑐𝑐𝑖𝑜𝑛𝑎𝑟([𝑋|𝑅], 𝑋, 𝑅).
𝑠𝑒𝑙𝑒𝑐𝑐𝑖𝑜𝑛𝑎𝑟([𝐶|𝑅], 𝑋, [𝐶|𝑌]) ∶ − 𝑠𝑒𝑙𝑒𝑐𝑐𝑖𝑜𝑛𝑎𝑟(𝑅, 𝑋, 𝑌).
e) tableroCorrecto(X).
Se testea si en el tablero X, ninguna reina amenaza a la otra.
𝑡𝑎𝑏𝑙𝑒𝑟𝑜𝐶𝑜𝑟𝑟𝑒𝑐𝑡𝑜([]).
𝑡𝑎𝑏𝑙𝑒𝑟𝑜𝐶𝑜𝑟𝑟𝑒𝑐𝑡𝑜([𝐶|𝑅]): − 𝑛𝑜𝑡(𝑎𝑚𝑒𝑛𝑎𝑧𝑎(𝐶, 𝑅)),
𝑡𝑎𝑏𝑙𝑒𝑟𝑜𝐶𝑜𝑟𝑟𝑒𝑐𝑡𝑜(𝑅).

14
f) amenaza(X, Y).
Se comprueba si una reina colocada en la columna X de la fila n de un
tablero amenaza a cualquiera de las demás reinas colocadas en las
filas 0 … 𝑛 − 1 del resto del tablero, y cuyas columnas vienen
especificadas en la lista Y.
𝑎𝑚𝑒𝑛𝑎𝑧𝑎(𝑋, 𝑃𝑟𝑜𝑓, [𝐶|_]):− 𝑋 𝑖𝑠 𝐶 + 𝑃𝑟𝑜𝑓;
𝑋 𝑖𝑠 𝐶 − 𝑃𝑟𝑜𝑓;
𝑋 = 𝐶.
𝑎𝑚𝑒𝑛𝑎𝑧𝑎(𝑋, 𝑃𝑟𝑜𝑓, [_|𝑅]):− 𝑃𝑟𝑜𝑓𝑀𝑎𝑠1 𝑖𝑠 𝑃𝑟𝑜𝑓 + 1,
𝑎𝑚𝑒𝑛𝑎𝑧𝑎(𝑋, 𝑃𝑟𝑜𝑓𝑀𝑎𝑠1, 𝑅).
𝑎𝑚𝑒𝑛𝑎𝑧𝑎(_,[]):− 𝑓𝑎𝑖𝑙.
𝑎𝑚𝑒𝑛𝑎𝑧𝑎(𝑋, 𝑌): − 𝑎𝑚𝑒𝑛𝑎𝑧𝑎(𝑋, 1, 𝑌).
Conclusiones
En síntesis, las estrategia de búsqueda nos da una idea de cómo los investigadores
en IA proponen diferentes formas de solución para los problemas; estas técnicas
son clásicas y es por ello que deben ser conocidas por todos aquellos que están
relacionados con programación de soluciones por computadora. Existen otros
métodos que requieren de mayor complejidad de programación para encontrar
mejores soluciones en un tiempo razonable, como son el método de ascenso de la
colina, algoritmos genéticos, las redes neuronales. Todos ellos requieren de una
mayor complejidad de computación y mayor conocimiento e información del
problema.
Por tanto, el mundo real es más complejo de lo que se formula en los problemas
para solucionar por computadora, sin embargo asumimos que los seres humanos
para encontrar soluciones tampoco requieren de mucha información, o al menos
no requiere conocer todo el universo para encontrar soluciones buenas.

15
Referencias.
Bibliografía.
[1] Russell, Stuart J., Norvig, Peter., Inteligencia Artificial: Un enfoque moderno
2da Edición, Prentice Hall, 2004.
[2] Nilsson, Nils J., Artificial Intelligence: A New Synthesis, Morgan Kaufmann,
1998.
[3] Simon, Herbert A., Las ciencias de lo artificial, Comares, 2006.
[4] Colaboradores de Wikipedia. Inteligencia artificial [en línea]. Wikipedia, La
en ciclopedia libre, 2009 [fecha de consulta: 2 de enero del 2009]. Disponible
en
<http://es.wikipedia.org/w/index.php?title=Inteligencia_artificial&oldid=2298
6524>.
Webgrafía.
Wikipedia - Vuelta atrás o Backtracking.
http://es.wikipedia.org/wiki/Vuelta_atr%C3%A1s
Wikipedia - State Space Tree
http://en.wikipedia.org/wiki/State_space
Wikipedia - Búsqueda en profundidad
http://es.wikipedia.org/wiki/B%C3%BAsqueda_en_profundidad
Departamento de Matemática Aplicada - Búsqueda en Profundidad
http://www.dma.fi.upm.es/java/matematicadiscreta/busqueda/

16
ANEXOS
Tabla comparativa de estrategias de búsqueda en espacios de estados:
Se muestra una comparativa entre las estrategias de búsqueda. Esta nos puede dar
una idea rápida de cuál estrategia debemos utilizar al intentar resolver un
problema de búsqueda en espacio de estados.
Búsqueda Ventajas Desventajas
Profundidad Requisitos modestos de
memoria; fácil
implementación
Puede tener ciclos
infinitos y no encontrar el
resultado.
Amplitud Encuentra la solución si
existe dentro del espacio
de búsqueda; fácil
programación.
Requiere de mucha
memoria para; almacenar
los nodos.
Con retroceso Menor requisito de
memoria al de
profundidad, fácil
programación.
Puede tener ciclos
infinitos
y no encontrar el
resultado
Primero el mejor Puede encontrar buenas
soluciones; resultados
más eficientes que una
búsqueda no informada.
Puede tener ciclos
infinitos; requiere diseño
de una heurística
complejidad de
programación de la
heurística.
A* Encuentra buenas
soluciones; No se crean
ciclos requerimientos
moderados de memoria.
Requiere de muy buenas
heurísticas.
Minimax
fácil programación
Encuentra una solución
óptima. Puede
retroceder en caso de no
haber una salida.
Sólo funciona para juegos
contra adversarios.
Crece exponencialmente
al
número de movimientos
Requiere de una muy
buena
Función de evaluación.

17
Glosario de Términos:
Árbol: estructura de datos ampliamente usada que imita la forma de un árbol (un
conjunto de nodos conectados). Un nodo es la unidad sobre la que se construye el
árbol y puede tener cero o más nodos hijos conectados a él. Se dice que un nodo a
es padre de un nodo b si existe un enlace desde a hasta b (en ese caso, también
decimos que b es hijo de a).
Camino solución: Un grafo dirigido de los nodos visitados que nos llevan a la
solución.
Cola: es una estructura de datos, caracterizada por ser una secuencia de elementos
en la que la operación de inserción push se realiza por un extremo y la operación
de extracción pop por el otro.
Estrategia de Búsqueda: método computacional para resolver problemas.
Heurística: Del griego heuriskein, encontrar. Criterio que puede resolver un
problema pero que no hay garantía de que siempre lo resuelva. Estimación del
coste necesario para alcanzar una solución desde el estado actual.
Pila: es una lista ordinal o estructura de datos en la que el modo de acceso a sus
elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en
salir) que permite almacenar y recuperar datos.
Prolog: Prolog se enmarca en el paradigma de los lenguajes lógicos, lo que lo
diferencia enormemente de otros lenguajes más populares tales como Fortran,
Pascal, C.

18

Problema de la ocho reinas. Implementación en Prolog.

Más contenido relacionado

La actualidad más candente

Destacado

Similar a Problema de la ocho reinas. Implementación en Prolog.

Último

Problema de la ocho reinas. Implementación en Prolog.