迷宫问题

 给定一个 n×n 的二维数组，如下所示：

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

数据保证至少存在一条从左上角走到右下角的路径。

输入格式:

第一行包含整数 n（0≤n≤1000）。

接下来 n 行，每行包含 n 个整数 0 或 1，表示迷宫。

输出格式:

输出从左上角到右下角的最短路线，如果答案不唯一，输出任意一条路径均可。

按顺序，每行输出一个路径中经过的单元格的坐标，左上角坐标为 (0,0)，右下角坐标为 (n−1,n−1)。

输入样例:

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

 解

#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

int maze[1000][1000];

typedef pair<int, int> PI;
PI q[1000 * 1000];
PI pre[1000][1000];
int n;

void bfs(int zx, int zy)
{
    int x[4]{ 0,0,1,-1 };
    int y[4]{ -1,1,0,0 };
    int jz = 0;//jz表示计划第几步了，sz表示实际走了几步了，直到走完前，实际走了几步等于计划走的步数
    int sz = 0;
    memset(pre, -1, sizeof pre);//将pre数组中的全部元素初始化为(-1,-1)
    q[0] = { zx , zy };//将终点作为起点，从后往前遍历
    pre[zx][zy] = { 0,0 };
    while (jz <= sz)
    {
        PI temp = q[jz++];//测试起点
        for (int i = 0; i < 4; i++)//四个方向都测试一遍
        {
            int Xx = temp.first + x[i];
            int Xy = temp.second + y[i];
            if (maze[Xx][Xy] == 1) continue;//碰壁情况
            if (Xx > n - 1 || Xx<0 || Xy > n - 1 || Xy < 0) continue;//越界情况
            if (pre[Xx][Xy].first != -1) continue;//遍历过的情况
            q[++sz] = { Xx,Xy };//将可以走的地点作为下一次的起点
            pre[Xx][Xy] = { temp.first,temp.second };//表示(Xx，Xy)是由(temp.first,temp.second)走过来的
        }
    }
}

int main()
{

    cin >> n;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            int d;
            cin >> d;
            maze[i][j] = d;
        }
    }

    bfs(n - 1, n - 1);

    PI temp = { 0,0 };
    while (1)
    {
        cout << temp.first << " " << temp.second << endl;
        if (temp.first == n - 1 && temp.second == n - 1)            break;
        temp = pre[temp.first][temp.second];//因为从短的路径到一点的步数肯定要比从长的路径到该点的步数要快，所以说保障了pre是最短的路径
    }
    return 0;
}