[算法和数据结构]--回溯算法之BFS初识
回溯算法----BFS
- BFS介绍(Breadth First Search)
- BFS经典例题
-
- 1.N叉树的层次遍历
- 2. 腐烂的桔子
- 3. 单词接龙
- 4. 打开转盘锁
BFS介绍(Breadth First Search)
DFS 是一条路走到黑，BFS就是一石激起千层浪。用我们以前学过的知识来说DFS相当于二叉树中的前序遍历，BFS就相当于二叉树中的层次遍历。
我们先来思考一下迷宫问题：
✨问题描述：
假设有一个迷宫，里面有障碍物，迷宫用二维矩阵表示，标记为0的地方表示可以通过，标记为1的地方表示障碍物，
不能通过。现在给一个迷宫出口，让你判断是否可以从入口进来之后，走出迷宫，每次可以向任意方向走。
✨案例代码：
迷宫问题可以用DFS，但是我用BFS来解决这个迷宫问题。
因为如果这个题目变化一下求最短路径长度的话，BFS会更加方便一些。
public static void main(String[] args) {
int[][] Mat = {{0,0,1,0},
{1,0,0,1},
{0,0,0,0},
{1,1,0,0}};
Scanner sc = new Scanner(System.in);
while (true){
System.out.println("起点，终点");
int sx = sc.nextInt();
int sy = sc.nextInt();
int ex = sc.nextInt();
int ey = sc.nextInt();
System.out.println(BFS(Mat,sx,sy,ex,ey));
}
}
我们输入一个起始位置和结束位置，然后判断其是否会从起始位置到结束位置？
比如：
输入：0 0 1 1
输出：true
输入：0 0 0 4
输出：false
✨问题分析：
这个问题使用的是BFS，我们也是需要像DFS一样需要向四周寻找，但是DFS是向四周寻找完成以后再次进行更加外层的查找，属于一层一层的查找。我们对于此问题我们可以先查找完一层后，把该层的数据放到一个队列中去，找完一层后，再根据队列中存储的结点去寻找下一层。
✨解题代码：
class Pair{
int x;
int y;
public Pair(int x, int y) {
this.x = x;
this.y = y;
}
}
private static boolean BFS(int[][] mat, int sx, int sy, int ex, int ey) {
Queue<Pair> qu = new LinkedList<>();//创建存储当前广度优先步数的位置个数
int[][] nextP = {{1,0},{-1,0},{0,1},{0,-1}};//搜索数组
qu.offer(new Pair(sx,sy));//将初始位置放进去
while (!qu.isEmpty()){//队列中的元素不为空
int size = qu.size();//记录当前队列的大小，以便我们把队列中的元素全部拿出来，然后用队列存储下一步的所有位置。
while (size-- != 0){
Pair pair = qu.poll();
if (pair.x == ex && pair.y == ey){//判断改位置是否是终点
return true;
}
for (int i = 0; i < 4; i++) {
int newX = pair.x + nextP[i][0];
int newY = pair.y + nextP[i][1];
if (newX < 0 || newX >= mat.length
||newY < 0 || newY >= mat[0].length){
continue;
}
if (mat[newX][newY] == 0){
mat[newX][newY] = 2;//标记此位置已经被搜索过了。
System.out.println(newX + " " + newY);
qu.offer(new Pair(newX,newY));
}
}
}
}
return false;
}
我们这个题目如果改编为求最短路径的长度的话，我们可以定义一个我计数器，把每次while()循环都进行+1，可以把判断到达终点的时候，我们就可以输出最短路径的长度了。
BFS 算法的基本步骤：
BFS(){
1.建立起始步骤队列的初始化
2.遍历队列中的每一种可能， while（队列不为空）{
通过队头元素带出下一步的所有可能，并依次入队
{
判断当前情况是否达成目标:按照目标来处理逻辑
}
继续遍历队列中的剩余情况。
}
}
BFS经典例题
1.N叉树的层次遍历
原题链接
✨问题描述：
给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
✨题目案例：
案例1：
![[算法和数据结构]--回溯算法之BFS初识_第1张图片](http://img.e-com-net.com/image/info8/8627a3c38fa84ff8a7bca2d5a23db88d.jpg)
输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]
案例2：
![[算法和数据结构]--回溯算法之BFS初识_第2张图片](http://img.e-com-net.com/image/info8/ecab6445c07048608acfc0c54bde9fcd.jpg)
输入：root =[1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
✨题目分析：
此问题就是一个经典的BFS问题，对于此问题我们完全可以按照BFS的基本步骤就可以把它给写出来。这个题目唯一需要注意的一点就是对于N叉树为空，我们就可以直接返回结果，不需要进行下面操作
✨解题代码：
public List<List<Integer>> levelOrder(Node root) {
List<List<Integer>> treeMat = new LinkedList<>();
if (root == null){//如果根节点为null，就直接返回一个什么也没有的List
return treeMat;
}
Queue<Node> qu = new LinkedList<>();//存放当前层次的遍历结果
qu.offer(root);
while (!qu.isEmpty()){
List<Integer> rowV = new ArrayList<>();//存放当前层的遍历结果，最后存储到treeMat
int size = qu.size();
while (size > 0){//对当前层的结点进行遍历，搜索下一层的子节点
rowV.add(qu.peek().val);
List<Node> curNode = qu.poll().children;//孩子节点是个链表
for (Node ch:curNode) {
qu.add(ch);
}
size--;
}
treeMat.add(rowV);
}
return treeMat;
}
2. 腐烂的桔子
原题链接
✨问题描述：
在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：
- 值 0 代表空单元格；
- 值 1 代表新鲜橘子；
- 值 2 代表腐烂的橘子。
每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。
返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。
✨题目案例：
案例1：
![[算法和数据结构]--回溯算法之BFS初识_第3张图片](http://img.e-com-net.com/image/info8/fcb5bcd09e994252b348fc8273110f8a.jpg)
输入：grid = [[2,1,1],[1,1,0],[0,1,1]]
输出：4
案例2：
输入：grid = [[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。
案例3：
输入：grid = [[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。
✨题目分析：
本题目是用BFS来进行解决的。我们这个问题是针对坐标的遍历所以我们必须定义一个含有x,y坐标的类，创建一个搜索队列，队列中的数据类型就是坐标类。我们首先搜索到整个区域中的桔子，把桔子加入到进行BFS的队列中，定义一个step变量进行记录我们桔子全部变坏所需要的时间，然后进行BFS。我们进行搜索的时候，我们四周搜索，这样我们就可以使用nextP数组，对周围的方向进行搜索。
✨解题代码：
class Pair{
int x;
int y;
public Pair(int x, int y) {
this.x = x;
this.y = y;
}
}
class Solution {
public int orangesRotting(int[][] grid) {
Queue<Pair> qu = new LinkedList<>();//存储需要搜索的坏桔子
int row = grid.length;
int col = grid[0].length;
for (int i = 0; i < row; i++) {//把坏掉的桔子存放到队列中去
for (int j = 0; j < col; j++) {
if (grid[i][j] == 2){
qu.offer(new Pair(i,j));
}
}
}
int step = 0;
while (!qu.isEmpty()){//进行BFS
int size = qu.size();
while (size-- > 0){
Pair pair = qu.poll();
for (int i = 0; i < 4; i++) {//对坏橘子四周进行搜索
int newX = pair.x + nextP[i][0];
int newY = pair.y + nextP[i][1];
if (newX < 0 || newX >= row
|| newY < 0 || newY >= col){//判断坏桔子的位置是否越界
continue;
}
if (grid[newX][newY] == 1){//坏桔子周围的好桔子放到队列中并且标记该位置为坏桔子
grid[newX][newY] = 2;
qu.offer(new Pair(newX,newY));
}
}
}
//坏桔子四周如果有好桔子的话，我们才会对分钟数+1，
// 如果队列不为null，说明此次搜索周围有桔子变坏
if (!qu.isEmpty()){
step++;
}
}
//判断是否还有未坏掉的桔子，如果有就返回-1
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (grid[i][j] == 1){
return -1;
}
}
}
return step;
}
}
3. 单词接龙
原题链接
✨问题描述：
字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列 beginWord -> s1 -> s2 -> … -> sk：
每一对相邻的单词只差一个字母。
对于 1 <= i <= k 时，每个 si 都在 wordList 中。注意， beginWord 不需要在 wordList 中。
sk == endWord
给你两个单词 beginWord 和 endWord 和一个字典 wordList ，返回 从 beginWord 到 endWord 的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列，返回 0 。
✨题目案例：
输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]
输出：5
解释：一个最短转换序列是 “hit” -> “hot” -> “dot” -> “dog” -> “cog”, 返回它的长度 5。
输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”]
输出：0
解释：endWord “cog” 不在字典中，所以无法进行转换。
✨题目分析：
该题目是一个BFS 类型题目，我们做这个题目的时候看到在字典中查找该字符串在不在其中，我们就应该把字典中的字符串放到一个Set中，因为在其中搜索的效率更高。我们进行BFS的时候，每个字符串的针对其一个每个字符进行26个英文字母的替换，判断其是否在字典中，并且需要查看它是否被搜索过。我们在每次取出队列中的元素的时候需要判断是否是目标数组，是的话我们就返回最短转换数列的数目，当BFS结束以后说明无法搜索到目标数组了，我们就返回0。
✨解题代码：
public int ladderLength(String beginWord, String endWord, List<String> wordList) {
Queue<String> qu = new LinkedList<>();//存放应该根据其搜索的字符串
qu.offer(beginWord);
Set<String> dict = new HashSet<>(wordList);//存放字典中的字符串。
Set<String> book = new HashSet<>();//标记已经搜索过的字符串
book.add(beginWord);
int step = 1;//最短转换数列的数目
while (!qu.isEmpty()){//进行BFS
int size = qu.size();
while (size-- > 0){
String str = qu.poll();
if (str.equals(endWord)){//判断队列中的字符串是否等于endWord
return step;
}
for (int i = 0; i < str.length(); i++) {//一个单词中一个字母需要进行依次替换
StringBuilder sb = new StringBuilder(str);//保证替换下一个的时候，其他位置的字母相对str不会改变
for (char ch = 'a'; ch <= 'z'; ch++) {//对一个位置的字母进行26次变化
sb.setCharAt(i,ch);
if (!book.contains(sb.toString()) && dict.contains(sb.toString())){//判断经过此次变化的字符串是否在字典中，并且未被搜索过
book.add(sb.toString());
qu.offer(sb.toString());
}
}
}
}
step++;
}
return -1;
}
4. 打开转盘锁
原题链接
✨问题描述：
你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： ‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’ 。每个拨轮可以自由旋转：例如把 ‘9’ 变为 ‘0’，‘0’ 变为 ‘9’ 。每次旋转都只能旋转一个拨轮的一位数字。
锁的初始数字为 ‘0000’ ，一个代表四个拨轮的数字的字符串。
列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无法再被旋转。
字符串 target 代表可以解锁的数字，你需要给出解锁需要的最小旋转次数，如果无论如何不能解锁，返回 -1
✨输入案例：
案例1：
输入：deadends = [“0201”,“0101”,“0102”,“1212”,“2002”], target = “0202”
输出：6
解释：
可能的移动序列为 “0000” -> “1000” -> “1100” -> “1200” -> “1201” -> “1202” -> “0202”。
注意 “0000” -> “0001” -> “0002” -> “0102” -> “0202” 这样的序列是不能解锁的，
因为当拨动到 “0102” 时这个锁就会被锁定。
案例2：
输入: deadends = [“8888”], target = “0009”
输出：1
解释：把最后一位反向旋转一次即可 “0000” -> “0009”。
案例3：
输入: deadends = [“8887”,“8889”,“8878”,“8898”,“8788”,“8988”,“7888”,“9888”], target = “8888”
输出：-1
解释：无法旋转到目标数字且不被锁定。
✨题目分析：
该问题不适合用DFS，因为递归深度太大，会造成溢出。在进行BFS的时候，我们需要对四位数中的每一位进行一次上下翻转。当然进行BFS的时候我们必须建立一个标记哈希表，去存储已经搜索过的字符串， 避免一个字符串多次搜索造成死循环。我们在进行判断新的字符串是否在死亡数组中的时候，我们应该用哈希表进行搜索，这样才能提高搜索效率。
- 建立两个哈希表，一个存放死亡数组，一个存放搜索过的字符串
- 事先判断”0000“字符串在死亡数组中，如果在就不会转动，不会找到目标数组直接返回-1
- 设一个变量记录搜索的步数
- 进行BFS的时候需要注意字符串中字符是‘0’的话向下拨就是’9‘，是‘9’的话向上拨就是‘0’
- 每次需要判断搜索队列中的字符串是不是目标字符串，是的话直接返回步数
- 对搜索队列进行加数据的话，需要判断是否不在死亡数组中，并且没有被搜索过
- 倘若经过BFS没有被搜索到证明不能够经过转动找到目标字符串，我们需要进行返回-1；
✨解题代码：
public int openLock(String[] deadends, String target) {
Set<String> deadSet = new HashSet<>(Arrays.asList(deadends));//将死亡数组存放到一个哈希表中
Set<String> book = new HashSet<>();//存放已经搜索过字符串，避免重复搜索
book.add("0000");
if (deadSet.contains("0000")){//如果"0000"字符串在死亡数组中，就不会转动，不会找到目标数组
return -1;
}
int step = 0;
Queue<String> qu = new LinkedList<>();//存放当前情况下的需要进行搜索的字符串
qu.offer("0000");
while (!qu.isEmpty()){//进行BFS
int size = qu.size();
while (size-- > 0){
String str = qu.poll();
if (str.equals(target)){//判断该搜索字符串是不是目标字符串
return step;
}
for (int i = 0; i < 4; i++) {//对四个数字中的每个都进行一次上下翻转
StringBuilder sb = new StringBuilder(str);
char ch1 = str.charAt(i);
char ch2 = str.charAt(i);
if (ch1 == '9'){
ch1 = '0';
}else {
ch1++;
}
if(ch2 == '0'){
ch2 = '9';
}else {
ch2--;
}
sb.setCharAt(i,ch1);
if (!book.contains(sb.toString())&&!deadSet.contains(sb.toString())){//判断是否不在死亡数组中，并且没有被搜索到
book.add(sb.toString());
qu.offer(sb.toString());
}
sb.setCharAt(i,ch2);
if (!book.contains(sb.toString())&&!deadSet.contains(sb.toString())){
book.add(sb.toString());
qu.offer(sb.toString());
}
}
}
step++;
}
return -1;
}