BFS求最短路

假设有一个n行m列的迷宫，每个单位格要么是空地(用1来表示)要么是障碍物(用0来表示).如何找到从起点到终点的最短路径？

分析：要找到终点到起点的最短路径，可以使用二叉树的BFS，因为二叉树的BFS的访问顺序就是结点到根节点的距离，从小到大访问的，因此可以从迷宫图的起点开始进行BFS的宽度优先遍历。

遍历过程中需要实现：

（1）记录每个结点到起点的距离；

（2）记录每个结点的父结点，构造出BFS二叉树，根据该树，给出任意一个空地的座标，都可以根据父节点回溯到起点（0，0）；

（3）每一个结点都要访问其上下左右四个方向，并判断每个方向的节点位置是否合格，合格的加入队列；

遍历成功后，根据给出终点位置，使用递归来输出起点到该终点的路径；

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;
const int maxn = 5;
struct Node{
    int x;
    int y;
    Node(int x = 0,int y = 0):x(x),y(y){}
}; 
int graph[maxn][maxn]; //迷宫数组 
int dis[maxn][maxn];   //记录每个结点到起点的距离 
struct Node path[maxn][maxn]; //记录每个结点的父节点 
const int dir[4][2] = {{0,1},{0,-1},{1,0},{-1,0}}; //每个结点的四个方向 
bool judge(int dr,int dc){
    if(dr >= 0 && dr < maxn && dc >= 0 && dc < maxn 
    && dis[dr][dc] == -1 && graph[dr][dc]){
        return true;
    }
    return false;
} 

void bfs(){    //宽度遍历迷宫，构造BFS树（最短路树）
    memset(dis,-1,sizeof(dis)); 
    queue<Node> q;
    q.push(Node(0,0));  //规定迷宫的起点是(0,0) 
    dis[0][0] = 0;
    while(!q.empty()){
        Node n = q.front();q.pop();
        for(int i = 0;i < 4;i++){
            int dr = n.x + dir[i][0];
            int dc = n.y + dir[i][1];
            if(judge(dr,dc)){
                dis[dr][dc] = dis[n.x][n.y] + 1;
                q.push(Node(dr,dc));
                path[dr][dc] = n; 
            }
        }
    }    
}
void print_path(int r,int c){
    Node n = path[r][c];
    if(n.x == 0 && n.y == 0){    //回溯到起点 
        cout << "(0,0)" << " ";
        return;
    }
    print_path(n.x,n.y);
    cout << "(" << r << "," << c << ")" << " "; 
} 
int main(){
    for(int i = 0;i < maxn;i++){    //输入迷宫 
        for(int j = 0;j < maxn;j++){
            cin >> graph[i][j];
        }
    }
    bfs(); 
    print_path(4,4);
    return 0;
}