C++数据结构与算法分析——BFS(宽度优先遍历)

BFS

介绍

BFS也叫宽度优先遍历，广度优先遍历，宽度优先搜索，广度优先搜索，是一种常用的搜索手段。

原理

以一个点为起点，先遍历所有与它直接相连的点，再层层拓展，直到最后走到终点或终止条件处停止。
假如有这棵二叉树，该二叉树从根节点开始宽度优先遍历的结果为a,b,c,d,e,f,g，先遍历a，然后遍历a的儿子节点b,c，然后遍历b的儿子节点d,e，然后遍历c的儿子节点f,g，下面没有节点了，遍历结束。

实现

那么BFS如何实现呢？我们知道当我们遍历到一个节点时必须要把它们的子节点也记下来，但是不能直接遍历，因为它还要先遍历自己的兄弟节点，即先将同一层节点的遍历完才遍历下一层节点。因此我们便发现队列是一个不错的容器。当遍历到一个节点时，可以先将它的子节点入队排队，然后再遍历队列的下一个元素，再做同样的事情。
例如：
当遍历到a时，先将a入队到q中。此时我们会发现，只要队列不空，入队的节点遍历到就会将它的子节点入队，队列也可以一直遍历节点，因此，我们的终止条件就是队列为空时停止BFS。因为它代表所有节点都没有子节点了，而且所有点也都遍历完了。

例题

题目描述

给定一个n×m的二维整数数组，用来表示一个迷宫，数组中只包含0或1，其中0表示可以走的路1表示不可通过的墙壁。

最初，有一个人位于左上角(1,1)处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。

请问，该人从左上角移动至右下角(n,m)处，至少需要移动多少次。

数据保证 (1,1) 处和 (n,m) 处的数字为0，且一定至少存在一条通路。

输入格式

第一行包含两个整数n和m。
接下来n行，每行包含m个整数(0或1),表示完整的二维数组迷宫。

输出格式

输出一个整数，表示从左上角移动至右下角的最少移动次数。

数据范围

$1\le n,m\le 100$

输入样例：

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

输出样例：

8

解题思路

通过题意我们能找到几个信息

1. 起点为(1,1)，终点为(n,m).
2. 每次能走上、下、左、右四个方向
3. ；遇到1时是墙壁，不能走，即如果下一步将要拓展到1的位置，则不必拓展，因为墙壁走不了，只有在0时才需要拓展。

首先为甚么这题会想到BFS呢？因为它要求起点到终点最短的距离，而我们知道BFS是一层一层向外拓展，即同时遍历的点一定是和起点的距离相同的点，那么第一个到达终点的点离起点的距离就一定是最短距离。

此前有一个小问题需要解决，就是既然一个点可以往4个方向延伸，那么也必然会延伸到延伸到自己这个点的点。即，假如从a可以延伸到b，那么从b也是可以延伸到a的，但是依据常理，我们从一个点既然往四面八方延伸了，那么则必不可能再回来，因为回来后又是往这个点的四面八方延伸，有悖常理。那么我们如何优化这个问题呢？
其实只需要加一个标记数组来标记这个点已经被遍历过了即可，又或者因为0是可以通过的，而1是不可以通过的，那么只要用这个性质，将我们遍历过的点都置为1即可。

用上面的思路：

1. 先定义一个队列q，将起点(1,1)入队，将起点标记为已遍历过。
2. 定义一个while循环，只要队列不空
3. 取出队头元素，在队列中删除队头元素，找到所有与队头元素表示的点距离为1的点，判断它们是否符合入队条件，符合则入队，不符合则不处理。然后距离数 + 1.
4. 当走到终点时，返回最短距离，结束循环。

代码

手写队列版

#include<iostream>
#include<cstring>
using namespace std;

const int N = 110,M = N * N;
int g[N][N]; // 存储图
int d[N][N]; // 存储点到起点的距离
int n,m;
pair<int,int> q[M]; // 队列

int dx[4] = {0,1,0,-1},dy[4] = {1,0,-1,0}; // 对应上、右、下、左

int bfs(int sx,int sy){
    memset(d,-1,sizeof d); // 将d初始化为-1，用来标记该点是否被遍历过。
    int hh = 0, tt = 0; // hh是队头，tt是队尾
    q[0] = {sx,sy}; // 将(sx,sy)入队
    d[1][1] = 0; // 起点的距离初始化为0
    
    while(hh <= tt){ // 队列不空
        auto t = q[hh ++]; // 取出队头元素，队列中删除队头元素
        
        if(t.first == n && t.second == m) return d[n][m]; // 假如到达了终点，则返回距离
        
        for(int i = 0; i < 4; i ++){ // 向上下左右四个方向拓展
            int a = t.first + dx[i],b = t.second + dy[i];
            
            if(a < 1 || a > n || b < 1 || b > m) continue; // 假如拓展的点出界则跳过
            if(g[a][b]) continue; // 假如拓展到的是墙壁，则跳过
            if(d[a][b] != -1) continue; // 假如该点已经走过了，则跳过
            
            d[a][b] = d[t.first][t.second] + 1; // 更新距离
            q[++ tt] = {a,b}; // 将(a,b)入队
        }
    }
}

int main(){
    cin >> n >> m;
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++) cin >> g[i][j];
    
    cout << bfs(1,1); // 从点(1,1)开始进行广度优先遍历
    
    return 0;
}

STL队列版

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;

const int N = 110,M = N * N;
int g[N][N]; // 存储图
int d[N][N]; // 存储点到起点的距离
int n,m;
queue<pair<int,int>> q; // 队列

int dx[4] = {0,1,0,-1},dy[4] = {1,0,-1,0}; // 对应上、右、下、左

int bfs(int sx,int sy){
    memset(d,-1,sizeof d); // 将d初始化为-1，用来标记该点是否被遍历过。
    q.push({sx,sy}); // 将(sx,sy)入队
    d[1][1] = 0; // 起点的距离初始化为0
    
    while(q.size()){ // 队列不空
        auto t = q.front(); // 取出队头元素
        q.pop(); // 队列中删除队头元素
        if(t.first == n && t.second == m) return d[n][m]; // 假如到达了终点，则返回距离
        
        for(int i = 0; i < 4; i ++){ // 向上下左右四个方向拓展
            int a = t.first + dx[i],b = t.second + dy[i];
            
            if(a < 1 || a > n || b < 1 || b > m) continue; // 假如拓展的点出界则跳过
            if(g[a][b]) continue; // 假如拓展到的是墙壁，则跳过
            if(d[a][b] != -1) continue; // 假如该点已经走过了，则跳过
            
            d[a][b] = d[t.first][t.second] + 1; // 更新距离
            q.push({a,b}); // 将(a,b)入队
        }
    }
}

int main(){
    cin >> n >> m;
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++) cin >> g[i][j];
    
    cout << bfs(1,1); // 从点(1,1)开始进行广度优先遍历
    
    return 0;
}