Enlace 1086
Título
Defina una matriz bidimensional:
int maze [5] [5] = {
0, 1, 0, 0, 0,
0, 1, 0, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};
Representa un laberinto, donde 1 representa la pared y 0 representa que puedes caminar.
Solo puede caminar horizontal o verticalmente en lugar de en diagonal.
El programa encuentra la ruta más corta desde la esquina superior izquierda hasta la esquina inferior derecha.
Entrada
Una matriz bidimensional de 5 × 5 representa un laberinto. Se garantiza que los datos tienen una solución única.
Salida
La ruta más corta desde la esquina superior izquierda a la esquina inferior derecha, el formato es como se muestra en la muestra.
Entrada de muestra
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
Salida de muestra
(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)
Esta pregunta es uno de los tipos más cortos de preguntas que necesita generar las coordenadas de la
ruta más corta. La idea de encontrar la ruta más corta es la misma que la pregunta más corta habitual, pero la diferencia es que necesita generar la ruta más corta
porque bfs es una búsqueda amplia. Al final, todos los nodos se rellenarán y saldrán, por lo que es difícil generar la ruta más corta directamente cuando se encuentra la ruta más corta, porque no sabe en qué punto está disponible el siguiente nodo, por lo que no lo sabe. Es este punto lo que queremos, y en este momento podemos usar el retroceso, es decir, desde el último punto, para encontrar el último punto, necesitamos registrar un nodo al mismo tiempo que registramos un nodo,
y es conveniente rastrear hacia atrás. Hay otro punto, porque Si buscamos desde el punto de inicio, al generar la salida, comenzará a retroceder desde el punto final, lo que equivale a la salida en orden inverso. Puede encontrar un número y guardarlo, y luego generarlo en orden positivo. También puede buscar desde el punto final hasta el punto de inicio desde el principio. De esta manera, el último paso es rastrear desde el punto de inicio, que es equivalente a la salida de secuencia positiva, lo cual es muy conveniente
el código se muestra a continuación
#include<bits/stdc++.h>
using namespace std;
struct ranran
{
int x, y;
};
ranran tr[6][6];//这个结构体的二维数组很重要，像你一样重要
/*
定义一个ranran的结构体的二维数组tr
从最后的终点往起点搜索，这样方便正序输出
而就是通过这个结构体的二维数组实现的
tr[][]里面的[]是从终点开始往起点搜的下一个节点的坐标
而tr[][].x / y是现在的点的坐标
我们最后通过的是从起点开始输出，拥有的是tr[][]中两个[]的数
通过这两个数索引会他的上一个的点的坐标
就是tr[][].x / y
输出的是这个x, y
*/
int vis[6][6] = {
0};//用来判断有没有走过这个点
int tang[6][6];//存地图
int dx[] = {
1, 0, 0, -1};//上下左右走
int dy[] = {
0, 1, -1, 0};
int judge(int x, int y)//判断这点能不能走
{
if (vis[x][y] == 0 && tang[x][y] == 0 && x <= 4
&& y <= 4 && x >= 0 && y >= 0)
{
return 1;
}
return 0;
}
void bfs()
{
ranran now, next;
now.x = 4;//从终点开始搜，所以肯定得把终点的坐标塞进去
now.y = 4;
queue<ranran>q;
//vis[now.x][now.y] = 1;//标记一下终点
q.push(now);
while(!q.empty())//当队列不为空的时候就进入循环
{
now = q.front();//取栈首
q.pop();//给他扔出去
if(now.x == 0 && now.y == 0)//判断是不是搜到了起点
{
break;
}
int tx, ty;//临时变量 用来存下一个的点的坐标，
for(int i = 0; i < 4; i++)//上下左右走
{
tx = now.x + dx[i];
ty = now.y + dy[i];
if(judge(tx, ty))
{
next.x = tx;
next.y = ty;
tr[next.x][next.y].x = now.x;//当按序输出的时候，这个now就相当于next
tr[next.x][next.y].y = now.y;
q.push(next);//塞进去
vis[next.x][next.y] = 1;
}
}
}
}
void printf()
{
int x = 0;
int y = 0;// 起点为(0, 0);
while(!(x == 4 && y == 4))
{
printf("(%d, %d)\n", x, y);
int rx, ry;
rx = tr[x][y].x;//用rx, ry 来存一下下一个点的坐标 如果直接用x = tr[][].x 那么给y赋值的时候这个x就被改变了，所以得用其他变量存一下
ry = tr[x][y].y;
x = rx;
y = ry;
}
printf("(%d, %d)\n", x, y);//得输出（4， 4）
}
int main()
{
//memset(vis, 0, sizeof(vis));
for(int i = 0; i < 5; i++)
{
for(int j = 0; j < 5; j++)
{
cin>>tang[i][j];
}
}
bfs();
printf();
return 0;
}
/*
0 0 0 0 1
1 0 1 0 1
1 0 0 1 1
1 0 0 0 0
0 0 0 0 0
*/