/********************************************************************** * Ejemplo: Solucion de un laberinto en forma recursiva. * Para mejor comprensin ver la descripcin adjunta. **********************************************************************/ #include <stdio.

h> #include <conio.h> /* 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 } }; /* Coordenadas de la entrada del laberinto */ int x0 = 1; int y0 = 0; /* Coordenadas de la salida del laberinto */ int xf = 11; int yf = 20; /********************************************************************** * Funcion que despliega el laberinto en su totalidad. **********************************************************************/ void desplegar() { int i, j; printf("\n"); for (i=0; i<FILAS; i++) { for (j=0; j<COLUMNAS; j++) { */ */ */ */

printf("%c", lab[i][j]); } printf("\n"); } return; } /********************************************************************** * Analiza una posicion dentro del laberinto, especificada por la fila * y columna recibidas como parametro, y deduce si es una posicion * valida para recorrer. Basicamente debe verificar que no este fuera de * los limites del laberinto, que no se trate de una posicion en la que * hay pared, y que no se trate de una posicion previamente visitada. **********************************************************************/ 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); } /********************************************************************** * Funcion 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 tambin * para senalar la ruta que conforma la solucion, una vez alcanzada. **********************************************************************/ 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 listo = if (!listo listo = if (!listo && valida(fil,col-1)) recorrer(fil,col-1); && valida(fil,col+1)) recorrer(fil,col+1); && valida(fil-1,col)) /* Intento a la izquierda */ /* Intento a la derecha */ /* Intento hacia arriba */

listo = recorrer(fil-1,col); if (!listo && valida(fil+1,col)) listo = recorrer(fil+1,col); /* /* /* if

/* 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. */ (!listo) lab[fil][col] = E;

/* Se retorna TRUE/FALSE dependiendo de si se encontro solucion */ return(listo); } /********************************************************************** * Funcion principal para la resolucion del laberinto. Se despliega * el laberinto antes y despues de resolverlo (encontrar el camino). **********************************************************************/ main() { int ok; /* Para saber si se obtuvo solucion */ /* Despliega el laberinto sin resolver */

desplegar();

/* 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"); // system(pause); desplegar(); /* Despliega el laberinto resuelto (con el camino) */ getch(); }