[算法和数据结构]--回溯算法之BFS初识

最新推荐文章于 2024-04-27 11:13:02 发布

YB_account

最新推荐文章于 2024-04-27 11:13:02 发布

阅读量724

点赞数

分类专栏：算法和数据结构文章标签：算法数据结构宽度优先

本文链接：https://blog.csdn.net/weixin_66409969/article/details/129350246

版权

算法和数据结构专栏收录该内容

4 篇文章 0 订阅

订阅专栏

回溯算法----BFS

BFS介绍(Breadth First Search)
BFS经典例题

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：
在这里插入图片描述

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

案例2：

输入：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：
在这里插入图片描述

输入：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;
    }

YB_account

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
[算法和数据结构]--回溯算法之BFS初识

DFS 是一条路走到黑，BFS就是一石激起千层浪。用我们以前学过的知识来说DFS相当于二叉树中的前序遍历，BFS就相当于二叉树中的层次遍历。我们先来思考一下迷宫问题：✨问题描述：假设有一个迷宫，里面有障碍物，迷宫用二维矩阵表示，标记为0的地方表示可以通过，标记为1的地方表示障碍物，不能通过。现在给一个迷宫出口，让你判断是否可以从入口进来之后，走出迷宫，每次可以向任意方向走。✨案例代码：迷宫问题可以用DFS，但是我用BFS来解决这个迷宫问题。
复制链接

扫一扫