Trusty Tahr（记录路径）

最新推荐文章于 2023-10-11 05:00:00 发布

原创最新推荐文章于 2023-10-11 05:00:00 发布 · 244 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了一种解决迷宫问题的方法，通过使用广度优先搜索（BFS）算法找到从迷宫左上角到右下角的最短路径。文章提供了一个具体的5x5迷宫示例，并给出了相应的C++代码实现。

代码来源：http://blog.youkuaiyun.com/irene_ruru/article/details/46458287

D:迷宫问题

总时间限制:

1000ms

内存限制:

65536kB

描述

定义一个二维数组：

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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

输入

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

输出

左上角到右下角的最短路径，格式如样例所示。

样例输入

样例输出

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

#include<iostream>
#include<stdio.h>
using namespace std;
int maze[5][5];
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
struct node
{
    int x,y;
    int pre;
}p[1000];
bool is(int x,int y)
{
    if(x>=0&&x<=4&&y>=0&&y<=4)
        return true;
    else
        return false;
}
void print(int x_)
{
    if(p[x_].pre==-1)
        return;
    print(p[x_].pre);//如果不是初始点，就再调用前一个
    printf("(%d, %d)\n",p[x_].x,p[x_].y);
    return;
}
void bfs(int x_,int y_)
{
    p[0].x=x_;
    p[0].y=y_;
    p[0].pre=-1;
    int front=0,rear=1;
    while(front<rear)//终止条件
    {
        for(int i=0;i<4;++i)
        {
            int tempx=p[front].x+dx[i];
            int tempy=p[front].y+dy[i];
            if(is(tempx,tempy)&&maze[tempx][tempy]==0)//判断(tempx,tempy)是否在迷宫内且能不能走
            {
                maze[tempx][tempy]=1;
                p[rear].x=tempx;
                p[rear].y=tempy;
                p[rear].pre=front;
                rear++;//当rear不能再增加时，front==rear
            }
            if(tempx==4&&tempy==4)
            {
                print(front);
                return ;
            }
        }
        front++;
    }
    return ;
}
int main()
{
    for(int i=0;i<5;++i)
        for(int j=0;j<5;++j)
            cin>>maze[i][j];
    printf("(0, 0)\n");
    bfs(0,0);
    printf("(4, 4)\n");
    return 0;
}