*注：如果还没有学过 结构体 或者 栈/队列/优先队列 的同学请仔细看完我的总结哦~

一、广度优先搜索

1. 意义

广度优先搜索（Breadth-first search，简称BFS），别名宽度优先搜索，是一种搜索算法。但是相较于深度优先搜索（Depth-first search，简称DFS），对于某些题目，时间复杂度更低。举个例子，对于走迷宫哪条路径最短，BFS 找来很多人一起走，只要出现有人走到终点的情况，那么这条路径必定是最短的，而 DFS 不能。

2. 分析

假如有这样一个迷宫：

	1	2	3	4	5
1		*
2		*		*
3
4		*	*	*
5				*

步数	位置	存活
0	（1，1）	1
1	（2，1）	1
2	（3，1）	2
3	（4，1）/（3，2）	1 / 1
4	（3，3）/（5，1）	2 / 1
5	（2，3）（3，4）/（5，2）	…
…	…	…

3. 基本程序

首先我们要理解为什么要用队列，这是因为在每次人没有存活的时候就要删除一开始的元素，那么用队列会更方便。

结构体队列的定义方法：

#include <queue>
struct Node
{int x;bool flag;char c;
}; // 记得写分号
queue <Node> q;
q.push({1, 0, 'c'}); // 入队
auto [a, b, c] = q.front(); // 获取队首元素
cout << a << " " << b << " " << c; // 输出: 1 0 'c'

伪代码如下：

void bfs()
{vis[1][1] = 1; // 起点标记q.push({1, 1, 0}); // 起点入队while (!q.empty) // 非空时{// 获取队首元素并出队// 判断是否为终点// 是：结束// 遍历四个方向// 获得新的x,y坐标，存为tx,ty// 判断能否走（边界，障碍，访问）// 能走：tx,ty,step+1入队}
}

二、例题

1. 最短路径模板

#include <iostream>
#include <queue>
using namespace std;struct Node
{int x, y; // 当前坐标int step; // 当前步数
};int n;
int a[105][105];
int sx, sy, ex, ey;
queue <Node> q; // 结构体队列
bool vis[105][105];
int dx[5] = {-1, 0, 0, 1};
int dy[5] = {0, -1, 1, 0};void bfs()
{vis[sx][sy] = 1; // 起点标记q.push({sx, sy, 0}); // 起点入队while (!q.empty()) // 非空时{// 获取队首元素并出队auto [fx, fy, fstep] = q.front();q.pop();// 判断是否为终点if (fx==ex && fy==ey){cout << fstep;return;}// 遍历四个方向for (int i = 0; i <= 3; i++){int tx = fx+dx[i];int ty = fy+dy[i];if (a[tx][ty]==0 && tx>=1 && tx<=n && ty>=1 && ty<=n && vis[tx][ty]==0){vis[tx][ty] = 1;q.push({tx, ty, fstep+1});}}}
}int main()
{// 输入cin >> n;for (int i = 1; i <= n; i++)for (int j = 1; j <= n; j++)cin >> a[i][j];cin >> sx >> sy >> ex >> ey;// bfsbfs();return 0;
}

2. 跳跃的马

2.1 审题

根据国际象棋规则，马只能走日字格。现在给定你一个 $n\times m$ 的矩阵，已知小马在矩阵的 (x, y)，请你给出一个步数矩阵，计算每个格子到达的步数（不能到达就填充 -1）。文件：horse.cpp。要求行末尾没有空格。

输入：

3 3 1 1

输出：

0 3 2
3 -1 1
2 1 4

2.2 思路

明确日子格的偏移量！

$x$ 偏移量	$y$ 偏移量
-2	-1
-1	-2
1	-2
2	-1
-2	1
-1	2
1	2
2	1

2.3 参考答案

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;struct Node
{int x, y;int step;
};int n, m;
int x, y;
int a[105][105];
int dx[10] = {-2, -1, 1, 2, -2, -1, 1, 2};
int dy[10] = {-1, -2, -2, -1, 1, 2, 2, 1};
queue <Node> q;void bfs()
{a[x][y] = 0; // 起点标记q.push({x, y, 0}); // 起点入队while (!q.empty()) // 非空时{// 获取队首元素并出队auto [fx, fy, fstep] = q.front();q.pop();// 遍历八个方向for (int i = 0; i <= 7; i++){int tx = fx+dx[i];int ty = fy+dy[i];if (tx>=1 && tx<=n && ty>=1 && ty<=m && a[tx][ty]==-1){a[tx][ty] = fstep+1;q.push({tx, ty, fstep+1});}}}
}int main()
{freopen("horse.in", "r", stdin);freopen("horse.out", "w", stdout);// 输入cin >> n >> m >> x >> y;memset(a, -1, sizeof(a));// bfsbfs();// 输出for (int i = 1; i <= n; i++){for (int j = 1; j <= m; j++){cout << a[i][j] << " \n"[j==m];}}fclose(stdin);fclose(stdout);return 0;
}

3. 今天就上 $200$ 层

3.1 审题

题目描述

《今天就上 $200$ 层》是一款考验玩家策略的益智类游戏，游戏中需要操控 yls 上到摩天大楼的第 $200$ 层，摩天大楼的每一层都有一个光圈，光圈上会显示一个数字 $k_i$，光圈有 $2$ 个箭头，一个向上，一个向下，上下的层数等于光圈上的数字，但注意，并不是所有的光圈都是有效的，例如 $3$ $3$ $1$ $2$ $5$ 代表 $k_i$（$k_1=3$，$k_2=3$…），如果 yls 当前在 $1$ 层，选择"上"的箭头可以到达 $4$ 层，选择"下"的箭头是不起作用的，因为没有 $-2$ 层。
假设 yls 在 $x$ 层，想要到 $y$ 层，至少需要选择几次光圈？

输入描述

输入共 $2$ 行。
第一行为三个用空格隔开的正整数，表示 $n$（表示摩天大楼的层数）$,x,y$（$1\le n\le 200$，$1\le x,y\le n$）。
第二行为 $n$ 个用空格隔开的非负整数，表示 $k_i$（$1\le k_i\le n$）。

输出描述

一行，即最少按键次数，若无法到达，则输出 $-1$。

样例1

输入

5 1 5
3 3 1 2 5

输出

3

3.2 参考答案

#include <iostream>
#include <queue>
using namespace std;struct Node
{int f;int step;
};int n;
int s, e;
int k[205];
bool vis[205];
queue <Node> q;void bfs()
{vis[s] = 1; // 起点标记q.push({s, 0}); // 起点入队while (!q.empty()){// 获取队首元素并出队auto [ff, fstep] = q.front();q.pop();// 判断是否为终点if (ff == e){cout << fstep;return;}// 往上走int up = ff+k[ff];if (up<=n && vis[up]==0){vis[up] = 1;q.push({up, fstep+1});}// 往下走int down = ff-k[ff];if (down>=1 && vis[down]==0){vis[down] = 1;q.push({down, fstep+1});}}cout << -1;return;
}int main()
{// 输入cin >> n >> s >> e;for (int i = 1; i <= n; i++)cin >> k[i];// bfsbfs();return 0;
}

三、DFS VS. BFS

BFS 适用于求源点和目标结点距离近的情况，例如求最少步数；
DFS 适用于求解一个任意符合方案中的一种或者遍历所有情况，例如能否到达、求所有路径数、全排列。

对于不同的题目，二者的优势也各不相同，在今天的三道例题中都推荐用时间复杂度更低的 BFS。