2021-bfsTRN-E

原创于 2021-03-14 19:23:36 发布 · 95 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#bfs

本文介绍了一种解决迷宫最短路径问题的方法，通过使用广度优先搜索（BFS）算法并结合前驱节点记录，实现了从起点到终点的路径回溯与输出。文章包含完整的C++代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

https://vjudge.net/contest/425322#problem/E

原题复制粘贴

定义一个二维数组：

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,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

细节

本不想为这个shuiti写博客，但是毕竟这里有一个输出方案的范式，所以还是说一下。
struct 类型表示每一个点那么可以用一个struct类型的pre[10][10] 数组来存放每一个点的前驱节点（不重不漏）
输出的时候可以递归，我还是乖乖循环了~~

代码

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <queue>

using namespace std;
int vis[10][10],cnt=1,dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
char s[10][10];
struct node
{
    int x,y;
}pre[10][10],ans[50];

void bfs()
{
    queue<node>q;
    node now;
    now.x=1,now.y=1;
    q.push(now);
    vis[1][1]=1;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.x==5&&now.y==5)
        {
            while(!q.empty()) q.pop();
            return;
        }
        for(int i=0;i<4;i++)
        {
            int nx=now.x+dir[i][0],ny=now.y+dir[i][1];
            if(nx>=1&&nx<=5&&ny>=1&&ny<=5&&s[nx][ny]!='1'&&!vis[nx][ny])
            {
                node next;
                next.x=nx,next.y=ny;
                vis[nx][ny]=1;
                pre[nx][ny]=now;
                q.push(next);
            }
        }
    }
}
void result()
{
    ans[1].x=5,ans[1].y=5;
    node now=pre[5][5];
    while(1)
    {
        if(now.x==1&&now.y==1) break;
        ans[++cnt].x=now.x,ans[cnt].y=now.y;
        now=pre[now.x][now.y];
    }
    ans[++cnt].x=1,ans[cnt].y=1;
}
int main()
{
    int i,j;
    for(i=1;i<=5;i++)
    {
        for(j=1;j<=5;j++)
        {
            cin>>s[i][j];
        }
    }
    bfs();
    result();
    for(i=cnt;i>=1;i--)
    {
        printf("(%d, %d)\n",ans[i].x-1,ans[i].y-1);
    }
    return 0;
}