广度优先搜索算法带图详解

1.前言

广度优先搜索https://so.csdn.net/so/search?q=%E5%B9%BF%E5%BA%A6%E4%BC%98%E5%85%88%E6%90%9C%E7%B4%A2&spm=1001.2101.3001.7020（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历策略。因为它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域，故得名。

一般可以用它做什么呢？一个算法导论里边会给出不少严格的证明，我想尽量写得通俗一点，因此采用一些直观的讲法来伪装成证明，关键的point能够帮你get到就好。

2.图的概念

刚刚说的广度优先搜索是连通图的一种遍历策略，那就有必要将图先简单解释一下。

图2-1连通图示例图

如图2-1所示，这就是我们所说的连通图，这里展示的是一个无向图，连通即每2个点都有至少一条路径相连，例如V0到V4的路径就是V0->V1->V4。

一般我们把顶点用V缩写，把边用E缩写。

3.广度优先搜索

3.1.算法的基本思路

常常我们有这样一个问题，从一个起点开始要到一个终点，我们要找寻一条最短的路径，从图2-1举例，如果我们要求V0到V6的一条最短路（假设走一个节点按一步来算）【注意：此处你可以选择不看这段文字直接看图3-1】，我们明显看出这条路径就是V0->V2->V6，而不是V0->V3->V5->V6。先想想你自己刚刚是怎么找到这条路径的：首先看跟V0直接连接的节点V1、V2、V3，发现没有V6，进而再看刚刚V1、V2、V3的直接连接节点分别是：{V0、V4}、{V0、V1、V6}、{V0、V1、V5}（这里画删除线的意思是那些顶点在我们刚刚的搜索过程中已经找过了，我们不需要重新回头再看他们了）。这时候我们从V2的连通节点集中找到了V6，那说明我们找到了这条V0到V6的最短路径：V0->V2->V6，虽然你再进一步搜索V5的连接节点集合后会找到另一条路径V0->V3->V5->V6，但显然他不是最短路径。

你会看到这里有点像辐射形状的搜索方式，从一个节点，向其旁边节点传递病毒，就这样一层一层的传递辐射下去，知道目标节点被辐射中了，此时就已经找到了从起点到终点的路径。

我们采用示例图来说明这个过程，在搜索的过程中，初始所有节点是白色（代表了所有点都还没开始搜索），把起点V0标志成灰色（表示即将辐射V0），下一步搜索的时候，我们把所有的灰色节点访问一次，然后将其变成黑色（表示已经被辐射过了），进而再将他们所能到达的节点标志成灰色（因为那些节点是下一步搜索的目标点了），但是这里有个判断，就像刚刚的例子，当访问到V1节点的时候，它的下一个节点应该是V0和V4，但是V0已经在前面被染成黑色了，所以不会将它染灰色。这样持续下去，直到目标节点V6被染灰色，说明了下一步就到终点了，没必要再搜索（染色）其他节点了，此时可以结束搜索了，整个搜索就结束了。然后根据搜索过程，反过来把最短路径找出来，图3-1中把最终路径上的节点标志成绿色。

整个过程的实例图如图3-1所示。

初始全部都是白色（未访问）

即将搜索起点V0（灰色）

已搜索V0，即将搜索V1、V2、V3

……终点V6被染灰色，终止

找到最短路径

图3-1寻找V0到V6的过程

3.2.广度优先搜索流程图

图3-2广度优先搜索的流程图

在写具体代码之前有必要先举个实例，详见第4节。

4.实例

（1）

问题 A: 【一本通基础广度优先搜索】细胞

[题目描述]

一矩形阵列由数字 0 到 9 组成,数字 1 到 9 代表细胞,细胞的定义为沿细胞数字上下左右还是细胞数字则为同一细胞,求给定矩形阵列的细胞个数。

输入

一行两个数，N，M （1<=n,m<=100）
N*M的矩阵

输出

一个数据，表示细胞个数。

样例输入

4 10
0234500067
1034560500
2045600671
0000000089

样例输出

4

上代码

#include <bits/stdc++.h>
using namespace std;
 
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
int n, m;
int h[1000][3];
 
int bz[100][100];
int num;
int x, y;
int head, tail, i;
 
void doit(int a, int b)
{   
    head = 0, tail = 1;
    num++;
    bz[a][b] = 0;
    h[1][1] = a;
    h[1][2] = b;
    do
    {
        head++;
        for(i = 0; i <= 3; i++)
        {
            x = h[head][1] + dx[i];
            y = h[head][2] + dy[i];
            if((x >= 0) && (x < m) && (y >= 0) && (y < n) && (bz[x][y]))
            {
                tail++;
                bz[x][y] = 0;
                h[tail][1] = x;
                h[tail][2] = y;
            }
        }
    }while(head < tail);
}
 
int main()
{
    scanf("%d%d", &m, &n);
    char s[100][100];
    for(int i = 0; i < m; i++)
        for(int j = 0; j < n; j++)
            bz[i][j] = 1;
     
    int i, j;
    for(i = 0; i <= m - 1; i++)
    {
        for(j = 0; j <= n - 1; j++)
        {
            cin >> s[i][j];
        }
    }
    for(i = 0; i <= m - 1; i++)
    {
        for(j = 0; j <= n - 1; j++)
        {
            if(s[i][j] == '0')
                bz[i][j] = 0;
        }
    }
    //cout << i << ' ' << j << endl;
    for(int i = 0; i < m; i++)
        for(int j = 0; j < n; j++)
        {
            if(bz[i][j] == 1)
                doit(i, j); 
        }
    //cout << head << " " << tail << endl;          
    cout << num << endl;
    return 0;
}

问题 B: 【一本通基础广度优先搜索】 最少步数

[题目描述]

在各种棋中，一种棋子的走法总是一定的，如中国象棋中马走“日”。有一位小学生就想如果马能有两种走法将更加增加趣味性，因此，他规定马既能按“日”飞，也能各象一样走“田”字。他的同桌平时喜欢下围棋，知道这件事后觉得很有趣，就和他玩一种新游戏，在围棋盘上任选两点A、B，A点放上黑子，B点放上白子，代表两匹马。棋子可以按“日”字走，也可以按“田”字走，俩人一个走黑马，一个走白马。谁用最少的步数走到左上角坐标为(1,1)的点时，谁获胜。现在他请你帮忙，给你A，B两点的坐标，想知道两个位置到（1,1）点的可能最少步数。

输入

每行的两个整数，第一行为A点坐标

第二行为B点坐标

(* 注意:棋盘大小规模为100*100以内 *)

输出

两行第一行为A点到（1,1）的步数

第二行为B点到（1,1）的步数

样例输入

12 16
18 10

样例输出

8
9

#include <bits/stdc++.h>
using namespace std;
 
int dx[12] = {-2, -2, -1, 1, 2, 2, 2, 2, 1, -1, -2, -2};
int dy[12] = {-1, -2, -2, -2, -2, -1, 1, 2, 2, 2, 2, 1};
 
int main()
{
    int s[101][101], que[10000][4] = {0}, x1, x2, y1, y2;
    memset(s, 0xff, sizeof((s)));//s数组的初始化 
    int head = 1, tail = 1;//初始位置入队列 
    que[1][1] = 1;
    que[1][2] = 1;
    que[1][3] = 0;
    cin >> x1 >> y1 >> x2 >> y2;//读入黑马和白马的位置 
    while(head <= tail)//如果队列为空， 则拓展队首结点 
    {
        for(int i = 0; i <= 11; i++)//枚举12个拓展方向 
        {
            int x = que[head][1] + dx[i];
            int y = que[head][2] + dy[i];
            if(x > 0 && y > 0 && x <= 100 && y <= 100)
            {
                if(s[x][y] == -1)
                {
                    s[x][y] = que[head][3] + 1;
                    tail++;//（1， 1）到（x，y）的最小步数入队 
                    que[tail][1] = x;
                    que[tail][2] = y;
                    que[tail][3] = s[x][y];
                    if(s[x1][y1] > 0 && s[x2][y2] > 0)//输出答案 
                    {
                        cout << s[x1][y1] << endl;
                        cout << s[x2][y2] << endl;
                        return 0;
                    }
                }
            }
        }
        head++;
    }
    return 0;
}