(算法提高课)-最短路模型1

1076. 迷宫问题

给定一个 n×n
的二维数组，如下所示：
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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。
数据保证至少存在一条从左上角走到右下角的路径。
输入格式
第一行包含整数 n。
接下来 n行，每行包含 n个整数 0 或 1，表示迷宫。
输出格式
输出从左上角到右下角的最短路线，如果答案不唯一，输出任意一条路径均可。
按顺序，每行输出一个路径中经过的单元格的坐标，左上角坐标为 (0,0)，右下角坐标为 (n−1,n−1)。
数据范围
0≤n≤1000
输入样例：
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<bits/stdc++.h>
using namespace std;

typedef pair<int,int> PII;
const int N = 1010;

int maze[N][N], n;
bool st[N][N];   //用来标记该节点是否访问过(用层次遍历法按层次遍历每一个不为独立块的0)
PII pre[N][N];  //标记访问到的每一个节点的前驱节点

void bfs()
{
    queue<PII> q;   //建立一个遍历队列
    q.push({n - 1,n - 1});   //这里为了输出的方便采取逆序搜索(用前驱节点记录，可以往前追溯，所以让(0,0)作为最后一个节点)
    st[n - 1][n - 1] = true;

    int dx[] = {0,-1,0,1};
    int dy[] = {-1,0,1,0};

    while(!q.empty()){
        PII t = q.front(); q.pop();
        int x = t.first; int y = t.second;

        for(int i = 0;i < 4;i ++){
            int sx = x + dx[i];
            int sy = y + dy[i];

            if(sx < 0 || sy < 0 || sx >= n || sy >= n) continue;
            if(maze[sx][sy])  continue;
            if(st[sx][sy])  continue;

            q.push({sx,sy});
            st[sx][sy] = true;
            pre[sx][sy] = t;
        }
    }
}
int main()
{
    cin>>n;
    for(int i = 0;i < n;i ++){
        for(int j = 0;j < n;j ++){
            scanf("%d", &maze[i][j]);
        }
    }

    bfs();

    PII p(0,0);
    while(true){
        printf("%d %d\n",p.first, p.second);
        if(p.first == n - 1 && p.second == n - 1) break;
        p = pre[p.first][p.second];   //找到前驱节点
        
    }
    return 0;
}