Ejemplo: Solución de un Laberinto
Descripción
Se presenta un programa que resuelve laberintos en forma recursiva. El laberinto a resolver se representa mediante una matriz de números enteros, y su configuración está dada por la inicialización que se haga a dicha matriz. Por esto, para cambiar el laberinto será necesario cambiar el código del programa. Una vez que se haya introducido el concepto de archivo será posible ampliar este programa para que sea más útil, almacenando distintas configuraciones de laberinto en distintos archivos.
Diseño
A continuación se aplicará nuestra metodología para la solución de problemas para diseñar el programa mencionado. 1. Definición del problema Conceptualización: El problema se ubica en un contexto en el que se debe buscar una solución a un laberinto con una entrada y una salida, y con movimientos válidos en cuatro direcciones (no diagonales). En el caso de este ejemplo, el contexto está limitado a una aplicación de computador, en la que el laberinto está representado mediante una matriz de números enteros. Objetivo: Partiendo de la entrada del laberinto, señalar una ruta que nos guíe hasta la salida. Por ejemplo, dado el siguiente laberinto:
Una solución que nos permitiría alcanzar nuestro objetivo sería la ruta mostrada con asteriscos en la siguiente figura:
Descripción general de la solución: El problema se resolverá haciendo uso de la recursividad. La solución se basa en una tarea o función que se llamará recursivamente para intentar solucionar el laberinto a partir de una posición particular. Desde cualquier lugar dentro del laberinto se intentará resolverlo primero intentando hacia izquierda, luego a la derecha, luego arriba y finalmente abajo. Para hacer estos intentos se empleará la función recursiva. El procedimiento parte de la posición de entrada. Se utilizarán marcas que serán dejadas en el camino para no intentar por caminos por los que ya se pasó y, en particular, no volver atrás salvo si se determina que no hay solución por el camino que se sigue hasta ahora. Elementos involucrados: No existen elementos externos involucrados en la búsqueda de la solución. El único elemento activo es el computador en sí llevando a cabo su trabajo. En el problema participan también los siguientes elementos pasivos:
» la matriz que representa el laberinto » la ubicación de la entrada » la ubicación de la salida 2. Conceptualización de la solución Variables: Como se mencionó, el laberinto estará representado mediante una matriz de números enteros: lab. Además, la posición de la entrada en el laberinto estará dada por las coordenadas dentro de la matriz, representadas por las variables x0, y0, para la fila y la columna, respectivamente. De manera similar, la posición de la salida del laberinto se guardará en xf , yf Todas estas variables serán globales.
Cada posición de la matriz puede estar en uno de tres estados: • • •
parte del muro (ladrillo) camino libre no visitado camino libre visitado
En el programa en C, la declaración de las variables y constantes globales se hará de la siguiente manera: /* Constantes que definen la dimension del laberinto */ #define FILAS 13 #define COLUMNAS 21 /* Caracteres que se almacenan en las posiciones del laberinto:
*/
/* ASCII 219 es un cuadro relleno que se usa para las paredes */ /* ' ' es un espacio en blanco, para los caminos libres */ /* '*' es la marca que senala las posiciones visitadas (camino) */ #define L 219 #define E ' ' #define MARCA '*' /* Constantes logicas para valor de retorno de funciones */ #define TRUE 1 #define FALSE 0 /* Matriz global que representa el laberinto. En la inicializacion, */ /* L representa un ladrillo en la pared y E un espacio en blanco */ int lab[FILAS][COLUMNAS] = { { L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L }, { E, E, E, L, E, L, E, L, E, L, E, E, E, L, E, E, E, E, E, E, L }, { L, L, E, L, E, E, E, L, E, E, E, L, E, L, E, L, E, E, L, E, L }, { L, E, E, E, E, L, E, L, L, L, E, L, E, L, E, L, L, E, L, E, L }, { L, E, L, L, L, L, E, L, E, L, E, L, E, L, L, L, E, E, L, E, L }, { L, E, E, E, L, E, E, L, E, L, E, L, E, E, E, E, E, L, L, E, L }, { L, E, L, L, L, L, L, L, E, L, E, L, L, E, L, E, E, E, E, E, L }, { L, E, E, E, E, E, E, E, E, E, E, E, L, E, L, E, L, L, E, L, L }, { L, L, L, L, L, L, L, L, L, L, L, E, L, E, L, E, E, L, E, L, L }, { L, E, E, E, E, E, E, E, L, E, E, E, L, L, L, L, L, L, E, L, L }, { L, E, L, L, L, L, L, E, E, E, L, L, L, E, L, E, E, E, E, E, L }, { L, E, E, L, E, E, E, E, L, E, E, L, E, E, E, E, L, L, L, E, E }, { L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L } }; La inicialización de la matriz que aquí se muestra corresponde al laberinto presentado en la figura del inicio. Los caminos están formados de espacios libres (E's). Observe el contorno del laberinto, formado por L's, y los puntos de entrada y salida. En la implementación de las distintas subtareas se hace uso de otras variables locales, propias de la función de cada subtarea. Descomposición en Tareas: El problema global puede descomponerse en las siguientes tareas. Como las variables más importantes se manejan en forma global, no es necesario pasarlas como parámetros. Este es el caso de la variable lab, la matriz que representa el laberinto.
Cada una de las tareas aquí definidas se implementará como una función en el programa en C. Para una mejor comprensión, se incluye el código en C que corresponde a cada una de estas funciones.
valida Parámetros: fila y columna de la posición Valor de retorno: valor booleano que indica si la posición es válida Descripción: Esta función analiza una posición dentro del laberinto, especificada por la fila y columna recibidas como parámetro, y deduce si es una posición válida para recorrer. Básicamente debe verificar que no esté fuera de los límites del laberinto, que no se trate de una posición en la que hay pared, y que no se trate de una posición previamente visitada. Algoritmo: 1. Inicialmente resultado vale VERDADERO 2. Si la posición dada está fuera del laberinto 2.1. Cambiar resultado a FALSO 3. Si la posición dada es pared o ya fue visitada
3.1. Cambiar resultado a FALSO Código en C: int valida(int f, int c) { int resultado = TRUE; /* Se supone inicialmente valida */ /* Controla si la posicion esta fuera del laberinto */ if ((f<0) || (f>=FILAS) || (c<0) || (c>=COLUMNAS)) resultado = FALSE; /* Controla si la posicion ya fue visitada o es muro */ if (lab[f][c] == MARCA || lab[f][c] == L) resultado = FALSE; return(resultado); }
recorrer Parámetros: fila y columna (fil y col) desde donde se empieza el recorrido. Valor de retorno: TRUE o FALSE que indica si se logró resolver el laberinto o no. Descripción: Tarea recursiva que recorre el laberinto a partir de una posicion dada por la fila y columna pasadas como parametro y devuelve un valor booleano que indica si se logro llegar a la salida. El caso base de la recursividad (condicion de termino) es que las coordenadas correspondan con la salida del laberinto. En caso contrario, se procede a marcar la casilla y a intentar en las distintas direcciones (izquierda, derecha, arriba y abajo), asegurandose primero que en esa direccion haya una casilla valida (no ladrillo, no fuera del laberinto y no visitada). En caso en que ninguna direccion nos lleva a la salida, se desmarca la casilla actual (pues se va a retroceder) y se devuelve falso como valor de retorno. Las marcas sirven también para senalar la ruta que conforma la solucion, una vez alcanzada. Algoritmo: 1. Inicialmente listo vale FALSO 2. Se marca la casilla 3. Si la posición es el fin del laberinto 3.1. Retornar VERDADERO 4. Si no se ha solucionado (listo vale FALSO) y la posición de la izquierda es válida 4.1. Llamar a recorrer recursivamente con la casilla de la izquierda como parámetro y guardar valor de retorno en listo, para ver si se resolvió el laberinto a partir de ahí. 5. Si no se ha solucionado (listo vale FALSO) y la posición de la derecha es válida 5.1. Llamar a recorrer recursivamente con la casilla de la derecha como parámetro y guardar valor de retorno en listo, para ver si se resolvió el laberinto a partir de ahí. 6. Si no se ha solucionado (listo vale FALSO) y la posición de arriba es válida 6.1. Llamar a recorrer recursivamente con la casilla de arriba como parámetro y guardar valor de retorno en listo, para ver si se resolvió el laberinto a partir de ahí. 7. Si no se ha solucionado (listo vale FALSO) y la posición de abajo es válida 7.1. Llamar a recorrer recursivamente con la casilla de abajo como parámetro y guardar valor de retorno en listo, para ver si se resolvió el laberinto a partir de ahí. 8. Si no se logró resolver el laberinto en ninguna dirección (listo todavía vale FALSO) 8.1. Quitar marca de la casilla (pues no formará parte del camino) 9. Retornar listo indicando si se pudo resolver o no el laberinto Código en C: int recorrer(int fil, int col) {
int listo = FALSE; /* Indica si se ha encontrado la salida */ /* Se marca la casilla como visitada */ lab[fil][col] = MARCA; /* Se controla la condicion de termino de recursividad: */ /* " Llegamos a la salida? " */ if (fil == xf && col == yf) return(TRUE); if (!listo && valida(fil,col-1)) listo = recorre(fil,col-1); if (!listo && valida(fil,col+1)) listo = recorre(fil,col+1); if (!listo && valida(fil-1,col)) listo = recorre(fil-1,col); if (!listo && valida(fil+1,col)) listo = recorre(fil+1,col);
/* Intento a la izquierda */ /* Intento a la derecha */ /* Intento hacia arriba */ /* Intento hacia abajo */
/* Si no se logro resolver el laberinto desde esta posicion, se */ /* desmarca la casilla pues no sera parte de la solucion. En este */ /* caso se retornara falso lo que provocara que se retroceda. */ if (!listo) lab[fil][col] = E; /* Se retorna TRUE/FALSE dependiendo de si se encontro solucion */ return(listo); }
desplegar Parámetros: no tiene Valor de retorno: no tiene Descripción: Despliega en la pantalla el laberinto Algoritmo: 1. Iterar i por todas las filas 1.1. Iterar j por todas las columnas 1.1.1. Desplegar posición i,j 1.2. Cambiar de línea pues terminó una fila Código en C: void desplegar() { int i, j; printf("\n"); for (i=0; i
3. Especificación del algoritmo
El algoritmo principal debe llamar a la tarea que recorre el laberinto, especificando como posición la entrada: ( x0 , y0 ). Antes y después de la resolución se despliega el laberinto. La segunda vez incluirá el camino que forma la solución (las posiciones que fueron marcadas y no desmarcadas posteriormente).
Algoritmo:
1. Desplegar el laberinto sin resolver 2. Recorrer desde la entrada del laberinto: ( x0 , y0 ) 3. Si no se pudo resolver 3.1. Desplegar un mensaje indicando que no hay solución 4. Desplegar el laberinto una vez resuelto (con el camino)
Código en C:
main() { int ok; /* Para saber si se obtuvo solucion */ desplegar(); /* Despliega el laberinto sin resolver */ /* Resuelve el laberinto desde la entrada: (x0,y0) */ ok = recorrer(x0,y0); if (!ok) /* Si no se pudo resolver se envia un mensaje */ printf("\nLaberinto sin solucion\n"); desplegar(); /* Despliega el laberinto resuelto (con el camino) */ } 4. Validación del algoritmo
La validación de un algoritmo recursivo requiere verificar que la condición de término se cumplirá en algún momento. En caso contrario, el algoritmo se llamará a sí mismo recursivamente hasta que el stack se agote y el programa colapse (error de ejecución). En este caso, la condición de término se alcanza cuando se logra llegar a la salida del laberinto o cuando se han probado todas las posibles direcciones (izquierda, derecha, arriba y abajo) y aún así no se ha encontrado solución. En este caso, el algoritmo recursivo se ha planteado de una forma bastante segura. El procedimiento siempre termina, ya sea positiva o negativamente, encontrando la solución o desistiendo de encontrarla, respectivamente. Por otra parte, es necesario definir dominios que caractericen situaciones distintas bajo las cuales se puede ejecutar el algoritmo. Dominios: Deben definirse dominios en los que, tanto la entrada como la salida del laberinto, se encuentren en distintas posiciones, incluso del mismo lado o hasta contiguas. Validación: Ejecutando en algoritmo para los dominios definidos debe verificarse que la solución cumple con la especificación planteada y por lo tanto alcanza el objetivo propuesto.
5. Limitaciones del algoritmo
A simple vista el algoritmo no tiene limitaciones importantes. Sin embargo, no existe una prueba formal de esto, por lo que se deja como ejercicio analizar la solución propuesta a fin de determinar potenciales limitaciones.
