Tecnológico de Estudios Superiores de Valle de

Bravo

Ingeniería en Sistemas Computacionales

Inteligencia Artificial
ABP UNIDAD 1
Catedrático: Dr. en I.S.C. Luis Alberto León Bañuelos

Alumno (s): José Miguel Suarez Estrella.

Carolina Malavez Hernández.
Edgar Raúl Ceballos Avila.

Grupo: 801
Ciclo escolar: FEBRERO 2024 - Agosto 2024.
INDICE GENERAL
..............................................................................................................................................................1
COMPETENCIAS:.............................................................................................................................3
COMPETENCIA EPECIFICA DE LA ASIGNATURA...................................................................3
COMPETENCIAS PREVIAS............................................................................................................3
Introducción........................................................................................................................................3
Problemática.......................................................................................................................................4
Teoría..................................................................................................................................................4
Corrida de escritorio..........................................................................................................................4
Código fuente.....................................................................................................................................7
Capturas de ejecución......................................................................................................................9
..............................................................................................................................................................9
REFERENCIAS.................................................................................................................................11

INDICE ILUSTRATIVO

Ilustración 1 resultado de corrida....................................................................................................6

Ilustración 2 Importar librerías y clases en ventana.............................................................................7
Ilustración 3 panel principal y casillas.................................................................................................7
Ilustración 4 camino más corto............................................................................................................8
Ilustración 5 restaurar ventana.............................................................................................................8
Ilustración 6 ejecución..........................................................................................................................9
Ilustración 7 cambio de matriz.............................................................................................................9
Ilustración 8 inicio y final..................................................................................................................10
Ilustración 9 se colocan los espacios..................................................................................................10
Ilustración 10 seleciona iniciar y se da el camino mas corto.............................................................11
COMPETENCIAS:

COMPETENCIA EPECIFICA DE LA
ASIGNATURA
Definir, diseñar, construir y programar las fases del analizador léxico y sintáctico
de un traductor o compilador

COMPETENCIAS PREVIAS
Analiza los componentes y la funcionalidad de sistemas de comunicación para
evaluar las tecnologías actuales como parte de la solución de un proyecto de
conectividad

Introducción
El algoritmo A* es un algoritmo de búsqueda clasificado dentro de los Algoritmos
de búsqueda en grafos. Utiliza el coste real del recorrido y el valor heurístico de
los nodos.
Presentado por primera vez en 1968 por Peter E. Hart, Nils J. Nilsson y Bertram
Raphael.
Se basa en una función de evaluación:
f(n) = h(n) + g(n)
Donde:
 h(n) es la distancia (coste) al nodo n (actual) y
 g(n) es la distancia (coste) al nodo meta.
Además, hace uso de dos listas de Nodos, una abierta y otra cerrada. En la
abierta se guardan los nodos potenciales para el camino óptimo y la cerrada
contiene los Nodos ya utilizados.

Problemática
Se pretende implementar el algoritmo A* de manera que el usuario pueda elegir el número
de la matriz bidimensional desde donde comienza la partida y donde termina, así como
marcar los obstáculos para darle mayor dinamismo. Los requisitos son que siempre llegue
al destino con el menor costo posible, que tenga solución y que sea dinámico
Teoría
Para resolver la problemática se tendrá como interfaz un panel que contenga botones que
actúen como casillas que cuando se activen pinte de rojo representando obstáculos que
estén apagados camino colores diferentes inicio y final,
Para que esto sea dinámico se tendrá for que genera botones con nombre seriados para
poder nombrar obstáculos caminos inicios y final, así como pedirle a usuario que active
botones con la función onclic y que coloque el numero de la casilla siguiendo el siguiente
patrón columna fila para inicio y fila columna para fin comenzando el conteo desde 0,0
Para el conteo del costo le daremos a cada nodo (casilla) un valor de columna de fila y de
coste que será 1 para todos que el algoritmo compare costo con vecinos para garantizar
que tomará el recorrido con menos costo esto con ayuda de un for que cada que entre en
el ciclo compare con los nodos vecinos.
Por último, al saber que camino es el mas viable dibujarlo pintando los botones de otro
color cabe resaltar que se puede mover de manera horizontal perpendicular y lateral

Corrida de escritorio
1. Creación del objeto Algoritmo_A_Estrella:
o Se crea un objeto de la clase Algoritmo_A_Estrella pasando un
objeto Mapa y un objeto InterfazHeuristica al constructor.
2. Llamada a calcularCaminoMasCorto:
o Se llama al método calcularCaminoMasCorto pasando las coordenadas
de inicio, las coordenadas de fin y un mapa de obstáculos.
o Este método configura la localización inicial y final en el mapa y
establece el mapa de obstáculos.
o Luego, realiza la búsqueda A* para encontrar el camino más corto.
3. Bucle principal del algoritmo A*:
o Mientras la lista abierta no esté vacía, se obtiene el primer nodo de la
lista (el nodo con la menor distancia desde el inicio).
o Si este nodo es el nodo final, se reconstruye el camino desde este
nodo hasta el nodo inicial y se devuelve.
o Si no, se elimina este nodo de la lista abierta, se añade a la lista
cerrada y se procesan todos sus vecinos.
4. Procesamiento de los vecinos:
o Para cada vecino del nodo actual, si el vecino está en la lista cerrada
o es un obstáculo, se ignora.
o Si no, se calcula la distancia desde el inicio hasta el vecino a través
del nodo actual.
o Si el vecino no está en la lista abierta, se añade a la lista.
o Si la nueva distancia es menor que la distancia anterior del vecino,
se actualiza la distancia del vecino y se establece el nodo actual
como el nodo anterior del vecino.
5. Reconstrucción del camino:
 o Una vez que se ha encontrado el nodo final, se llama al
método reconstruirCamino para obtener el camino desde el nodo inicial
hasta el nodo final.
o Este método sigue los nodos anteriores desde el nodo final hasta el
nodo inicial, añadiendo cada nodo al principio del camino.
6. Impresión del camino:
o Finalmente, se llama al método pintarCamino para imprimir el camino
más corto en la consola.

EJEMPLO

1. Inicialización:
o Crear una matriz de 7x7 para representar el entorno.
o Colocar el punto de inicio ‘S’ en la posición (0,0).
o Colocar el punto final ‘E’ en la posición (6,0).
o Generar posiciones aleatorias para los obstáculos ‘X’, asegurándose
de que no estén en los puntos de inicio o final.
2. Representación del Entorno:
o El entorno inicial podría verse así (los obstáculos son aleatorios):

Ilustración 1 entorno

3.Ejecución del Algoritmo A*:

o El algoritmo comienza en el punto de inicio y evalúa los nodos

vecinos.
o Se calcula el costo ‘G’ (distancia desde el inicio) y el costo ‘H’
(heurística hasta el final) para cada nodo.
o Se añaden los nodos a una lista abierta y se selecciona el nodo con
el menor costo ‘F’ (G + H).
 o Se repite el proceso hasta llegar al punto final o hasta que la lista
abierta esté vacía.

3.Ejecución del Algoritmo A*:

o El algoritmo comienza en el punto de inicio y evalúa los nodos

vecinos.
o Se calcula el costo ‘G’ (distancia desde el inicio) y el costo ‘H’
(heurística hasta el final) para cada nodo.
o Se añaden los nodos a una lista abierta y se selecciona el nodo con
el menor costo ‘F’ (G + H).
o Se repite el proceso hasta llegar al punto final o hasta que la lista
abierta esté vacía.

5.Construcción del Camino:

o Una vez que se llega al punto final, se reconstruye el camino desde

el punto final hasta el punto de inicio siguiendo los nodos previos.
o El camino resultante se marca con ‘*’, indicando la ruta encontrada.

6.Resultado Final:

 El entorno con el camino encontrado podría verse así:

Ilustración 2 resultado de corrida

Código fuente
Pantalla principal del programa
Se importan las librerías y las clases y el constructor.
 Ilustración 3 Importar librerías y clases en ventana

Se crea el método panel principal y el método casillas

Ilustración 4 panel principal y casillas

Método para el camino mas corto.

 Ilustración 5 camino más corto

Método para restaurar ventana

Ilustración 6 restaurar ventana

Capturas de ejecución
El programa ejecuta con un tamaño predeterminado se puede cambiar en el lado inferir
derecho
 Ilustración 7 ejecución

Así es como se debe de cambar la matriz

Ilustración 8 cambio de matriz

Colocamos y final
 Ilustración 9 inicio y final

Colocamos los obstáculos

Ilustración 10 se colocan los espacios

Damos en iniciar y dará el recorrido más corto

 Ilustración 11 selecciona iniciar y se da el camino más corto

REFERENCIAS
1. YouTube: Algoritmo A (estrella) en HTML5 y JavaScript:
https://www.youtube.com/watch?v=NWS-_VsMab4*
2. Graph Everywhere: Algoritmos de grafos - Detección de rutas más cortas:
https://www.grapheverywhere.com/algoritmo-a/
3. Stack Overflow: A Algorithm Questions:
https://stackoverflow.com/questions/tagged/a-star
4. "Artificial Intelligence: A Modern Approach" (4th Edition) by Stuart Russell
and Peter Norvig.
5. ALGORTIMO A*. (n.d.). Retrieved from
https://nlaredo.tecnm.mx/takeyas/apuntes/Inteligencia%20Artificial/
Apuntes/tareas_alumnos/A-Star/A-Star(2005-II-A).pdf