BFS（广度优先遍历）
BFS（广度优先遍历）
1. BFS原理
原理
-
使用BFS可以求解最短路径，前提是：所有边的权值均相同。
-
使用队列完成BFS，在遍历的过程中，每次将队首的元素弹出，然后再将该队首相邻的且未被遍历的数据插入队尾，直到队列为空停止。
-
BFS可以解决的问题：
（1）
Floodfill：参考网址（2）最短路问题
（3）多源BFS问题
（4）最小步数问题
（5）双端队列广搜
（6）双向广搜
（7）A*
这里只讲解后六种类型。
-
BFS求最短路的正确性证明：
-
我们需要证明任意时刻队列中的数据具有：1. 两段性：最多有两段不同的数据；2. 单调性：队列后面的数据一定大于等于前面的数据
可以使用数学归纳法进行证明：
（1）刚开始队列中只有一个起点，到自己的距离为0，满足上面两条性质；
（2）假设某一时刻满足上面两条性质，那么
因此任意时刻队列都具有两段性和单调性。
-
证明完上述性质后，我们有两种方法证明BFS是正确的。
方法1：这里的队列相当于
dijstkra算法中的优先队列，因为dijstkra算法是正确的，所以BFS是正确的。方法2：使用数学归纳法+反证法证明，归纳假设为：所有已经出队的元素的最小值不会再改变了。
（1）当起点出队后，起点到自己的距离为0，是最小值，归纳的起点成立；
（2）假设某一时刻上述归纳假设成立，那么考虑下一时刻：
因此归纳假设成立，所以BFS是正确的。
-
2. 最短路问题
AcWing 844. 走迷宫
问题描述
-
问题链接：AcWing 844. 走迷宫
分析
- 在BFS的过程中使用二维数组记录可以到达的位置需要的步数即可
代码
- C++
#include AcWing 1076. 迷宫问题
问题描述
-
问题链接：AcWing 1076. 迷宫问题
分析
- 使用一个二维pre数组，记录到达某点的前一个是什么
- 为了最终输出从
(0, 0)->(n - 1, n - 1)的路径，我们反向遍历即可，即从(n - 1, n - 1)遍历到(0, 0)
代码
- C++
#include AcWing 188. 武士风度的牛
问题描述
-
问题链接：AcWing 188. 武士风度的牛
分析
- 使用偏移量技巧，可以很方便的遍历8个方向
代码
- C++
#include AcWing 1100. 抓住那头牛
问题描述
-
问题链接：AcWing 1100. 抓住那头牛
分析
- 我们可以发现N的变化的过程中不可能变为负数，如果变为负数的话，只有通过
N=N+1才能变为正数，花费的时间变长。 - 如果
N>K，我们只能用过-1得到结果，否则我们可以通过三者的组合得到K，并且在过程中数据大小不会超过K+1。 - 题目是一定有解的，因为最差我们可以挺过
+1或者-1得到结果。
代码
- C++
#include 3. 多源BFS
AcWing 173. 矩阵距离
问题描述
-
问题链接：AcWing 173. 矩阵距离
分析
- 本题中的1相当于超市，0相当于住户，需要求解每个住户距离最近的一个超市的距离。
- 1相当于超市，也是上图中的起点。代码实现的时候并不需要创建虚拟源点，只需要在最开始的时候将所有1的位置加入到队列中即可，然后执行BFS得到结果。
代码
- C++
#include 4. 最小步数模型
之前的问题都是在一个二维数组中操作，从二维数组中的某个点到达数组中的另外一个点。
下面的两个问题中每个二维数组可以看成一种状态，类似于棋盘，每操作一步转换成一种状态。
AcWing 845. 八数码
问题描述
-
问题链接：AcWing 845. 八数码
分析
代码
- C++
#include AcWing 1107. 魔板
问题描述
-
问题链接：AcWing 1107. 魔板
分析
-
思路：首先将"12345678"放到队列的队头，然后用宽搜搜索可以到达的状态，直到搜到终点为止。
-
每一次扩展的时候分别做一下A、B、C三种操作，做完之后得到一个字符串，然后判断这个字符串是否被搜到过，如果没有搜到过的话，把它的距离更新一下，然后存到队列中。
-
因为要输出方案，我们记录一下每个状态是从哪个状态更新过来的即可。
-
如何保证存在多个方案时，输出字典序最小的方案呢？我们在扩展的时候按照A、B、C三种方案进行扩展即可。可以使用数学归纳法证明：任意时刻按照A、B、C三种方案进行扩展得到的序列字典序是最小的。
（1）刚开始序列为空，归纳假设显然成立。
（2）假设某一时刻上述归纳假设成立，那么考虑下一时刻：
代码
- C++
#include 5. 双端队列广搜
AcWing 175. 电路维修
问题描述
-
问题链接：AcWing 175. 电路维修
分析
代码
- C++
// 非常类似于dijskra
#include 6. 双向广搜
AcWing 190. 字串变换
问题描述
-
问题链接：AcWing 190. 字串变换
分析
- 使用两个队列从起点和终点同时扩展，每次选择状态比较少的一端进行扩展，这样可以大大降低需要搜索的空间。
- 注意：每次必须将一层的点全部扩展，否则会出现问题
上图来自：题解
代码
- C++
#include 7. A*
A*算法原理
AcWing 178. 第K短路
问题描述
-
问题链接：AcWing 178. 第K短路
分析
-
这一题的估价函数：每个点到终点的最短距离。这个可以反向求解，只需要在反向图上跑一边
dijkstra算法即可。 -
那么如何求解第K短路呢？
当终点第一次从队列中弹出来的时候，一定是最短路径（上面A*算法中已经证明了）。因此可以猜想，当终点从队列中第K次弹出来的时候，就是第K短路径，这个猜想的证明思路是类似的，只需要证明第二次弹出的是第二小的即可，也可以使用反证法，将上面A*算法证明中的最小值换成第二小值即可。
代码
- C++
#include AcWing 179. 八数码
问题描述
-
问题链接：AcWing 179. 八数码
分析
- 八数码问题有解 等价于 按行展开后逆序对的数量为偶数
- 这里的估价函数取为所有点到其最终位置的曼哈顿距离之和，这个值一定是小于最优解的。
代码
- C++
#include 3. 力扣上的BFS题目
Leetcode 0127 单词接龙
问题描述
-
问题链接：Leetcode 0127 单词接龙
分析
- 对于每个单词可以变成哪些单词，直接枚举即可。
代码
- C++
/**
* 执行用时：160 ms, 在所有 C++ 提交中击败了59.48%的用户
* 内存消耗：15.7 MB, 在所有 C++ 提交中击败了34.35%的用户
*/
class Solution {
public:
unordered_set<string> S;
unordered_map<string, int> dist; // 距离数组，同时具有判重的作用
queue<string> q;
int ladderLength(string beginWord, string endWord, vector<string> &wordList) {
for (auto word : wordList) S.insert(word);
dist[beginWord] = 0;
q.push(beginWord);
while (q.size()) {
auto t = q.front();
q.pop();
string r = t;
for (int i = 0; i < t.size(); i++) {
t = r;
for (char j = 'a'; j <= 'z'; j++) {
t[i] = j;
if (S.count(t) && dist.count(t) == 0) {
dist[t] = dist[r] + 1;
if (t == endWord) break;
q.push(t);
}
}
}
}
return dist[endWord] != 0 ? dist[endWord] + 1 : 0;
}
};
- Java
/**
* Date: 2021/3/18 10:01
* 执行用时：283 ms, 在所有 Java 提交中击败了35.26%的用户
* 内存消耗：42.1 MB, 在所有 Java 提交中击败了18.79%的用户
*/
class Solution {
HashSet<String> S = new HashSet<>();
HashMap<String, Integer> dist = new HashMap<>();
Queue<String> q = new LinkedList<>();
public int ladderLength(String beginWord, String endWord, List<String> wordList) {
S.addAll(wordList);
q.add(beginWord);
dist.put(beginWord, 0);
while (!q.isEmpty()) {
String t = q.remove();
for (int i = 0; i < t.length(); i++)
for (char j = 'a'; j <= 'z'; j++) {
String r = t.substring(0, i) + j + t.substring(i + 1);
if (S.contains(r) && !dist.containsKey(r)) {
dist.put(r, dist.get(t) + 1);
if (endWord.equals(r)) break;
q.add(r);
}
}
}
return dist.getOrDefault(endWord, -1) + 1;
}
}
Leetcode 0126 单词接龙 II
问题描述
-
问题链接：Leetcode 0126 单词接龙 II
分析
- 分为两步：(1) 正向bfs，求出起点到其他点的最短距离，用于剪枝 (2) 反向暴搜
代码
- C++
/**
* 执行用时：144 ms, 在所有 C++ 提交中击败了76.80%的用户
* 内存消耗：15.5 MB, 在所有 C++ 提交中击败了75.43%的用户
*/
class Solution {
public:
unordered_set<string> S;
unordered_map<string, int> dist; // 距离数组，同时具有判重的作用
queue<string> q;
vector<vector<string>> ans;
vector<string> path;
string beginWord;
vector<vector<string>> findLadders(string _beginWord, string endWord, vector<string> &wordList) {
for (auto word : wordList) S.insert(word);
beginWord = _beginWord;
dist[beginWord] = 0;
q.push(beginWord);
while (q.size()) {
auto t = q.front();
q.pop();
string r = t;
for (int i = 0; i < t.size(); i++) {
t = r;
for (char j = 'a'; j <= 'z'; j++) {
t[i] = j;
if (S.count(t) && dist.count(t) == 0) {
dist[t] = dist[r] + 1;
if (t == endWord) break;
q.push(t);
}
}
}
}
if (!dist.count(endWord)) return ans;
path.push_back(endWord);
dfs(endWord);
return ans;
}
void dfs(string t) {
if (t == beginWord) {
reverse(path.begin(), path.end());
ans.push_back(path);
reverse(path.begin(), path.end());
} else {
string r = t;
for (int i = 0; i < t.size(); i++) {
t = r;
for (char j = 'a'; j <= 'z'; j++) {
t[i] = j;
// 不能使用S.count(t), 因为起点不一定在S中
// dist[t] 表示t到起点的距离, 这里进行了剪枝
if (dist.count(t) && dist[t] + 1 == dist[r]) {
path.push_back(t);
dfs(t);
path.pop_back();
}
}
}
}
}
};
- Java
/**
* Created by WXX on 2021/3/18 9:29
* 执行用时：254 ms, 在所有 Java 提交中击败了58.92%的用户
* 内存消耗：42.3 MB, 在所有 Java 提交中击败了78.18%的用户
*/
public class Solution {
HashSet<String> S = new HashSet<>();
HashMap<String, Integer> dist = new HashMap<>();
Queue<String> q = new LinkedList<>();
List<List<String>> ans = new ArrayList<>();
ArrayList<String> path = new ArrayList<>();
String beginWord;
public List<List<String>> findLadders(String _beginWord, String endWord, List<String> wordList) {
S.addAll(wordList);
beginWord = _beginWord;
q.add(beginWord);
dist.put(beginWord, 0);
while (!q.isEmpty()) {
String t = q.remove();
for (int i = 0; i < t.length(); i++)
for (char j = 'a'; j <= 'z'; j++) {
String r = t.substring(0, i) + j + t.substring(i + 1);
if (S.contains(r) && !dist.containsKey(r)) {
dist.put(r, dist.get(t) + 1);
if (endWord.equals(r)) break;
q.add(r);
}
}
}
if (!dist.containsKey(endWord)) return ans;
path.add(endWord);
dfs(endWord);
return ans;
}
private void dfs(String t) {
if (beginWord.equals(t)) {
Collections.reverse(path);
ans.add((List<String>) path.clone());
Collections.reverse(path);
} else {
for (int i = 0; i < t.length(); i++)
for (char j = 'a'; j <= 'z'; j++) {
String r = t.substring(0, i) + j + t.substring(i + 1);
if (dist.containsKey(r) && dist.get(r) + 1 == dist.get(t)) {
path.add(r);
dfs(r);
path.remove(path.size() - 1);
}
}
}
}
}
Leetcode 0675 为高尔夫比赛砍树
问题描述
-
问题链接：Leetcode 0675 为高尔夫比赛砍树
分析
- 将树从小到大排序。然后求两点之间的最短路径，有多少棵树求多少次bfs。
代码
- C++
/**
* 执行用时：892 ms, 在所有 C++ 提交中击败了33.96%的用户
* 内存消耗：174.7 MB, 在所有 C++ 提交中击败了10.38%的用户
*/
class Solution {
public:
struct Tree {
int x, y, h; // 位于(x, y)的树的高度为h
bool operator<(const Tree &t) const {
return h < t.h;
}
};
int n, m;
vector<vector<int>> g;
int bfs(Tree st, Tree ed) {
if (st.x == ed.x && st.y == ed.y) return 0; // 起点终点都是出发点
queue<Tree> q;
vector<vector<int>> dist(n, vector<int>(m, -1));
dist[st.x][st.y] = 0;
q.push(st);
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
while (q.size()) {
auto t = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int x = t.x + dx[i], y = t.y + dy[i];
if (x >= 0 && x < n && y >= 0 && y < m && g[x][y]) {
if (dist[x][y] == -1) { // 没有判重数组，必须有这句话
dist[x][y] = dist[t.x][t.y] + 1;
if (x == ed.x && y == ed.y) return dist[x][y];
q.push({x, y});
}
}
}
}
return -1;
}
int cutOffTree(vector<vector<int>> &forest) {
g = forest;
n = g.size(), m = g[0].size();
vector<Tree> trs;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (g[i][j] > 1)
trs.push_back({i, j, g[i][j]});
sort(trs.begin(), trs.end());
Tree last = {0, 0};
int res = 0;
for (auto &tr : trs) {
int t = bfs(last, tr); // last -> tr
if (t == -1) return -1;
res += t;
last = tr; // 更新last
}
return res;
}
};
- Java
/**
* Created by WXX on 2021/3/7 18:51
* 执行用时：242 ms, 在所有 Java 提交中击败了96.69%的用户
* 内存消耗：38.7 MB, 在所有 Java 提交中击败了87.60%的用户
*/
public class Solution {
static class Tree implements Comparable<Tree> {
int x, y, h;
public Tree(int x, int y, int h) {
this.x = x;
this.y = y;
this.h = h;
}
@Override
public int compareTo(Tree o) {
return this.h - o.h;
}
}
int n, m;
int[][] g;
private int bfs(Tree st, Tree ed) {
if (st.x == ed.x && st.y == ed.y) return 0;
Queue<Tree> q = new LinkedList<>();
int[][] dist = new int[n][m];
for (int i = 0; i < n; i++) Arrays.fill(dist[i], 0x3f3f3f3f);
dist[st.x][st.y] = 0;
q.add(st);
int[] dx = {-1, 0, 1, 0}, dy = {0, 1, 0, -1};
while (!q.isEmpty()) {
Tree t = q.remove();
for (int i = 0; i < 4; i++) {
int x = t.x + dx[i], y = t.y + dy[i];
if (x >= 0 && x < n && y >= 0 && y < m && g[x][y] != 0) {
if (dist[x][y] > dist[t.x][t.y] + 1) {
dist[x][y] = dist[t.x][t.y] + 1;
if (x == ed.x && y == ed.y) return dist[x][y];
q.add(new Tree(x, y, -1));
}
}
}
}
return -1;
}
public int cutOffTree(List<List<Integer>> forest) {
n = forest.size();
m = forest.get(0).size();
g = new int[n][m];
List<Tree> trs = new ArrayList<>();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
g[i][j] = forest.get(i).get(j);
if (g[i][j] > 1) trs.add(new Tree(i, j, g[i][j]));
}
Collections.sort(trs);
Tree last = new Tree(0, 0, -1);
int res = 0;
for (Tree tr : trs) {
int t = bfs(last, tr);
if (t == -1) return -1;
res += t;
last = tr;
}
return res;
}
}