6.4.2走迷宫

最新推荐文章于 2025-05-23 10:12:54 发布

Henryinferno

最新推荐文章于 2025-05-23 10:12:54 发布

阅读量990

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构和算法文章标签：数据结构 bfs

本文链接：https://blog.youkuaiyun.com/wsx199397/article/details/10657997

数据结构和算法专栏收录该内容

30 篇文章

订阅专栏

本文介绍了一种基于广度优先搜索（BFS）的迷宫最短路径算法实现，通过使用C语言进行编码，详细展示了如何寻找从起点到终点的最短路径，并附带了完整的代码示例。

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

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#define MAXN 7

int fa[MAXN][MAXN];//存储父节点
int dist[MAXN][MAXN];//存储到（x,y）的最短距离
int last_dir[MAXN][MAXN];//记录方向
int vis[MAXN][MAXN];
int dx[4]={-1,1,0,0},dy[4]={0,0,-1,1};//分别代表上下左右四个方向

void bfs(int x,int y,int **maze,int n,int m)
{
    int queue[MAXN*MAXN];
    int rear=0,front=0;
    int cur,next,d,nx,ny;

    cur=x*m+y;
    vis[x][y]=1;
    queue[rear++]=cur;//根节点入队
    fa[x][y]=cur;
    dist[x][y]=0;
    while(front<rear)
    {
        cur=queue[front++];//出队
        x=cur/m;
        y=cur%m;
        for(d=0;d<4;d++)
        {
            nx=x+dx[d];
            ny=y+dy[d];
            if(nx>=0 && nx<n && ny>=0 && ny<m && !*((int *)maze+nx*MAXN+ny) && !vis[nx][ny])
            { /* *((int *)maze+nx*MAXN+ny)这里学到了如何在一个二维数组行列不确定的情况下传参并操作
                注意这里不是*((int *)maze+nx*m+ny)。我这个bug找了很长时间。汗。。。*/

                next=nx*m+ny;
                queue[rear++]=next;
                vis[nx][ny]=1;
                fa[nx][ny]=cur;
                dist[nx][ny]=dist[x][y]+1;
                last_dir[nx][ny]=d;
            }
        }
    }
}
/*如果n,m较小的话可以用递归:
如果格子(x,y)有父亲(fx,fy),需要先打印从起点到(fx,fy)的最短路，
然后再打印从(fx,fy)到(x,y)的移动方向。*/
void PrintPath(int x,int y,int m)
{
    int fx=fa[x][y]/m;
    int fy=fa[x][y]%m;
    char name[5]="UDLR";

    if(fx!=x||fy!=y)
    {
        PrintPath(fx,fy,m);
        putchar(name[last_dir[x][y]]);
    }
}


/*非递归输出
int dir[MAXN*MAXN];
void PrintPath(int x,int y,int m)
{
    int fx,fy;
    int c=0;
    char name[5]="UDLR";

    while(1)
    {
        fx=fa[x][y]/m;
        fy=fa[x][y]%m;
        if(fx==x&&fy==y)
            break;
        dir[c++]=last_dir[x][y];
        x=fx;
        y=fy;
    }
    while(c--)
        putchar(name[dir[c]]);
}
*/
int main()
{
    int maze[MAXN][MAXN]={{0,0,1,0,0},
                          {0,1,0,0,0},
                          {0,1,0,1,1},
                          {0,1,0,0,0},
                          {0,0,0,1,0},
                          {0,0,0,0,0}};
   // int m,n,i,j,lx,ly;

   // printf("输入迷宫行，列\n");
  //  scanf("%d%d",&n,&m);
   // printf("初始化迷宫:(0表示空格，1表示障碍)\n");
   // for(i=0;i<n;i++)
   //     for(j=0;j<m;j++)
   //     {
   //         scanf("%d",&maze[i][j]);
    //    }
    bfs(0,0,(int **)maze,6,5);//起点默认为(0,0)
   // printf("输入终点坐标:");
  //  scanf("%d%d",&lx,&ly);
    PrintPath(0,4,5);//终点默认为(0,4)
    return 0;
}