概述
广度优先搜索,又称宽度优先搜索,简称bfs.
与dfs不同的是,bfs是从根节点开始,先搜索较近的点再搜索较远的点,就像水波扩散一样.
如上图.
此图的dfs序为:A - B - E - F - C - D - G
此图的bfs序为:A - B - C - D - E - F - G
bfs点的层次是很明显的.
第一层:A
第二层:B,C,D
第三层:E,F,G
蒟蒻君小测验
观察上面那张图,可能的bfs序列有哪些呢?
- a. A - D - B - C - E - F - G
- b. B - A - C - D - G - F - E
- c. A - D - C - B - G - F - E
答案:ac
实现步骤
bfs需要借助队列(queue)来实现.
- step1:初始把起点放在队列中,并标记为已访问.
- step2:如果队列不为空,则从中取出队顶值u,否则结束算法.
- step3:访问和u相连的所有点,如果目前的点没有被访问过,则入队,并标记为已访问.
- step4:重复执行step2.
代码框架
void bfs(起点) {
将起点入队
标记为已访问
while (队列非空) {
访问队顶元素u
删除队顶元素
for (所有与u相邻的点) {
if (合法且未访问) {
将该点入队
}
}
}
}
迷宫的最短路
- 题目
小猪猪又来啦~
情人节到了,小猪猪要去给小花猪送花花啦~
有一个一个n*m的大猪窝.农场主因不想让它们谈恋爱,将小猪猪放到了(1,1),将小花猪放到了(n,m).
用’A’表示小猪猪,'B’表示小花猪.'P’表示别的猪猪(猪猪不能从猪猪上走).'R’表示路径(可走),小猪猪为了尽快让小花猪收到玫瑰,让你帮他筹划一种路径,你需要告诉他最少要走几步(一步一个格子).
这道题dfs明显很简单. - dfs代码
#include <bits/stdc++.h>
using namespace std;
const int dir_arr[4][2] = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}}; // 方向数组
const int maxn = 1005;
int n, m; // 猪圈大小
int res = 0x3f3f3f3f; // 答案
char G[maxn][maxn]; // 猪圈
bool vis[maxn][maxn]; // 是否访问过
inline bool in(int x, int y) { // 判断(x,y)是否在猪圈中
return x >= 1 && x <= n && y >= 1 && y <= m;
}
void dfs(int x, int y, int stp) {
if (stp >= res) { // 可行性剪枝
return ;
}
// 递归终止条件:到达小花猪的地方
if (x == n && y == m) {
res = stp;
return ;
}
for (int i = 0; i < 4; ++i) {
int nxt_x = x + dir_arr[i][0];
int nxt_y = y + dir_arr[i][1];
// 可行性剪枝(vis数组)
if (in(nxt_x, nxt_y) && G[nxt_x][nxt_y] != 'P' && !vis[nxt_x][nxt_y]) {
vis[nxt_x][nxt_y] = true;
dfs(nxt_x, nxt_y, stp + 1); // 走出这一步
vis[nxt_x][nxt_y] = false; // 退回来
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> G[i][j];
}
}
dfs(1, 1, 0);
cout << res << '\n';
return 0;
}
显然,这个算法的时间复杂度有些高了.
这里就会用到我们的bfs啦.
由于bfs是分层搜索,所以第一次搜到终点的时候,当前搜索的层数就是答案.
- bfs代码
#include <bits/stdc++.h>
using namespace std;
const int dir_arr[4][2] = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}}; // 方向数组
const int maxn = 1005;
int n, m; // 猪圈大小
char G[maxn][maxn]; // 猪圈
bool vis[maxn][maxn]; // 是否访问过
struct node { // x,y表示这个点的坐标,stp表示起点到这个点的最小步数(层数)
int x, y;
int stp;
node(int _x, int _y, int _stp) {
x = _x;
y = _y;
stp = _stp;
}
};
inline bool in(int x, int y) { // 判断(x,y)是否在猪圈中
return x >= 1 && x <= n && y >= 1 && y <= m;
}
const int st_x = 1, st_y = 1; // 起点坐标
int bfs() {
queue<node> Q;
Q.push(node(st_x, st_y, 0)); // 起点入队
vis[st_x][st_y] = true; // 标记为"已访问"
while (Q.size()) { // 队列为空,则结束bfs函数
node u = Q.front(); // 当前点
Q.pop();
for (int i = 0; i < 4; ++i) { // 遍历每个方向
int v_x = u.x + dir_arr[i][0];
int v_y = u.y + dir_arr[i][1];
// 如果v点合法
if (in(v_x, v_y) && G[v_x][v_y] != 'P' && !vis[v_x][v_y]) {
// 如果到达小母猪的位置,返回v_stp = u.stp + 1
if (G[v_x][v_y] == 'B') {
return u.stp + 1;
} else {
vis[v_x][v_y] = true; // 标记
Q.push(node(v_x, v_y, u.stp + 1)); // 当前点入队
}
}
}
}
}
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() << '\n';
return 0;
}
再来一道题
可爱的小猪猪扶老奶奶过马路,这个老奶奶给了他一种超能力…
小猪猪由于追小母猪,没时间吃饭,他现在很饿.
这条路有n米长(超过n米就会掉进粪坑里,小猪猪很爱干净),小猪猪在地a米,食盆在第b米.
小猪猪每秒可以向前移动一米,也可以向后移动一米.他的超能力还可以让他用一秒的时间将从起点到现在它的位置翻倍(如5米可以变成10米),小猪猪想让你帮他计算一下最少要几秒的时间能正好到达食盆.
- 思路
我们可以利用bfs求解.每次搜索时按三种规则进行位置改变.每个地方只能经过一次(相当于可行性剪枝),时间复杂度O(n). - 代码
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10005; // 假设n最大为10000
int dis[maxn]; // dis[i]表示从起点到第i米的最小步数
bool vis[maxn]; // vis[i]表示地i米是否走过
int n, a, b;
int bfs() {
queue<int> Q;
Q.push(a); // 起点入队
vis[a] = true;
while (Q.size()) {
int u = Q.front();
Q.pop();
if (u == b) { // 到终点就return
return dis[u];
}
for (int i = 0; i < 3; ++i) { // 枚举每种规则
int v; // 下一步的位置
if (i == 0) {
v = u - 1;
} else if (i == 1) {
v = u + 1;
} else {
v = u * 2;
}
if (v >= 0 && v <= n && !vis[v]) { // 若合法且未访问
dis[v] = dis[u] + 1; // 标记并入队
vis[v] = true;
Q.push(v);
}
}
}
// 不可能没有路径
}
int main() {
cin >> n >> a >> b;
cout << bfs() << '\n';
return 0;
}
讨论小组(图的连通块)
- 题目描述
作为猪猪学校的老师,对于任意一头小猪猪,Mr.Juruo决定让与他相邻或者他相邻的相邻的同学(多少个相邻都可以)的同学们讨论问题,这些同学会形成一个讨论圈。
现在有n位小猪猪,其中m对小猪猪是相邻的。Juruo老师让聪明的你帮助他求有多少个讨论圈。 - 思路分析
题目大意其实很简单(蒟蒻君的小猪猪确实敲可耐哒),就是有n个点,m条边,让你求图中的连通块个数。
这里我们可以用链表存储图,用bfs求解。 - 代码
#include <bits/stdc++.h>
using namespace std;
vector<int> G[1005]; // 使用vector链式存图
bool vis[1005];
void bfs(int st) {
queue<int> q;
q.push(st);
vis[st] = true;
while (q.size()) {
int u = q.front();
q.pop();
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
// 如果v未访问并且与u联通,则加入这个连通块
if (!vis[v]) {
vis[v] = true;
q.push(v);
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
// u,v是连通的
G[u].push_back(v);
G[v].push_back(u);
}
int res = 0;
for (int i = 1; i <= n; ++i) {
if (!vis[i]) { // 这个点还未被访问,说明这里有一个新的连通块
++res;
bfs(i);
}
}
cout << res << '\n';
return 0;
}
喜欢的就继续往下看ba