算法初探系列4 - 广度优先搜索之图上搜索

概述
广度优先搜索,又称宽度优先搜索,简称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