思路：正着一遍bfs，反着输出
给定一个 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
行，每行包含
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

#include<bits/stdc++.h>
using namespace std;
int f[1005][1005],t,tx,ty;
int book[1005][1005];
int kx[4]={0,0,1,-1};
int ky[4]={1,-1,0,0};
struct vivo{
    int x,y;
}mi;
queue< vivo > v;
int n;
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        {
            cin>>t;
            if(t)
            {
                f[i][j]=-1;
                book[i][j]=0;
            }
            else
            {
                f[i][j]=0;
                book[i][j]=1;
            }
        }
    book[n][n]=0;
    f[n][n]=1;
    mi.x=n;
    mi.y=n;
    v.push(mi);
    while(v.size())
    {
        for(int i=0;i<4;i++)
        {
            tx=v.front().x+kx[i];
            ty=v.front().y+ky[i];
            if(tx>0&&ty>0&&tx<=n&&ty<=n&&book[tx][ty])
            {
                book[tx][ty]=0;
                mi.x=tx;
                mi.y=ty;
                v.push(mi);
                f[tx][ty]=f[v.front().x][v.front().y]+1;
            }
        }
        v.pop();
    }
    mi.x=1;
    mi.y=1;
    v.push(mi);
    printf("0 0\n");
    while(v.size())
    {
        for(int i=0;i<4;i++)
        {
            tx=v.front().x+kx[i];
            ty=v.front().y+ky[i];
            if(tx>0&&ty>0&&tx<=n&&ty<=n&&f[tx][ty]==f[v.front().x][v.front().y]-1)
            {
                printf("%d %d\n",tx-1,ty-1);
                mi.x=tx;
                mi.y=ty;
                v.push(mi);
                break;
            }
        }
        v.pop();
    }
    return 0;
}