迷宫问题 POJ - 3984（bfs）

Time limit

1000 ms

Memory limit

65536 kB

OS

Linux

Source

---

定义一个二维数组：

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

Input

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

Output

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

Sample Input

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

Sample Output

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

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <cstring>
#include <queue>
using namespace std;
int dis[6][6];
char s[6][6];
const int dx[]= {1,-1,0,0};
const int dy[]= {0,0,1,-1};
struct node
{
    int x,y;
}pre[6][6];//pre这个数组储存的是点的两个坐标值
bool valid(int x,int y)
{
    return x>=0&&x<5&&y>=0&&y<5;
}
void bfs(node b)
{
    queue<node> q;
    q.push(b);
    memset(dis,-1,sizeof(dis));
    dis[b.x][b.y]=0;
    while(!q.empty())
    {
        node u=q.front();
        q.pop();
        for(int i=0; i<4; i++)
        {
            node v=u;//u为当前点
            v.x+=dx[i];
            v.y+=dy[i];//v为下一步的点
            if(!valid(v.x,v.y))continue;
            if(dis[v.x][v.y]!=-1)continue;//保证点不被重复
            if(s[v.x][v.y]=='1')continue;
            dis[v.x][v.y]=dis[u.x][u.y]+1;
            pre[v.x][v.y]=u;//变化后的点pre输出的是上一步的坐标
            q.push(v);
        }
    }
}
node ans[10];//node型的数组ans存储的也是横纵坐标
int main()
{
    for(int i=0; i<5; i++)
    {
        for(int j=0;j<5;j++)
            cin>>s[i][j];
    }
    bfs(node{0,0});//相当于绘制了一个地图
    node u=node{4,4};
    int cnt=0;
    ans[cnt++]=node{4,4};//（4，4）这个点没有符合条件的下一个点来呈现它的坐标，所以直接加上
    while(u.x||u.y)
    {
        u=pre[u.x][u.y];//一步一步向前推
        ans[cnt++]=u;
    }
    for(int i=cnt-1;i>=0;i--)
    {
        cout<<"("<<ans[i].x<<", "<<ans[i].y<<")"<<endl;
    }
}

这个代码在有多条路径时，显然只能输出后来更新的那条，因为最后更新的会覆盖前面的，这就导致了如果dx[],dy[]这两个字符串里的数字顺序不一样的话，输出来的那一条路径可能不同。

与较为简单的只输出最少步数相比，需要在结构体上加一个数组来记录上一步的位置。

①为什么用后面的点来存前面点的坐标？而不反过来呢？

出现了后面的点才说明前面的点符合要求且不会断掉，是一条通路；反过来的话，在分叉路口，如果有两个方向都是0，后面的会把前面的覆盖，然而不能保证后面的是通路，这时候运行会崩，因为后面没有符合条件的路径，pre代表的下一个点不存在，u=pre[u.x][u.y];这一步就会出错，pre[u.x][u.y]可能随机，会跳到其他u，就乱掉了，可能溢出。

②为什么输出时从大到小，反过来可以吗？

如果是从后往前的话，就可以保证pre是前一个点一定是通路；而反过来势必要用到查找，在分叉时有两个点pre相同的话，就会有问题，分叉个数不定，分叉长度不定，很难判断到底该走哪一条路。就像是一棵树要找到最长的树枝，那么找到伸得最远的树梢，向前拽就可以得到结果，而从树干开始找的话需要一直判断哪些树枝还在延伸。更何况pre只可以存储一个点的坐标，就势必只能走一条路，但又不能保证这条路之后是通路，但根本不需要这样，bfs已经从前往后选择出通路了，直接从后往前输出这条路就可以了。

③什么要用到结构体？

队列里一个元素要代表一个坐标，所以要用到结构体。

在结构体中如果不用int x，int y；直接用<int,int>的话，需要用first，second调用。

④类和结构体调用时好相似啊！有什么区别吗？

结构体赋值是 直接赋值的值，而对象的指针 赋值的是对象的地址。

C++结构体的继承默认是public，而c++类的继承默认是private。

这个问题网上的答案更全面。

但是调用时都是p.x，p.y这种形式的。p是类（结构体）中的一个对象，x，y是属性。