juego del puzzle(1)

8/8/2019 Juego Del Puzzle(1)

1/19

Juego del Puzzle

Es un problema clsico en la rama de la Inteligencia Artificial, aunque el problemaparece de cierta manera trivial en la forma de entender y de plasmar en un lenguaje de programacin, es sin embargo de cierta compledidad en la hora de resolverlocomputacionalmente, iniciaremos dando una breve descripcin del problema, y

posteriormente veremos las tcnicas comunes que son usadas para resolver este juego.sin mas prembulo iniciaremos con el problema.

Descripcin

Tratamos de resolver un juego de puzzle con 9 casillas para el caso del 8-puzzle, en lacual 8 estn llenas de algn elemento (Imagen, Numero, Letra, etc) y la novena casillase encuentra vaca, esto sirve para hacer movimientos de manera horizontal o vertical, elobjetivo es llegar de un estado inicial a un estado meta (Solucin).

Estado Inicial, Estado Meta A y Estado Meta B respectivamente.

Debemos notar que al mover una ficha de posicin generamos un nuevo estado la cualtenemos que analizar, as moviendo las fichas de lugar en diferentes formas llegaremosal estado meta -sin embargo no todo esto es cierto- existe un problema en el juego de

puzzle llamado error de paridad(Muy similar al error de paridad de las comunicacioneselectrnicas). Por lo tanto no siempre desde cualquier estado inicial, podemos llegar aun estado meta.


2/19

Error de paridad

Antes de entender el error de paridad necesitamos plantear el concepto de inversin quedepende del Estado Meta a llegar, por lo cual tomaremos nuestro Estado inicial yEstado Meta B respectivamente:

Llamamos inversin a la violacin del orden de la posicin de acuerdo a su valor perse, en otras palabras un numero mayor se encuentra justamente detrs de un numeromenor, en el estado ilustrado anteriormente tenemos:

2 se encuentra detrs del 1

8 se encuentra detrs del 3, 1, 6, 4, 7 y 5


6 detrs del 4 y 5

Y por ultimo 7 detrs del 5

Esto nos da un total de inversiones de 11, un numero impar.

De otra forma tenemos el Estado Inicial y el Estado Meta A:

Usando la misma logica pasada tenemos que:


8 se encuentra detrs del 1 y 3


6 se encuentra detrs del 4 y 7

Con un total de 6 inversiones un numero par.

Como podra ya suponerse, el error de paridad depende exclusivamente del total deinversiones, ya que si es un numero par tiene solucin, de lo contrario es imposiblellegar al Estado Meta.


3/19

Bsqueda

Dado que al cambiar una ficha de posicin estamos generando un nuevo estado,podemos ver el problema del puzzle en forma de arbol, en la que cada nodo es un estadodel puzzle generado por un padre (Excepto el nodo raz, el cual es el estado inicial), y

cada nodo hijo es un nuevo estado generado a partir del movimiento de las fichas, porejemplo:

Existen principalmente dos tipos de bsqueda para resolver el problema del puzzle yclaro entre otros.

y Bsqueda a Ciegas (No informada)o Fuerza Bruta (Sin orden en particular)o Ordenada (Estrategia de orden)

Depth-first (Expandir en profundidad) Breath-first (Expandir en anchura) Iterative Deeping Search (Una combinacin de las estrategiasanteriores)

y Bsqueda Contextual (Informada)o Selectiva (Estrategias de expansin)

Best-first A*

Algoritmo Best-First

La bsqueda usada en este problema fue de manera contextual y con estrategia deexpansin de Best-First.

Los mtodos de bsqueda contextual no se ajustan a un orden fijo para expandir losestados, sino que, para tomar la decisin, incorporan una funcin de evaluacin (x) lacual se compone de dos partes:

(x) = g(x) + h(x)

Funcin de Costo Estimado y funcin de aptitud


4/19

h(x) es una funcin que evala el estado x en cuanto a su parecido con el estado meta.

g(x) evala la dificultad, en terminos del espacio de estados representados, de llegarhasta el estado x, o bien, la dificultad restante hasta llegar a un estado meta, estacomponente de la funcion es usada usualmente en el algoritmo A*.

En lugar de expandir siempre un profundidad (Depth-first), siempre en anchura (Breath-first), o una combinacin (Iterative Deeping Search), este algoritmo expande, en cadaocasin, el estado mas prometedor.

La funcin de evaluacin heurstica determina cul es el nodo a expandir.

Funcin de Aptitud

Existen dos funciones de aptitud tradicionalmente usadas para este problema enparticular, ambas funciones de aptitud miden las diferencia entre el estado evaluado y elestado meta.

Estado Meta usado

y El numero de fichas colocadas de manera incorrecta, basada en el estado meta.

h(e) = Numero de fichas mal posicionadas

h(e) = 4

y La suma de la distancia Manhattan (Suma Vertical y Horizontal), de cada ficha asu posicin del estado meta.


5/19

h(e) = i=1 to i=8 ( e(i), Estado Meta(i) )

h(e) =1 + 1 + 2 + 1 = 5

Pasos del Algoritmo Best-First

1. Definir la lista de estados a examinar (Lista OPEN), conteniendoexclusivamente el estado inicial S.

2. Si la lista OPEN est vaca, entonces NO HAYSOLUCINy terminar.3.

Extraer de la lista el siguiente estado (n) con mejor aptitud y moverlo a unalista de nodos ya examinados (CLOSED), dado que la lista debera estarsiempre ordenada debemos seleccionar el primer estado.

4. Expandir el estado n (En todas sus formas validas).5. Si algn sucesor de n es el estado meta, SOLUCIN y reconstruirla, de lo

contrario.

Para cada estado recin generado:

y Evaluar su aptitud con h(e).y En caso de que el estado no se encuentre en alguna de las dos listas,

entonces aadirlo a OPEN.y Ordenamos OPENy Regresar al Paso 2


6/19

Ejemplo simple

Tenemos Estado Inicial y el Estado Meta respectivamente.

Paso 1, Insertar el estado inicial a la lista de OPEN.

Lista OPEN

Lista CLOSED

Vaca

Paso 2, verificar si la lista OPEN no esta vaca.

Paso 3 extraer de la lista OPEN el estado con mejor aptitud, en este caso como OPENsolo tiene un elemento,lo movemos a CLOSED

Lista OPEN

Vaca

Lista CLOSED


7/19

Paso 4, expendemos el estado.

Lo que nos da:

Paso 5, ningn estado sucesor de (n) es el estado meta.

Paso 6, Usaremos la funcin aptitud de posiciones incorrectas, y tenemos sus siguienteaptitudes respectivamente:h1(e) = 3, h2(e) = 5, h3(e) = 4

Ninguno de los estados se encuentra en CLOSED ni en OPEN, por lo tanto metemosnuestros estados a la lista OPEN.

Lista OPEN

Ordenamos de acuerdo a su aptitud h1(e) = 3, h3(e) = 4, h2(e) = 5:

Lista OPEN


8/19

Lista CLOSED

Repetimos el Paso 2, verificamos si la lista OPENesta vaca.

Paso 3 extraer de la lista OPEN el estado con mejor aptitud. y lo movemos a CLOSED

Lista OPEN

Lista CLOSED


Lo que nos da:


9/19


Paso 6, Usaremos la funcin aptitud de posiciones incorrectas, y tenemos sus siguienteaptitudes respectivamente:h4(e) = 3, h5(e) = 4, h6(e) = 4, h7(e) = 3

Ya queh6(e) se encuentra en CLOSED no se insertara en la listaOPEN, por lo tantosolo metemos h4,h5,h7, lo que en la lista nos quedah3, h2, h4, h5, h7

Lista OPEN

Ordenamos de acuerdo a su aptitud h7(e) = 3, h4(e) = 3, h5(e) = 4, h3(e) = 4, h2(e) = 5


10/19

Lista OPEN

Repetimos el Paso 2, verificamos si la lista OPEN esta vaca.


Lista OPEN

Lista CLOSED


11/19


Lo que nos da:


Paso 6, Usaremos la funci n aptitud de posiciones incorrectas, y tenemos sus siguienteaptitudes respecti amente: h8(e) = 2, h9(e) = 3, h10(e) = 4

Ya que h9(e) se encuentra en CL SED no se insertara en la listaOPE , porlo tantosolo metemos h8, h10,lo que en la lista nos quedah4,h5,h3,h2,h8,h10

Li OPE

rdenamos de acuerdo a su aptitudh8(e) = 2, h4(e) = 3, h5(e) = 4, h3(e) = 4, h10(e) =4, h2(e) = 5


12/19

Lista OPEN



Lista OPEN

Lista CLOSED



13/19

Lo que nos da:


Paso 6, Usaremos la funcin aptitud de posiciones incorrectas, y tenemos sus siguienteaptitudes respectivamente:h11(e) = 1,h12(e) = 3

Ya queh12(e) se encuentra en CLOSED no se insertara en la listaOPEN, por lo tantosolo metemos h11 lo que en la lista nos quedah4,h5,h3,h2,h10.h11

Lista OPEN

Ordenamos de acuerdo a su aptitud h11(e) = 1,h4(e) = 3,h5(e) = 4,h3(e) = 4,h10(e) =4,h2(e) = 5


14/19



Lista OPEN


15/19

Li CLOSED


Lo que nos da:

Paso 5, Un estado sucesor de (n) es el estado meta.

Reconstruimos la soluci n:


16/19

Conclusin

Con un poco de observacin notaremos que solo 5 movimientos son necesarios parallegar del estado inicial al estado meta, sin embargo este ejemplo aunque parece simple,tiene varios detalles que contemplar como: las listas de OPEN y CLOSED vancreciendo a un ritmo acelerado, tendramos que reservar espacio en memoria para lasdos listas, generar nuevos estados, comparar estado anteriores, ordenar la lista de OPEN

para cada insercin de un nuevo estado, y generar aptitudes por cada estado, lo que haceque requiera un gran recurso de tiempo mquina. Llegando en ciertos lenguajes de

programacin imposible de llegar a una solucin -Aunque esta exista-.Una cosa mas que notar, es sobre la funcin de aptitud, ya que por lo generar en este

juego, la funcin de aptitud de Manhattan es increblemente superior a la funcin deposiciones incorrectas.

El tamao del espacio de bsqueda para el 8-puzzle es de 9!, esto es: 362,880permutaciones, ahora supongamos que necesitamos resolver el 15-puzzle, el cual tiene15!, lo que es equivalente a: 1,307,674,368,000 permutaciones!!!!


17/19

;;;*******************************************************************

;;; Enunciado:

;;;*******************************************************************

;;; Para el 8-puzzle se usa un cajn cuadrado en el que hay situados 8

bloques

;;; cuadrados. El cuadrado restante est sin rellenar. Cada bloque

tiene un

;;; nmero. Un bloque adyace nte al hueco puede deslizarse hacia l. El

juego

;;; consiste en transformar la posicin inicial en la posicin final

mediante

;;; el deslizamiento de los bloques. En particular, consideramos el

estado

;;; inicial y final siguientes:

;;;

;;; +---+---+---+ +---+---+---+

;;; | 2 | 8 | 3 | | 1 | 2 | 3 |

;;; +---+---+---+ +---+---+---+

;;; | 1 | 6 | 4 | | 4 | 5 | 6 |

;;; +---+---+---+ +---+---+---+

;;; | 7 | | 5 | | 7 | 8 | |

;;; +---+---+---+ +---+---+---+;;;

;;; Estado inicial Estado final

;;;*******************************************************************

;;; Estado inicial

;;;*******************************************************************

(defparameter *estado -inicial*

(make-array '(3 3)

:initial-contents '((2 8 3)

(1 6 4)

(7 h 5))))

;;;*******************************************************************;;; Estado final

;;;*******************************************************************

(defparameter *estado -final*

(make-array '(3 3)

:initial-contents '((1 2 3)

(8 h 4)

(7 6 5))))

(defun es-estado-final (estado)

(equalp estado *estado -final*))

;;;*******************************************************************

;;; Funciones auxiliares

;;;*******************************************************************

(defun copia-tablero (tablero)

(let ((nuevo-tablero (make-array '(3 3))))

(loop for i from 0 to 2

do (loop for j from 0 to 2

do (setf (aref nuevo -tablero i j)

(aref tablero i j) )))

nuevo-tablero))


18/19

(defun coordenadas (bloque tablero)


thereis (loop for j from 0 to 2

thereis

(when (eq (aref tablero i j) bloque)

(list i j)))))

;;;****************************************** *************************

;;; Operadores

;;;*******************************************************************

(defparameter *operadores*

'(mover-izquierda

mover-arriba

mover-derecha

mover-abajo))

(defun mover-izquierda (estado)

(let* ((lugar-del-hueco (coordenadas 'h estado))

(i (first lugar-del-hueco))

(j (second lugar-del-hueco))

(nuevo-estado (copia-tablero estado)))

(when (> j 0)(setf (aref nuevo-estado i j) (aref nuevo -estado i (-

j 1)))

(setf (aref nuevo-estado i (- j 1)) 'h)

nuevo-estado)))

(defun mover-arriba (estado)





(when (> i 0)

(setf (aref nuevo -estado i j) (aref nuevo -estado (- i 1) j))

(setf (aref nuevo-estado (- i 1) j) 'h)

nuevo-estado)))

(defun mover-derecha(estado)





(when (< j 2)

(setf (aref nuevo-estado i j) (aref nuevo -estado i (+ j 1)))

(setf (aref nuevo-estado i (+ j 1)) 'h)

nuevo-estado)))

(defun mover-abajo (estado)





(when (< i 2)

(setf (aref nuevo-estado i j) (aref nuevo -estado (+ i 1) j))

(setf (aref nuevo-estado (+ i 1) j) 'h)

nuevo-estado)))

(defun aplica (operador estado)

(funcall (symbol-function operador) estado))


19/19

;;;*******************************************************************

;;; Coste

;;;****************************** *************************************

(defun coste-de-aplicar-operador (estado operador)

(declare (ignore estado operador))

1)

;;;*******************************************************************

;;; Heursticas

;;;********************************* **********************************

(defun heuristica (estado)

(heuristica-1 estado))

(defun heuristica-1 (estado)


counting (not (equal (coordenadas i estado)

(coordenadas i *estado -final*)))))

(defun heuristica-2 (estado)


summing (distancia -manhattan (coordenadas i estado)(coordenadas i *estado -final*))))

(defun distancia-manhattan (c1 c2)

(+ (abs (- (first c1) (first c2)))

(abs (- (second c1) (second c2)))))

juego del puzzle(1)

Documents