001:迷宫问题

描述
定义一个二维数组：

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 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

样例输出

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

简单的bfs，主要难点是保存路径，因此需要模拟队列。

#include<cstdio>
#include<cstring>
using namespace std;
const int N = 100;
int matrix[N][N]; //记录迷宫
struct Path { //把坐标x,y以及父节点f这三个状态加入队列，所以用了结构体
    int r,c;
    int f;//父节点
    Path() {} //无参构造函数
    Path(int _r,int _c,int _f) : r(_r),c(_c),f(_f) {} //有参构造函数
};
bool vis[N][N] = {0}; //记录点是否已经加入，每个点只能加入一次
int head = 0,tail = 1; //因为要保存路径，所以元素不能出列，因此要模拟队列 。用头尾两个指针就好了。
int dis[4][2] = {{1,0},{-1,0},{0,-1},{0,1}}; //按四个方向拓展
Path Queue[N]; //队列
void Init() //初始化
{
    memset(matrix,0,sizeof(matrix));
    for(int i = 0; i<5; ++i)
        for(int j = 0; j<5; ++j)
            scanf("%d",&matrix[i][j]);
    Queue[0] = Path(0,0,-1); //将起点加入队列，并修改vis
    vis[0][0] = 1;
}
void Print_1(int head) //打印答案。先用数组存储，然后反向输出
{
    int ans[N] = {0};
    int i = 1;
    ans[0] = head;
    while(Queue[head].f != -1) {
        head = ans[i++] = Queue[head].f;
    }
    for(int j = i-1; j>=0; --j)
        printf("(%d, %d)\n",Queue[ans[j]].r,Queue[ans[j]].c);
}
void Print_2(int head) //递归输出，看起来高大上了
{
    if(head == -1)
        return;
    Print_2(Queue[head].f);
    printf("(%d, %d)\n",Queue[head].r,Queue[head].c);
    return;
}
void Bfs(int x,int y)
{
    while(head != tail) {
        Path path = Queue[head];
        if(path.r == 4 && path.c == 4) { //找到答案，输出
//            Print_1(head);
            Print_2(head);
            return;
        } else {
            for(int i = 0; i<4; ++i) { //拓展
                int now_x = path.r + dis[i][0];
                int now_y = path.c + dis[i][1];
                if(now_x>=0 && now_x<5 && now_y>=0 && now_y<5) { //不能越界
                    if(!vis[now_x][now_y] && matrix[now_x][now_y] != 1) { //满足条件
                        Queue[tail++] = Path(now_x,now_y,head);
                        vis[now_x][now_y] = 1;
                    }
                }
            }
        }
        head++; //这里要注意，每次头指针都要后移
    }
}
int main()
{
    Init();
    Bfs(0,0);
    return 0;
}