Programación del laberinto de colores
Usar espacio de nombres std
T //La clase define el tipo de estructura que describe la posición actual en el laberinto.
{
Público:
int x; //x representa la coordenada de fila de la posición actual.
int y; //y representa la coordenada de la columna de la posición actual.
int dir//0: no válido, 1: este, 2: sur, 3: oeste, 4: norte.
};
Nodo de enlace de clase//Nodo de lista enlazada
{
Pila de clases de amigos;
Público:
Datos de prueba;
LinkNode * siguiente
};
Pila de clases
{< / p>
Privado:
LinkNode * top//Puntero a la parte superior de la pila que apunta al primer nodo
Público:
stack() ;/ /Constructor, pila vacía
~ Stack(); //Destructor
Push vacío (T e); //Empuja los datos del elemento a la pila.
t Pop(); //Eliminar el elemento superior de la pila
t get pop(); //Eliminar el elemento superior de la pila
void Clear (); //Borrar la pila
Boolean vacío(); //Determinar si la pila está vacía, devuelve 1, de lo contrario devuelve 0.
};
Stack::Stack() //Constructor, pila vacía.
{
top = NULL
}
Pila::~Pila() //Destructor
{
}
Void Stack::Push(T e) //Empuja el elemento X a la pila.
{
nodo de enlace * P;
p = nuevo nodo de enlace
p->;
p->;next = top
top = P;
}
T Stack::Pop() //Salir del elemento superior de la pila de la pila.
{
Temperatura de prueba;
nodo de enlace * P
P = arriba
arriba = arriba; - gt; siguiente;
temp = P- gt;
eliminar P; p>
T Stack::GetPop() //Elimina el elemento superior de la pila.
{
Volver al inicio - gt;data;
}
Void Stack::Clear() //Borrar la pila .
{
top = NULL
}
Bool Stack::empty() // Determina si la pila está vacía, si está vacío Devuelve 1; de lo contrario, devuelve 0.
{
if(top==NULL) devuelve 1;
De lo contrario, devuelve 0; >int move[4][2]={{0, 1}, {1, 0}, {0, -1}, {-1, 0 } } // Definir las cuatro direcciones en las que está la posición actual; para ser movido.
bool Mazepath(int **maze, int m, int n);
//Encuentra el camino de (0, 0) a (m, n) en el laberinto.
//Si se alcanza, devuelve verdadero; de lo contrario, devuelve falso.
void PrintPath(stack p); //Generar la ruta del laberinto
void Restore(int **maze, int m, int n); //Restaurar el laberinto
int * * get maze(int amp; m, int ampn); //Obtener el laberinto
//Devuelve el puntero bidimensional para acceder al laberinto.
int main()
{
int m=0, n = 0; //Definimos el largo y ancho del laberinto.
int * *Maze; //Definir un puntero bidimensional para acceder al laberinto
maze=GetMaze(m, n); //Llamar a get maze(int; m, int ampn) Función para obtener el laberinto.
If(Mazepath(maze, m, n)) //Llame a la función Mazepath(int **maze, int m, int n) para obtener la ruta.
cout lt lt"¡La exploración del camino del laberinto fue exitosa!\n ";
else cout lt lt"¡Este camino no existe!\n";
Return 0;
}
int * * get maze(int amp; m, int ampN)//Devuelve un puntero bidimensional para acceder al laberinto.
{
int * *laberinto; //Definir un puntero bidimensional para acceder al laberinto
int i=0, j = 0;
cout lt lt"Ingrese el largo y el ancho del laberinto:";
int a, b; CIN gt; Ingrese el largo y el ancho del laberinto; .
cout lt lt"Ingrese el contenido del laberinto: \n";
m = a
n = b //m y n; representan el laberinto respectivamente El número de filas y columnas.
maze = new int *[m 2]; //Solicita un puntero secundario con una longitud igual al número de líneas más 2.
for(I = 0;I ltm 2;I) //Aplica espacio para cada puntero bidimensional.
{
laberinto[I]= new int[n 2];
}
for(I = 1; i lt = m; I ) //Ingrese el contenido del laberinto, donde 0 significa que es transitable y 1 significa que no es transitable.
for(j = 1;j lt= n;j)
CIN gt; gtmaze[I][j];
for(I = 0 ; i ltm 2; i )
laberinto[I][0]=laberinto[I][n 1]= 1;
for(I = 0; i ltn 2 ; i )
Laberinto[0][I]=Maze[m 1][I]= 1;
Devuelve el laberinto //Devuelve el laberinto de puntero bidimensional que almacena; el laberinto.
};
Ruta del laberinto bool (int * * maze, int m, int n) // Encuentra de (0, 0) a (m, n) en el laberinto camino.
//Si se alcanza, devuelve verdadero; de lo contrario, devuelve falso.
{
Stack q, p; //Defina las pilas P y Q para almacenar el proceso y la ruta de almacenamiento para explorar el laberinto, respectivamente.
T Temp1, Temp2
int x, y, bucle
temp 1
temp 1 . 1;
q . Push(temp 1); //Coloca la posición de entrada en la pila
Página (abreviatura de página) push(temp 1);
Maze[1][1]=-1; //Indica que se ha alcanzado la posición de entrada.
And (!Q.empty()) //Si la pila Q no está vacía, explora repetidamente.
{
temp 2 = q . get pop(); //Obtiene el elemento superior de la pila
If (!(p.GetPop()) .x ==q.GetPop().x amp ampp.GetPop().y==q.GetPop() >
//Si hay una nueva posición en la pila, almacene la última posición explorada en la pila. pag.
for(loop = 0; loop lt4; Loop) //Explora las 4 posiciones adyacentes de la posición actual.
{
x = temp 2 . x move[loop][0] //Calcula el valor de posición de la nueva posición x.
y = temp 2. y move[loop][1]; //Calcula el valor de la posición Y de la nueva posición
If(maze[x][y]== 0) //Determina si se puede acceder a la nueva ubicación.
{
temp 1 . x = x;
temp 1 . =-1; //Indica que se ha alcanzado la nueva posición.
q . Push(temp 1); //La nueva posición se coloca en la pila
}
if((x = =(m)) amp; amp(y = =(n))//Llegó con éxito a la salida
{
temp 1 . = n. ;
temp 1 . dir = 0;
Página (abreviatura de página) push(temp 1); //Coloca la última posición en la pila
print path(p); //Ruta de salida
Restore(maze, m, n); //Restaurar ruta
Return 1; se ha encontrado correctamente
}
}
if(p.GetPop().x==q.GetPop().x amp ampp.GetPop(. ).y==q .GetPop(). y)
//Si no hay una nueva posición en la pila, regresa a la posición anterior
{
Página (abreviatura de página. ) pop();
q
}
}
Regresar. 0; // Indica error de búsqueda, es decir, no hay ruta en el laberinto
}
Void PrintPath(stack p) //Ruta de salida
cout lt lt” El camino del laberinto es\n";
cout lt lt"El contenido entre paréntesis se expresa como (coordenadas de fila, coordenadas de columna, números dirección, dirección)\n";
Pila t ; //Definir una pila según la ruta de acceso desde la entrada hasta la salida.
int a, b;
Datos de prueba
LinkNode * temp
temp = nuevo LinkNode//Espacio de aplicación
temp->; data = p. Pop(); //Obtiene el elemento de vértice de la pila P, que es la primera posición.
t.push(temperature->data); //La primera posición se coloca en la pila t.
Eliminar temp//Liberar espacio
Y (!P.empty()) //Si la pila P no está vacía, repita la transferencia.
{
temp = new LinkNode
temp->; data = p . //Obtener la siguiente posición
a=t.GetPop(). x-temp->;data.x//Dirección de coordenadas de línea
b=t.GetPop(). y-temp->;data.y//Dirección de las coordenadas de la columna
if(a==1) temp->dir = 1;//La dirección hacia abajo está representada por 1.
else if(b = = 1)temp-gt; data dir = 2 //La dirección correcta está representada por 2.
else if(a = =-1)temp-gt; data dir = 3; //La dirección ascendente está representada por 3.
else if(b = =-1)temp-gt; data dir = 4; //La dirección izquierda está representada por 4.
t.push(temp->data); //Pon la nueva posición en la pila
Eliminar temp
}
// Ruta de salida, incluidas las coordenadas de la fila, las coordenadas de la columna y la dirección de la siguiente posición.
Y (!T.empty()) //La pila no está vacía, continúa la salida.
{
datos = t . Pop();
cout lt lt(' lt ltdata.x lt lt,' lt ltdata.y lt lt, ' lt ltdata.dir lt lt","; // Genera las coordenadas de fila y columna
Switch(data.dir) // Muestra la dirección correspondiente
{
Caso 1: cout lt; lt" ↓) \ n ";
Caso 2: cout lt"→)\ n "; Caso 3: cout lt" ↑)\n"; Romper;
Caso 4: cout lt"←)\n";
Caso 0: cout lt ; lt")\n"; break;
}
}
}
Restauración nula (int * * laberinto, int m, int n)//Restaurar el laberinto.
{
int i, j;
for(I = 0; iltm 2; I) //Puntero de recorrido
for (j = 0; j ltn 2; j )
{
if(maze[I][J]=-1)//Restaurar la posición explorada, es decir, restaurar -1 es 0.
Laberinto[I][j]= 0;
}
}
Salida de muestra:
Prueba 1:
Ingrese el largo y el ancho del laberinto: 5 5.
Por favor introduce el contenido del laberinto:
0 1 1 0 0
0 0 1 1 0
1 0 0 1 1
1 0 0 1 0
1 1 0 0 0
El camino del laberinto es
El contenido entre paréntesis es expresado como (coordenadas de línea, coordenadas de columna, dirección numérica, dirección).
(1, 1, 1, ↓)
(2, 1, 2, →)
(2, 2, 1, ↓)
(3, 2, 1, ↓)
(4, 2, 2, →)
(4, 3, 1, ↓)
(5, 3, 2, →)
(5, 4, 2, →)
(5, 5, 0,)
¡La exploración del camino del laberinto fue exitosa!
Prueba 2:
Ingrese el largo y ancho del laberinto: 9 8
Ingrese el contenido del laberinto:
0 0 1 0 0 0 1 0
0 0 1 0 0 0 1 0
0 0 0 0 1 1 0 1
0 1 1 1 0 0 1 0
0 0 0 1 0 0 0 0
0 1 0 0 0 1 0 1
0 1 1 1 1 0 0 1
1 1 0 0 0 1 0 1
1 1 0 0 0 0 0 0
El camino del laberinto es
El Los contenidos entre paréntesis se expresan como (coordenadas de fila, coordenadas de columna, dirección numérica, dirección).
(1, 1, 1, ↓)
(2, 1, 1, ↓)
(3, 1, 1, ↓)
(4, 1, 1, ↓)
(5, 1, 2, →)
(5, 2, 2, →)
(5, 3, 1, ↓)
(6, 3, 2, →)
(6, 4, 2, →)
(6, 5, 3, ↑)
(5, 5, 2, →)
(5, 6, 2, →)
( 5, 7, 1, ↓)
(6, 7, 1, ↓)
(7, 7, 1, ↓)
(8, 7, 1, ↓)
(9, 7, 2, →)
(9, 8, 0,)
La exploración del camino del laberinto fue exitosa !