Tercer programa de la unidad 2. La torre de Hanoi.

Las torres de Hanoi es un juego matemtico ideado en el siglo XVIII. Este juego consiste en pasar 64
discos de dimetro decreciente, de un poste a otro poste, utilizando un tercer poste auxiliar para los pasos
intermedios, tal y como muestra la Figura 1 (en la figura se presenta el juego utilizando 8 piezas).

Figura 1. Torres de Hanoi.

Cada vez slo se puede mover un disco, los discos siempre deben estar en algn poste y no se puede
colocar un disco sobre otro de menor tamao.
1. Cmo representaras los estados?
2. Cules seran los operadores?
1-. Representacin de los estados:
El estado lo definirn 3 pilas representando los postes, en donde cada pila contiene algunos o todos
los discos.
El estado est definido por los Discos que se encuentran dentro de cada pila y la posicin dentro de
la pila.
D(n,i) n = n de disco ;
i = posicin dentro de la pila
Pk {D(n, 1), D(n-1, 2), , D((n-i)+1),i)} donde 1 k 3 ,1 n 8 y 1 i 8
(Ntese que la posicin ms baja de una pila es 1)
El estado inicial seria para el caso de 8 discos:
P1{D(8, 1), D(7, 2), D(6, 3), D(5, 4), D(4, 5), D(3, 6), D(2, 7), D(1, 8)}
P2{} y P3{}

El estado final es:

P2{D(8,1),D(7,2),D(6,3),D(5,4),D(4,5),D(3,6),D(2,7),D(1,8)}
P1{} y P3{}

2 -. Las operaciones disponibles son:

Mover(l, k, Dn) : l = {1, 2, 3} k={1, 2, 3} l j y 1 n 8 (Donde l indica la pila origen, k la pila destino y Dn el disco)
Las restricciones son:
Se puede realizar cualquier operacin Mover (l, k,Dn) siempre que el valor de Dn, sea menor que el valor de Dn en la posicin j de la pila k: (Dn) < (Dn)Pkj.
(Dn)Pij = Valor de Dn en la pila k posicin j.
Ej: P_1 {D(8,1),D(7,2) } el valor Dn=7 para la pila k=1,posicin j= 2
Objetivos.
a) Con la informacin anterior realice el anlisis del problema de bsqueda.
b) Implemente el mtodo de bsqueda primero en profundidad para encontrar una solucin
al problema del juego con 8 piezas.
c) Realiza el reporte correspondiente (pdf).

Programa final de la segunda unidad de IA (Evaluacin).

Utiliza el siguiente cdigo en lenguaje C y OpenGl para hacer la representacin del laberinto de 20x20
que se presenta en la figura 2. Pueden cambiar la configuracin del laberinto cambiando los valores en
la matriz para hacer sus pruebas.

#include <GL/glut.h>
#include <stdio.h>
#include <stdlib.h>
#define N 20
void cargaMatriz(int matriz[N][N]);
void pared(int x, int y, int r, int g, int b);
void estado(int x, int y, int tX, int tY);

int matriz[N][N];
int inicio[2] = {0,0};// el inicio estar en el origen del laberinto
int salida[2] = {N-1,N-1}; //la salida estar en la esquina que se encuentra en la diagonal
int tx = 0;
int ty = 0;
void display() //Funcion de dibujado
{
int i;
int j;
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
if (matriz[i][j] == 1)
pared(j,i,0,0,0);
else
pared(j,i,1,1,1);
}
}
/**en esta parte deben insertar el estado en el que se encuentran y cuyas coordenadas corresponden
al vector de traslacin
cada vez que se llegue a un nuevo estado valido**/
/**==============================================================**/
estado(inicio[0],inicio[1], tx,ty);/**============================**/
/**==============================================================**/

glFlush(); //Forza el limpiado de pantalla

}
void init()
{
glClearColor(1.0,1.0,1.0,0.0); //Limpiar Pantalla
}
void reshape(int width, int height)
{
glClear(GL_COLOR_BUFFER_BIT); //Buffer
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION); //Genera proyeccion
glLoadIdentity();
glOrtho(0.0,N,0.0,N,-1.0,1.0); //Perspectiva
glMatrixMode(GL_MODELVIEW); //Tipo de Proyeccion
}

int main(int argc, char ** argv)

{
cargaMatriz(matriz);//se llena la forma del laberinto mediante una matriz binaria
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //Funcion Main
glutInitWindowPosition(100,100); //Posicion de Ventana
glutInitWindowSize(500,500); //Cambiar Tamao de Ventana
glutCreateWindow("Inteligencia Artificial - Laberinto - Instituto Tecnologico de Oaxaca"); //Crea y
cambia el nombre de la ventana
glutDisplayFunc(display); //Funcion de Dibujado anteriormente creada
glutReshapeFunc(reshape);
glutMainLoop(); //Loop
return 0;
}
void cargaMatriz(int matriz[N][N])
int i = 0 ;
int j = 0 ;
int matriz1[N][N] = { //el laberinto est dado por una mtriz binaria en donde 0 indica que es un /
//pasillo y 0 que es un muro.
{0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,1},
{0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1},
{0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0},
{1,1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1},
{0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0},
{1,1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0},
{0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0},
{0,1,0,1,0,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1},
{0,1,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0},
{1,1,1,1,0,1,1,1,0,1,0,0,0,0,1,0,0,0,1,0},
{0,0,0,0,0,1,0,1,0,0,0,1,1,0,1,0,1,1,1,0},
{0,1,1,1,1,1,0,1,0,1,1,1,1,0,0,0,1,0,0,0},
{0,1,0,0,0,1,0,1,0,0,1,1,1,1,1,1,1,0,1,1},
{0,1,1,1,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0},
{0,0,0,0,0,1,0,1,1,1,1,0,1,1,1,1,1,1,1,0},
{0,1,1,1,1,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0},
{0,0,0,0,0,1,0,1,0,1,0,1,1,0,1,0,1,0,1,1},
{0,1,1,1,0,1,0,1,0,1,0,1,1,0,1,0,1,0,0,0},
{0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,1,1,1,0}
};
for (i = 0 ; i< N; i ++)
for (j = 0 ; j< N; j ++)
{
matriz[j][i] = matriz1[j][i];
}
}
void pared(int x, int y, int r, int g, int b)
{
glBegin(GL_QUADS); //Modelo a Dibujar
glColor3f(r,g,b);
glVertex3f(x,y,0.0);
glVertex3f(x + 1,y,0.0);
glVertex3f(x + 1,y + 1,0.0);
glVertex3f(x,y + 1,0.0);
glEnd(); //Finaliza el dibujo
}
void estado(int x, int y, int tX, int tY)
{
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
glColor3f(1.0,0.0,0.0);
glPointSize(10.0f);
glBegin(GL_POINTS);
glVertex2f(x +0.5 + tX,y + 0.5 +tY);
glEnd();
glTranslatef(tX,tY,0.0f);
glPopMatrix();
}

Figura 2. Laberinto generado mediante la matriz binaria.

En la figura el punto rojo representa la posicin actual en el recorrido del laberinto.

El estado inicial est dado en la posicin 0,0 del laberinto, aunque puede ser en cualquier lugar donde
exista un pasillo; mientras que la salida estar en la posicin 19,19 (o cualquier ponto en donde exista un
pasillo).
Objetivos.
a) -Realiza el anlisis correspondiente al problema para la bsqueda del camino que nos dirija a la
salida a partir del punto inicial.
b) -Determina la forma de los estados y las reglas que determinarn el comportamiento y las
restricciones.
c) -Implemente el algoritmo de bsqueda primero en profundidad para encontrar la solucin. Por
cada uno de los estados validos que se visiten el punto rojo debe moverse, es decir, se podr
visualizar como se hace la bsqueda hasta encontrar la salida. OJO, no slo la solucin se
mostrar sino todos los estados visitados, (cada vez que se inserte/elimine un nodo en la pila debe
verse el cambio de posicin).
d) -Realizar el reporte correspondiente.
La evaluacin se har con una matriz desconocida, as que no tiene caso hacer el algoritmo para
que funcione con la matriz dada en el cdigo de arriba en especfico, debe funcionar con cualquier
configuracin.

Problema de Graficacin.
Utilizando las libreras, los algoritmos desarrollados en clase, desarrolla:
Una aplicacin grafica (NO GLUT, OPENGL) que sea capaz de dibujar un polgono regular en el centro
de la pantalla (origen de los ejes cartesianos, para poder manejar coordenadas negativas).
Consideraciones.
Uso del teclado:
Se usarn dos teclas para aumentar o disminuir el nmero de lados del polgono (al iniciar el programa
debe dibujarse por default un tringulo por ser el polgono de menor nmero de lados); selecciona dos
teclas (a tu gusto), una para aumentar el nmero de lados y otra para disminuirlos.
Se usarn cuatro teclas para realizar la traslacin del polgono por toda la pantalla (pueden ser las teclas
de direccin), al presionar la tecla correspondiente a una direccin, sta deber afectar al vector de
traslacin que es aplicado a las coordenadas del polgono, logrando as su traslacin.
Se usarn dos teclas para realizar la rotacin del polgono (a tu gusto), dicha rotacin se har sobre el
centro del polgono no desde el origen de los ejes, tengan cuidado de no perder el centro de la figura al
realizar las operaciones traslaciones.
Se usarn dos teclas para realizar la operacin de escalado (una para el escalado positivo y otra para el
negativo, el factor de escalamiento por cada vez que se presione la tecla puede ser de 0.5 en los dos ejes
para tener un escalado uniforme), OJO utilizar la funcin de escalado que evita el efecto de traslacin,
es decir el escalado tendr como punto de referencia el centro del polgono.
Nota. Todos los procedimientos, dibujado de la lnea, clculo de los vrtices del polgono, clculos
de las transformaciones geomtricas, deben estar programadas en funciones separadas y deben ser
propias. El programa no pedir nada al usuario, al iniciar se presentara un tringulo en el centro
de la pantalla y dependiendo de la tecla que se presione se deber ver el cambio de este
inmediatamente ya sea al modificar sus lados o al aplicarle una transformacin.
Evaluacin: programa corriendo y reporte escrito (pdf).