Propuesta del tema

Laberintos

BFS(Breadth First Search – Busqueda por Anchura)

BFS va formando un árbol a medida que va recorriendo un grafo, si se observa bien toda parte de un nodo inicial que será la raíz del árbol que se forma, luego ve los adyacentes a ese nodo y los agrega en una cola, como la prioridad de una cola es FIFO (primero en entrar es el primero en salir), los siguientes nodo a evaluar serán los adyacentes previamente insertados, una cosa bastante importante es el hecho de que no se pueden visitar dos veces el mismo nodo ya que si no se podría terminar en un ciclo interminable o simplemente no hallar el punto deseado en el menor número de pasos.

Un recorrido en anchura se refiere a recorrer un grafo por niveles, es decir, partiendo de un nodo inicial recorro todos sus vecinos, posteriormente los vecinos de los vecinos hasta que todos los nodos hayas sido visitados.

BFS(Breadth First Search – Busqueda por Anchura)

Este algoritmo de grafos es muy útil en diversos problemas de programación. Por ejemplo, hallar la ruta más corta cuando el peso entre los nodos es 1, cuando se requiere llegar con un movimiento de caballo de un punto a otro con el menor número de pasos, cuando se desea transformar algún número o cadena en otro realizando ciertas operaciones como suma producto, pero teniendo en cuenta que no sea muy grande el proceso de conversión o para salir de un laberinto con el menor número de pasos.

uno esperaría que hables de laberintos primero y luego expliqués qué tiene que ver todo esto con laberintos

Versión entregada en 1ra oportunidadCONTENIDO COPIADO; CERO PUNTOS

Modelado del problema

Tenemos una matriz de caracteres que representa un laberinto 2D un # implica muro, un implica un espacio libre un I indica la entrada del laberinto y una S indica la salida.

¿Cuánto mide la ruta más corta para escapar?

lo relevante no es cuánto mide sino cuál es

Solución:

El problema nos da un Estado inicial y final, en este caso “I” y “S”, nos pide el menor número de pasos para ir de “I” a “S” tomando en consideración que solo podremos avanzar por los “.”

Dicha la descripción anterior, el problema puede ser resulto por BFS al tener un estado inicial y final eh ir avanzando por algún adyacente que no sea “#”. Los posibles adyacentes para movernos son hacia arriba, abajo, izquierda y derecha, suponiendo que estamos en la posición (x, y) tendríamos:

X + 0, Y + 1

X + 0, Y – 1

X + 1, Y + 0

X – 1, Y + 0

X – 1, Y

X, Y - 1 X, Y X, Y + 1

X + 1, Y

El camino encontrado por el procedimiento anterior tiene una propiedad importante: ningún otro camino desde el inicio a la salida pasa por menos casillas. Eso es porque usamos un algoritmo llamado búsqueda en anchura para encontrarlo. La búsqueda en anchura, también conocida como BFS(breadth-first search en inglés), encuentra los caminos más cortos desde un vértice de origen dado a todos los demás vértices, en términos del número de aristas en los caminos.

La búsqueda en anchura es otro procedimiento para visitar sistemáticamente todos los vértices de un grafo. Es adecuado especialmente para resolver problemas de optimización, en los que se deba elegir la mejor solución entre varias posibles. Al igual que en la búsqueda en profundidad se comienza en un vértice v (la raíz) que es el primer vértice activo. En el siguiente paso se etiquetan como visitados todos los vecinos del vértice activo que no han sido etiquetados. Se continúa etiquetando todos los vecinos de los hijos de v (que no hayan sido visitados aún). En este proceso nunca se visita un vértice dos veces por lo que se construye un grafo sin ciclos, que será un árbol generador de la componente conexa que contiene a v.

se está poniendo repetitivo esto; ya explicaste BFS al inicio

las instrucciones dicen CLARAMENTE no NO SE PERMITE COPIAR texto o el proyecto va a valer cero puntos

esto lo tomaste tal cual de http://docencia.udea.edu.co/regionalizacion/teoriaderedes/informaci%F3n/C3_Profundidad.pdf

Instancia con datos verdaderos

La búsqueda en anchura supone que el recorrido se haga por niveles. Para entender más fácilmente de que se trata, hemos indicado en la siguiente imagen un grafo ejemplo en donde cada color representa un nivel, tomando como raíz o nodo inicial el que tiene el número 1. El recorrido se hará en orden numérico de forma consecutiva hasta llegar al nodo número 7.

La estrategia que usaremos para garantizar este recorrido es utilizar una cola que nos permita almacenar temporalmente todos los nodos de un nivel, para ser procesados antes de pasar al siguiente nivel hasta que la cola esté vacía.

queue<State> q;

q.push(State(raiz));

mark[raiz] = true;

Inmediatamente después de declarar nuestra estructura de cola, agregamos el nodo raíz para poder iniciar el proceso de búsqueda. Esto se hace porque necesitamos tener al menos un elemento en nuestra cola, dado que la condición de salida es que la cola esté vacía. Luego marcamos el nodo raíz como visitado.

while(!q.empty())

{

State st = q.front();

q.pop();

if (st.node == nodo){

printf("'%d'n",nodo);

return;

}else printf("%d ",st.node);

int T = (int)graph.G[st.node].size();

for(int i = 0; i < T; ++i)

{

if (!mark[graph.G[st.node][i].node])

{

mark[graph.G[st.node][i].node] = true;

q.push(State(graph.G[st.node][i].node));

}

}

}

Cada vez que visitamos un nodo, lo desencolamos e imprimimos por pantalla el valor del nodo para ir indicando el recorrido. Luego agregamos a la cola todos los nodos del siguiente nivel y los marcamos como visitados antes de comenzar el

esto lo tomaste de http://www.bibliadelprogramador.com/2014/04/algoritmos-de-busqueda-en-anchura-bfs-y.html

ciclo de nuevo, en el que procesaremos estos nuevos nodos que hemos agregado a la cola. Si encontramos el elemento buscado, la función BFS retornará al “main” e imprimirá entre comillas simples el valor del elemento buscado. Podríamos hacer otro tipo de mensaje para indicar que el elemento ha sido encontrado, calcular el número de nodos que fueron visitados o incluso generar un mensaje especial en el caso de que el elemento no haya sido encontrado. Por el momento la función ha quedado lo más sencilla posible para enfocarnos únicamente en cómo hacer el recorrido.

Diseño de la solución propuesta

De acuerdo con el laberinto mostrado en la parte superior se diseñó un pseudocódigo para dar la solución del laberinto.

• Algoritmo en pseudocódigo • 1 método BFS(Grafo,origen): • 2 creamos una cola Q • 3 agregamos origen a la cola Q • 4 marcamos origen como visitado • 5 mientras Q no este vacío: • 6 sacamos un elemento de la cola Q llamado v • 7 para cada vértice w adyacente a v en el Grafo: • 8 si w no ha sido visitado: • 9 marcamos como visitado w • 10 insertamos w dentro de la cola Q

esto lo tomaste de https://codebreakerscorp.wordpress.com/2010/12/06/algoritmo-de-busqueda-breadth-first-search/

es pura trampa este proyecto; muy deshonesto de tu parte

Implementación

Así por ejemplo si se está en la siguiente posición y suponiendo que se la coordenada 3,4

Los posibles Estados adyacentes serian: izquierda (3,2 -> “.”), derecha (3,5 -> “.”), arriba (2,4 -> “#”) y abajo (4,4 -> “#”) por lo tanto para ese caso solo podríamos avanzar por la derecha o izquierda.

La solución la explicaremos paso a paso en el lenguaje C++, para otros lenguajes como Java es bastante similar.

Primeramente, declaramos nuestro laberinto como una matriz, también declaramos un arreglo de Visitado que nos indicará si se visitó o no un estado determinado:

#define MAX 100 //máximo número de filas y columnas del laberinto char ady[MAX][MAX]; //laberinto bool visitado[MAX][MAX]; //arreglo de estados visitados Para la función BFS, la entrada que se recibe es el punto inicial de donde deseamos a partir y el punto de llegada, en este ejemplo el punto de llegada esta representado por S por lo que es necesario pasarlo como parámetro. El valor inicial cuando trabajamos con dos dimensiones es necesario la fila y columna inicial, además tenemos que pasar la altura y el ancho del laberinto para controlar los limites de recorrido estos podemos declararlos globales si se desea. int BFS(int x , int y, int h, int w) //coordenadas de inicial "I" y dimensiones de laberinto

Cada vez que trabajamos con BFS trabajamos con estados, desde un estado inicial podemos llegar al estado final por medio de varios estados, por ello una forma de manejar los diferentes estados y los valores que se tiene hasta ese estado podemos realizar una estructura estado que contendrá la posición del estado determinado, así como otros atributos, uno necesario es la distancia en dicho estado

esto lo tomaste de https://codebreakerscorp.wordpress.com/2010/12/06/algoritmo-de-busqueda-breadth-first-search/

struct Estado { int x; // Fila del estado int y; // Columna del estado int d; // Distancia del estado Estado (int x1 , int y1 , int d1) : x(x1), y(y1), d(d1){} // Constructor }; Respecto a lo anterior otra forma para hallar las distancias sería ir almacenando en un arreglo de distancias. Declaramos nuestro estado inicial:

Estado inicial(x,y,0) ; //Estado inicial, distancia = 0 Ahora para realizar un BFS es necesario la estructura de datos Cola, la cual pondemos implementar por medio de arreglos o simplemente usar la estructura ya implementada de las librerias de C++ (queue) o Java(Queue):

queue<Estado> Q; //Cola de todos los posibles Estados por los que se pase para llegar al destino Q.push(inicial); //Insertamos el estado inicial en la Cola. Nuestro arreglo de visitados es necesario inicializarlo como no visitado inicialmente:

memset(visitado, false, sizeof(visitado)); //marcamos como no visitado Ahora a partir de la inicial comprobamos si se llegó al destino, en caso sea verdadero retornamos la distancia recorrida hasta ese momento, de otro modo empezamos a evaluar los adyacentes y agregarlos a la cola. Para evaluar los adyacentes se explicó anteriormente que son dados en 4 direcciones ello se puede expresar de la siguiente manera:

int dx[4] = {0, 0, 1, -1 }; //incremento en coordenada x int dy[4] = {1, -1, 0, 0 }; //incremento en coordenada y Estos valores serán usados para aumentar al estado actual y ver su adyacente, esto se explicó anteriormente en la gráfica ejemplo de recorrido.

Haremos todo este proceso descrito anteriormente mientras la cola no esté vacía:

while( !Q.empty() ){ //Mientras cola no esté vacía Estado actual = Q.front(); //Obtengo de la cola el estado actual, en un comienzo será el inicial Q.pop(); //Saco el elemento de la cola if( ady[actual.x][actual.y]== 'S'){//Si se llegó al destino (punto final)

aquí hay puras cosas copiadas, no hay nada que valga puntos

return actual.d; //Retornamos distancia recorrida hasta ese momento } visitado[actual.x][actual.y]=true; //Marco como visitado dicho estado para no volver a recorrerlo for( int i = 0; i < 4; i++){ //Recorremos hasta 4 porque tenemos 4 posibles adyacentes int nx = dx[i] + actual.x; //nx y ny tendran la coordenada adyacente int ny = dy[i] + actual.y; //ejemplo en i=0 y actual (3,4) -> 3+dx[0]=3+0=3, 4+dy[0]=4+1=5, nueva coordenada (3,5) //aqui comprobamos que la coordenada adyacente no sobrepase las dimensiones del laberinto //ademas comprobamos que no sea pared "#" y no esté visitado if(nx>=0 && nx<h && ny>=0 && ny<w && ady[nx][ny]!='#' && !visitado[nx][ny]){ Estado adyacente (nx, ny, actual. d+1); //Creamos estado adyacente aumento en 1 la distancia recorrida Q.push(adyacente); //Agregamos adyacente a la cola } } }

Finalmente, si no se pudo llegar al destino retornamos un valor que el problema comúnmente nos da en este caso podemos retornar -1.

Evaluación

Des pues de haber realizado diferentes tipos de propuesta para la resolución del laberinto, de modo que la solución dada anteriormente fue la mejor, ya que de esta manera el laberinto de soluciono de manera rápida y fácil. se sugirieron ideas tecnológicas de las funciones que se podría dar al pseudocódigo, una de ellas fue la idea de elaborar un dron de búsqueda y rescate, al igual que para el diseño y fabricación de videojuegos o simplemente juegos en línea o aplicaciones móviles para entretenimiento de personas, entre otras cosas.

Al igual el pseudocódigo desarrollado solo es para la solución del laberinto, pero dado a los grafos y a la búsqueda de anchura, se pueden llegar a crear drones de rescate, de búsqueda, aplicaciones entre otras cosas

Revisión de literatura

http://programandoandojs.blogspot.mx/2013/08/recorrido-en-anchura-y-en-profundidad.html

http://elisa.dyndns-web.com/teaching/mat/discretas/md.html

https://es.slideshare.net/ChernandezQ/recorrido-de-anchura

http://elvex.ugr.es/decsai/algorithms/slides/5%20Grafos.pdf

https://jorgecontrerasp.wordpress.com/unidad-iii/busquedas-en-anchura-y-profundidad/

https://es.wikipedia.org/wiki/B%C3%BAsqueda_en_anchura

https://desarrolloweb.com/articulos/recorrido-anchura-arbol-binario-java.html

http://usandojava.blogspot.mx/2012/02/escribiendo-y-leyendo-en-un-archivo-de.html

http://users.dsic.upv.es/~nprieto/clases/EDA0708/Grafos/SolucionEjercicios.pdf

la bibliografía carece formato

NO HICISTE NADA MÁS QUE COPIAR COSAS DE PÁGINAS

ESTE PROYECTO VALE CERO PUNTOS

Laberintos

Un laberinto suele ser un pasatiempo gráfico, que consiste en trazar una línea desde un punto de origen, situado en el exterior del laberinto a un destino situado generalmente en el centro o en el lado opuesto al del inicio.

Su dificultad consiste en encontrar un camino corto y directo que llegue hasta el final, el centro o el otro extremo del laberinto.

Las configuraciones del laberinto contienen diferentes vías sin salida y solo un recorrido correcto, es un lugar formado por calles, paredes y encrucijadas, intencionalmente complejo para confundir a toda persona que se disponga a realizar su solución le resulte confuso e imposible de hallar la salida. Los laberintos tienen diferentes formas en que pueden mostrarse ya sea un cuadrado, ovalo, redondos, cuadrangulares, con figuras de personajes entre otras formas.

Búsqueda por profundidad

Es un algoritmo de búsqueda no informada utilizado para recorrer todos los nodos de un grafo 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 de modo que repite el mismo proceso con cada uno de los hermanos del nodo ya procesado.

ENTREGADA TARDE PARA 2DA OP.

no se respetan los apartados de las instrucciones

imagen tomada de https://userscontent2.emaze.com/images/3094b6ea-0fd9-4a72-8cb1-b8e617f185d1/8298146b549c2aec985bd5bd819ff2bc.png

NO SE PUEDE copiar cosas y luego no indicar claramente de dónde son, eso es PLAGIO

Versión entregada en 2da oportunidadCONTENIDO COPIADO; CERO PUNTOS

Relaciona de la búsqueda por profundidad y los laberintos.

Este algoritmo de grafos es muy útil en diversos problemas de programación. Por ejemplo, hallar la ruta mas corta cuando el peso entre los nodos es uno, cuando se requiere llegar con un movimiento de caballo de un punto a otro con el menor número de pasos, cuando se desea transformar algún numero o cadena en otro, realizando ciertas operaciones como suma producto, pero teniendo en cuenta que no sea muy grande el proceso de conversión o para salir de un laberinto con el número menor de pasos.

Su funcionamiento consiste en ir expandiendo todos y cada uno de los nodos que va localizando, de una forma recurrente, un camino concreto. Cuando ya no quedan mas nodos que visitar en dicho camino, regresa de modo que repite el mismo proceso en cada uno de los vecinos del nodo ya procesados.

Modelado del problema

Para la realización de una búsqueda por profundidad se toma en cuenta un laberinto 2D

Simbología

1- Paredes 0- calles E- entrada S- salida 8- ruta más corta

111111111111111111 100000001100000111 101110100101110101 100010111100010001

E00101000001011100S 101000111101000111 101010101101010101 101010001101010001 101011101101011101 100000000100000001 111111111111111111

falta indicar con referencias de dónde se está sacando la información

¿Cuál es la ruta más corta para escapar?

Para dar una solución al problema es fundamental para la mayoría de las aplicaciones de inteligencia artificial. La capacidad para resolver problemas suele usarse como una medida de la inteligencia tanto para el ser humano como para la computadora. Existen dos clases de problemas, una primera clase puede ser resuelta usando algún tipo de procedimiento determinista cuyo existo este garantizado, a este proceso se le llama de computación. La solución por computadora normalmente solo se aplica a aquellos tipos de problemas para los que existan tales procedimientos como en matemáticas. Se puede con frecuencia traducir los métodos usados para resolver estos problemas de manera fácil, a un algoritmo que pueda ser ejecutado por una computadora.

Por ejemplo, en el laberinto de arriba hay que encontrar la salida de este. Se sabe que la salida esta al otro extremo del laberinto.

La E indica la entrada o donde se encuentra el robot. Al empezar la búsqueda primero comprueba si tiene el camino libre, y como ha avanzado se observa si puede seguir avanzando o no. Si este sigue avanzado el laberinto se puede tomar con los ejes x y y al ser así se le puede ir sumando o restando pasos al robot y decir si sube, baja retrocede o sigue de frente hasta encontrarse con una pared o una calle sin salida. Como aún no ha encontrado la salida S debe de segur andando hasta encontrarla.

El hecho que se pueda representar la solución a esta clase de problemas en forma de grafo es importante, ya que ofrece una forma sencilla de observar como funcionan las diferentes técnicas de búsqueda.

Para una solución de este laberinto hay que tener en cuenta lo siguiente

Un estado, es la representación de un problema en un instante dado. Para definir el espacio de estados o espacio de búsqueda no es necesario hacer una exhaustiva numeración de todos los estados válidos, sino que es posible definirlo de manera más general.

El estado inicial consiste en uno o varios estados en los que puede comenzar el problema. El estado objetivo o estado meta consiste en uno o varios estados finales que se consideran solución aceptable.

Las reglas describen las acciones u operaciones que posibilitan un pasaje de estados. Se podría decir una regla tiene una parte izquierda y una derecha. La primera determina la aplicabilidad de la regla, es decir, describe los estados a los que puede aplicarse la regla. Mientras que la segunda describe la operación que se lleva acabo si se aplica la regla.

texto amarillo copiado de http://www.unistmo.edu.mx/~daniel.garcia/unidadiii_ia.pdf

La heurística es la información acerca de la posibilidad de que un nodo especifico sea mejor para intentar la próxima elección que cualquier nodo.

El camino solución es el grafo dirigido de los nodos visitados que nos llevan a la solución.

Espacio de estados. La totalidad de tableros que se puede generar en el laberinto.

Estado inicial. El tablero 11 x 18 donde cada cuadro tiene una pared marcada con un 1 o una calle con un 0.

Objetivo o estado final. La salida del laberinto marcada con una S

Regla. Son los movimientos legales, que pueden realizarse dentro del laberinto mediante una parte patrón para ser contrastado con la posición actual del tablero y otra parte que describa el cambio que debe producirse en el tablero. Dado que describe todas las posiciones del tablero, las reglas deben escribirse de manera más general posible.

Heurística. Se puede elegir el tablero en donde se tenga el menor numero de pasos

Camino solución. El conjunto de movimientos para llegar al estado final.

La búsqueda de una solución no es tan simple como empezar en el principio y seguir su camino hasta su conclusión.

Para la solución del laberinto se elaboro un algoritmo para su solución.

Su análisis es el siguiente

El código se empieza con las variables principales

Total- que se utilizara para contabilizar los pasos del camino mas corto hacia la salida.

Pasos- este se utilizará como registro del recorrido que se va efectuando a lo largo de todos los casos que se van analizando en el algoritmo principal, y así evitando el paso por caminos ya recorridos.

Mapaorig- este es la matriz donde se encuentra la configuración original del laberinto a analizar.

Al igual que se usan dos funciones de apoyo.

Función alternativa. Esta se encarga de verificar los posibles movimientos a realizar según su dirección y obstáculos que se encuentren alrededor de la posición.

Dirección- orientación del movimiento actual

pobre estructuración de la redacción; frases fragmentadas

PosY- posición en el eje y

PosX- posición en el eje x

Pasos- registro con la trayectoria que se ha seguido en el movimiento actual, para evitar así el paso por zonas ya comprobadas.

Función cerrar camino- esta función se encarga de desactivar aquellos caminos que lleven a una zona sin salida

La dirección vine dada por los siguientes valores

1- Derecha 2- Izquierda 3- Arriba 4- Abajo

Dirección- orientación del movimiento actual

PosY- posición en el eje y

PosX- posición en el eje x

Tot- numero de movimientos

Pasos- los movimientos que se irán ejecutando, es necesario para evitar pasar por zonas ya comprobadas.

Ya una vez aclarado todo el algoritmo queda de esta forma

<? Variables principales $total = 0; $pasos = array(); $mapaOrig = array(); Cargar el laberinto y guardarlo en una matriz y así recorrerlo $lineas = file('./laberinto.txt'); $i = 0; while ($tupla = each($lineas)) { for ($j=0; $j<strlen($tupla[1]); $j++ ) {

código copiado de http://www.codigo-facil.com/es/salida-laberinto.php

if ($tupla[1][$j]=='0' || $tupla[1][$j]=='s' || $tupla[1][$j]=='1') $mapaOrig[$i][$j] = $tupla[1][$j]; } $i++; } Funciones que van a invertir en el algoritmo principal, se encargara de buscar posibles rutas según su dirección y obstáculos function alternativas($direccion,$posY,$posX,$pasos) { global $mapaOrig; $posib = array(); if ( $direccion!=4 && $posY>0 && !isset($pasos[($posY-1).'-'.$posX]) && $mapaOrig[$posY-1][$posX]==0) $posib[]=3; if ( $direccion!=3 && $posY<(count($mapaOrig)-1) && !isset($pasos[($posY+1).'-'.$posX]) && $mapaOrig[$posY+1][$posX]==0 ) $posib[]=4; if ($direccion!=1 && $posX>0 && !isset($pasos[$posY.'-'.($posX-1)]) && $mapaOrig[$posY][$posX-1]==0) $posib[]=2; if ( $direccion!=2 && $posX<(count($mapaOrig[$posY])-1) && !isset($pasos[$posY.'-'.($posX+1)]) && $mapaOrig[$posY][$posX+1]==0 ) $posib[]=1; return $posib; }

Esta función evita que el algoritmo evalué de nuevo esta posibilidad con el que se ahorra doble trabajo función cerrar Camino($posY,$posX) { global $mapaOrig; $posi = array(); if ($mapaOrig[$posY+1][$posX]==0) $posi[]=array(0=>($posY+1),1=>$posX); if ($mapaOrig[$posY-1][$posX]==0) $posi[]=array(0=>($posY-1),1=>$posX); if ($mapaOrig[$posY][$posX+1]==0) $posi[]=array(0=>$posY,1=>($posX+1)); if ($mapaOrig[$posY][$posX-1]==0) $posi[]=array(0=>$posY,1=>($posX-1)); if (count($posi)==1) { $mapaOrig[$posY][$posX] = 1; Cerrar Camino($posi[0][0],$posi[0][1]); } } Esta función se encarga de buscar diferentes salidas y asi obtener la ruta mas corta hacia la salida función salida($direccion,$posY,$posX,$tot,$pasos) { global $total,$mapaOrig; if ($tot>=$total && $total!=0)

return -1; else if ($mapaOrig[$posY][$posX]=='s') { if ($total==0 || $tot<$total) { global $pasosF; $pasosF = $pasos; $total=$tot; } return $tot; } else { $pasos[$posY.'-'.$posX]=2; $posib = alternativas($direccion,$posY,$posX,$pasos); if (!count($posib)) { Cerrar Camino($posY,$posX); return -1; } else { $caminos = array(); while ($tupla = each($posib)) { if ($tupla[1]==1) $caminos[] = salida($tupla[1],$posY,($posX+1),($tot+1),$pasos); if ($tupla[1]==2) $caminos[] = salida($tupla[1],$posY,($posX-1),($tot+1),$pasos); if ($tupla[1]==3) $caminos[] = salida($tupla[1],($posY-1),$posX,($tot+1),$pasos); if ($tupla[1]==4)

$caminos[] = salida($tupla[1],($posY+1),$posX,($tot+1),$pasos); } $valor=null; while ($tupla = each($caminos)) { if (($valor==null || $tupla[1]<$valor) && ($tupla[1]!=-1)) $valor = $tupla[1]; } if ($valor==null) $valor = -1; return $valor; } } } Se invoca la función principal $valor =salida(2,8,$pasos); ?>

¿Cuál es la ruta más corta para escapar?

Una vez realizado el algoritmo se obtiene la ruta mas corta para salir del laberinto

Simbología

1- Paredes 0- calles E- entrada S- salida 8- ruta más corta

111111111111111111 100000001188888111 101110100181118101 188810111180018881

E881818888881011188S 101888111101000111 101010101101010101 101010001101010001 101011101101011101 100000000100000001 111111111111111111

Al finalizar se obtiene la ruta mas corta de salir del laberinto y se obtiene que en 28 pasos se encuentra la salida del laberinto.

Evaluación

La búsqueda de una solución no es tan simple como empezar en el principio y seguir su camino hasta su conclusión. En este caso mas o menos simple de la salida de un laberinto, este método de búsqueda en una manera de llevarlo a cabo. Generalmente se usará una computadora para resolver problemas en los que el numero de nodos en el espacio de búsqueda sea muy grande. El algoritmo diseñado se podría modificar y usar en laberintos diseñados por una persona y se

obtendría la salida más rápida para salir de este. La inteligencia artificial se podría implementar en la solución de problemas y desarrollar drones de búsqueda y rescate para diferentes campos y así obtener una vista desde un ángulo distinto. Este algoritmo se podría modificar para hacer diferentes tipos de trabajos.

Bibliografía

Daniel Alejandro García López, INTELIGENCIA ARTIFICIAL, publicado el 19 de enero del 2009, http://www.unistmo.edu.mx/~daniel.garcia/unidadiii_ia.pdf

Jhosimar George Arias Figueroa, Algorithms and More, Blog about programming, Publicado el enero 1, 2013, https://jariasf.wordpress.com/

Roberto J. de la Fuente López, INTELIGENCIA ARTIFICIAL. INTRODUCCION Y TAREAS DE BUSQUEDA, versión 20100619 http://aconute.es/iartificial/documentos/ia_intro_busqueda.pdf

Alejandro De J. López Ortegón, Esmeralda Zurita Gallegos, Cesar A. Pech Interian, Russel Chuc Aguilar, Alinda E. Chan May, Micaela Baas Dzul, TEORÍA DE GRAFOS, Publicado el 8 de diciembre del 2014, http://mate-discretasj2.blogspot.mx/

Julio J. Rubio García, INTELIGENCIA ARTIFICIAL E INGENIERIA DEL CONOCIMIENTO I, BUSQUEDA, v1.0, publicado el9 de noviembre de 1998, http://www.lsi.upc.es/~bejar/iia/iabusq.pdf

Fernando Segismundo Alonso Garzón, LABERINTOS, https://laberintos.weebly.com/bibliografiacutea.html

https://es.wikipedia.org/wiki/Laberinto_(pasatiempo)