Cómo crear un modelo de laberinto de teléfono móvil mediante programación
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; ->Siguiente;
temp = P ->data;
Eliminar P;
Temperatura de retorno;
}
T Stack::GetPop() //Obtiene el elemento superior de la pila.
{
Volver al principio ->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 & m, int & n); //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 & m, int & N) // Devuelve un puntero bidimensional para acceder al laberinto.
{
int * *laberinto; //Definir un puntero bidimensional para acceder al laberinto
int i=0, j = 0;
cout<<"Ingrese el largo y el ancho del laberinto:"
int a,b;CIN>>a>>b;//Ingrese el largo y el ancho del laberinto.
cout & lt& lt"Ingrese el contenido del laberinto:\n";
m = a
n = b //m, n representa; respectivamente El número de filas y columnas del laberinto.
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<m+2;I++) //Aplica espacio para cada puntero bidimensional.
{
laberinto[I]= nuevo 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<=n;j++)
CIN>>maze[I][j];
for (I = 0;i<m +2;i++)
Laberinto[I][0]=Laberinto[I][n+1]= 1;
for(I = 0;i<n+2;i++ )
Maze[0][I]=Maze[m+1][I]= 1;
Regresar al laberinto; // Devuelve el laberinto de puntero 2D 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&p.GetPop().y==q.GetPop(). p>
//Si hay una nueva posición en la pila, almacena la última posición explorada en pila pág.
for(loop = 0; loop & lt4;Loop++) //Explora 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))//Llegué exitosamente a la salida
{
temp 1 . 1 . y = n;
temp 1 . dir = 0;
Página (abreviatura de página) push(temp 1); p>
print path(p); //Ruta de salida
Restore(maze, m, n); //Restaurar ruta
Return 1; la ruta 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
}
}
}
Void PrintPath(stack p) //Ruta de salida
{
cout. <<"El camino del laberinto es\n";
cout <<"El contenido entre paréntesis se expresa como (coordenadas de fila, coordenadas de columna). , dirección numérica, 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//Solicitar espacio
temp->; ();//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-> data dir = 2 //La dirección correcta está representada por 2.
else if(a = =-1)temp-& gt; dir = 3 //La dirección ascendente está representada por 3.
else if(b = =-1)temp-& gt; 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",";// Salida de coordenadas de fila y columna
Switch(data.dir) // Salida de la dirección correspondiente
{
Caso 1: cout & lt; & lt" ↓) \ n "Pausa
Caso 2: cout & lt; & lt"→)\ n " ; romper;
Caso 3: cout & lt& lt"←)\ n "; ;
Caso 0: cout <<")\n";Break;
}
}
}
Restauración de vacío (int * * maze, int m, int n) //Restaurar el laberinto.
{
int i,j;
for(I = 0;i<m+2;I++) //Puntero de recorrido
for(j = 0; j & ltn+2; j++)
{
if(maze[I][J]=-1)//Restaurar la Posición explorada, que es decir, restaurar -1 a 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,↓) p>
(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,)
El camino del laberinto era explorado con éxito!