Tarea de estructura de datos y algoritmos: utilice la programación en lenguaje C para generar aleatoriamente un laberinto y luego encuentre la hoja de ruta desde la entrada hasta la salida.
¡urgente!
Algunas notas:
1. Este programa es dinámico y encontrará automáticamente la salida del laberinto después de ejecutarlo
2. Este programa es de gran importancia para aquellos que acaban de aprender el lenguaje C.
3. Está rodeado de paredes, las coordenadas (1, 1) son la entrada y el pie inferior derecho es la salida.
Declaración: Este programa no se puede depurar con VC. y necesita ser modificado
La herramienta de depuración para este programa es TC.............
#include "graphics.h"
#include "dos.h"
#include "stdlib.h"
#include "process.h"
#define MAX_COL 14 /*Definición Tamaño del laberinto*/
#define MAX_ROW 14
typedef struct
{ int vert
int horiz; p>
}compensaciones;
mapture(int i, int j, int k); /* Marca el laberinto, (i, j) está marcado como modo k*/
initmaze() ; /* Inicializa la matriz del laberinto */
findmaze(int i, int j /* Encontrado (i, j) que se puede recorrer, marcado */
mapmaze(); /*Dibuja el laberinto original*/
int findpath(int row, int col) /*Función recursiva para encontrar el camino del laberinto*/
mapbar(); /*Dibujar fuera de la cuadrícula*/
initgrap(); /*Inicializar VGA*/
print(); la salida es exitosa*/
int startx=50, starty=50 /*Coordenadas de pantalla para dibujar*/
int maze[MAX_ROW][MAX_COL];
movimiento de compensaciones[8]={{ 0,1},{1,1},{-1,1},{1,0},{-1,0},{0,-1},{ 1,-1},{-1,- 1}}; /*Buscar en 8 direcciones*/
initmaze()/*Inicializar la matriz del laberinto*/
{ int i, j;
for (i=0; ilt; MAX_ROW; i )/*Establezca 1 alrededor del laberinto para representar la pared*/
{ maze[i][0 ]=1;
laberinto[i ][MAX_COL-1]=1;
}
for(i=0; ilt; MAX_COL; i )
{ laberinto[0][i ]=1
laberinto[MAX_ROW-1][i]=1
}
<; p> randomize();for (i=1; ilt; MAX_ROW-1; i )/*El gráfico del laberinto se genera aleatoriamente, 1 significa irrazonable, 0 significa factible*/
for (j=1; jlt; MAX_COL-1; j )
{
laberinto[i][j]=random(2
}
findmaze (int i, int j)/*Buscar (i, j) y listo*/
{
mamá
pture(j, i, 2); /* marca en el gráfico */
sleep(1);
}
returnmaze(int i, int); j)/*Si encuentra (i, j), puede ir, pero si no hay manera de seguir adelante, márquelo */
{
mapture(j, i, 3); /*En Marca en el gráfico */
sleep(1);
}
print(int i)/*Después del el laberinto se completa, si la salida es exitosa*/
{ settextstyle(1, 0, 5
if (i==1)
outtextxy); (340, 400, "¡Ruta verdadera!");
else if(i==2)
outtextxy(340, 400, "¡Sin ruta!"); >
}
int findpath(int row, int col)/*Encuentra el laberinto usando recursividad*/
{ int direct, next_row, next_col
<; p> directo=0;laberinto[1][1]=2;
mapture(1, 1, 2)
dormir(1)
while(directlt; 8)/*Buscar en 8 direcciones*/
{ next_row=row move[direct].vert /*Establecer la siguiente coordenada*/
next_col=col move[direct] .horiz;
if(maze[next_row][next_col]==0) /*Si se puede mover, márcalo*/
{ laberinto[next_row][next_col]=2;
findmaze(next_row, next_col
if(next_row==(MAX_ROW-2)&next_col= =(MAX_COL-2))/*Encuentra la salida y sal del programa */
{ print(1);
getch(); (0);
}
else
findpath(next_row, next_col); /*Continuar recursividad sin llegar a la salida*/
returnmaze(next_row, next_col
}
directo
}
return(row);
}
La depuración de TC es buena