BFS (Java) 广度优先搜索 简单介绍、模板、案例（一）

一. BFS的简单介绍

        深度优先搜索DFS和广度优先搜索BFS是经常使用的搜索算法，在各类题目中都有广泛的应用。

        深度优先搜索算法（英语：Depth-First-Search，DFS）是一种用于遍历或搜索树或图的算法。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。
        广度优先搜索算法（Breadth-First Search，缩写为 BFS），又称为宽度优先搜索，是一种图形搜索算法。简单的说，BFS 是从根结点开始，沿着树的宽度遍历树的结点。如果所有结点均被访问，则算法中止。

        一般来说，能用DFS的，一般都可以用BFS解决，反过来同理。但是不同的题目，对于DFS和BFS的复杂度可能是有些差别的，对于有些题目，用BFS更容易解决，会有更少的时间复杂度。

二. BFS模板

        BFS的载体一般选择双端队列，两边都可以增删，可以满足一些特殊的情况，比如0-1BFS(Ref.[1]).

        一般在循环体内都有另一层循环，此层循环是同层循环，一般在同层循环中，答案的更新是一样的，可以理解为树的同一层，具有同样的深度。

class Solution {
    public BFS(TreeNode root) {
        //双端队列，用来存储元素
        Deque<TreeNode> queue = new ArrayDeque<>();
        //添加首个元素
        queue.add(首个元素);
        //当队列不为空一直进行循环，直到队列不再有元素
        while(!queue.isEmpty()){
            int n = queue.size();

            //得到队列的大小
            
            for(int i = 0; i < n; i++){

                var t = queue.poll();

                在同一层的操作;
                ...

            }
            在非同层更新答案;        
        }
        返回答案;
    }
}

三. 典型案例

1.leetcode102 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

 

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();
        Deque<TreeNode> queue = new ArrayDeque<>();
        if(root != null){
            queue.add(root);
        }
        while(!queue.isEmpty()){
            List<Integer> list = new ArrayList<>();
            int n = queue.size();
            for(int i = 0; i < n; i++){
                TreeNode node = queue.poll();
                 list.add(node.val);
                if(node.left != null){
                    queue.add(node.left);  
                }
                if(node.right != null){
                    queue.add(node.right);
                }
            }
            ans.add(list);
        }
        return ans;
    }
}

本题小结:（1）此题是BFS的典型题目， 在同层添加左右子节点，同层节点具有相同的深度

               （2）以颜色来区分同层，可以得到表示更为清晰的二叉树的层序遍历：

那么，原本的二叉树被分为三层，第一层{3}，第二层{9，20}，第三层{15，17}，同一层内的操作在for循环中完成

2.leetcode 1091 二进制矩阵中的最短路径

给你一个 n x n 的二进制矩阵 grid 中，返回矩阵中最短 畅通路径 的长度。如果不存在这样的路径，返回 -1 。

二进制矩阵中的 畅通路径 是一条从 左上角 单元格（即，(0, 0)）到 右下角 单元格（即，(n - 1, n - 1)）的路径，该路径同时满足下述要求：

路径途经的所有单元格的值都是 0 。
路径中所有相邻的单元格应当在 8 个方向之一 上连通（即，相邻两单元之间彼此不同且共享一条边或者一个角）。
畅通路径的长度 是该路径途经的单元格总数。

输入：grid = [[0,1],[1,0]]
输出：2

 

class Solution {
    public int shortestPathBinaryMatrix(int[][] grid) {
        if(grid[0][0] == 1) return -1; 
        Deque<Integer> q = new LinkedList<>();
        int m = grid.length;
        int n = grid[0].length;
        boolean[] vis = new boolean[m*n];
        q.addLast(0);
        vis[0] = true;
        int ans = 0;
        while(!q.isEmpty()){
            int size = q.size();
            for(int k = 0; k < size; k++){
                int t = q.pollFirst();
                if(t == m*n-1) return ans+1;
                int x = t/n;
                int y = t%n;
                for(int i = -1; i <= 1; i++){
                    for(int j = -1; j <=1; j++){
                        int xx = x+i;
                        int yy = y+j;
                        if(xx >= m || yy >= n || xx < 0 || yy < 0 || grid[xx][yy] == 1) continue;
                        if(vis[xx*n+yy]) continue;
                        q.addLast(xx*n+yy);
                        vis[xx*n+yy] = true;
                    }
                }
            }
            ans++;
        }
        return -1;
    }
}

本题小结:（1）此题也是BFS的典型题目，此题经典的解法即为BFS或者DFS，类似的还有走迷宫的题目，在矩阵或者图中，从起点到终点的题目几乎都可以用DFS或者BFS来解决。

               （2）在同一层具有相同的深度，即在for循环内ans是相同的，在for循环外来更新ans。

               （3）来到当前点的下一个点的方向可以朝着上下左右行走，那么原本最初的for循环变为两层，但逻辑都是一样的，即：寻找下一步可以走的所有可能性。 

               （4）vis[xx*n+yy] = true;走过的进行标记，这在回溯等方法中也经常使用，在DFS、BFS此类暴力搜索的方法中也不不得不用的措施。

3.leetcode 1210 穿过迷宫的最少移动次数

你还记得那条风靡全球的贪吃蛇吗？

我们在一个 n*n 的网格上构建了新的迷宫地图，蛇的长度为 2，也就是说它会占去两个单元格。蛇会从左上角（(0, 0) 和 (0, 1)）开始移动。我们用 0 表示空单元格，用 1 表示障碍物。蛇需要移动到迷宫的右下角（(n-1, n-2) 和 (n-1, n-1)）。

每次移动，蛇可以这样走：

如果没有障碍，则向右移动一个单元格。并仍然保持身体的水平／竖直状态。
如果没有障碍，则向下移动一个单元格。并仍然保持身体的水平／竖直状态。
如果它处于水平状态并且其下面的两个单元都是空的，就顺时针旋转 90 度。蛇从（(r, c)、(r, c+1)）移动到 （(r, c)、(r+1, c)）。

如果它处于竖直状态并且其右面的两个单元都是空的，就逆时针旋转 90 度。蛇从（(r, c)、(r+1, c)）移动到（(r, c)、(r, c+1)）。

 

返回蛇抵达目的地所需的最少移动次数。

如果无法到达目的地，请返回 -1。

输入：grid = [[0,0,0,0,0,1],
               [1,1,0,0,1,0],
               [0,0,0,0,1,1],
               [0,0,1,0,1,0],
               [0,1,1,0,0,0],
               [0,1,1,0,0,0]]
输出：11
解释：
一种可能的解决方案是 [右, 右, 顺时针旋转, 右, 下, 下, 下, 下, 逆时针旋转, 右, 下]。

 

class Solution {
    int r;
    int c;
    int[][] grid;
    public int minimumMoves(int[][] grid) {
        this.grid = grid;
        r = grid.length;
        c = grid[0].length;
        int ans = 0;
        int endL = r*c - 2;
        int endF = r*c - 1;
        Deque<int[]> q = new ArrayDeque<>();
        boolean[][] vis = new boolean[r*c][r*c];
        //            尾巴 头 别反了
        q.add(new int[]{0,1});
        vis[0][1] = true;
        while(!q.isEmpty()){
            for(int k = q.size(); k > 0; k--){
            var t = q.pollFirst();
            int tF = t[1];
            int tL = t[0];
            if(tF == endF && tL == endL){
                return ans;
            }
            int tFx = t[1]/c;//头x
            int tFy = t[1]%c;//头y
            int tLx = t[0]/c;//尾x
            int tLy = t[0]%c;//尾y
            //水平状态 向右平移一格 (tFx,tFy+1) (tLx,tLy+1)
            //垂直状态 向右平移一个 (tFx,tFy+1) (tLx,tLy+1)
            if(tFx == tLx){//当前是水平状态
                if(tFy+1 < c && grid[tFx][tFy+1] == 0 && !vis[tLx*c+tLy+1][tFx*c+tFy+1]){//水平向右
                    q.offerLast(new int[]{tLx*c+tLy+1,tFx*c+tFy+1});
                    vis[tLx*c+tLy+1][tFx*c+tFy+1] = true;
                }
                if(tFx+1 < r && grid[tFx+1][tFy] == 0 && grid[tLx+1][tLy] == 0){
                    if(!vis[(tLx+1)*c+tLy][(tFx+1)*c+tFy]){//水平向下
                        q.offerLast(new int[]{(tLx+1)*c+tLy,(tFx+1)*c+tFy});
                        vis[(tLx+1)*c+tLy][(tFx+1)*c+tFy] = true;
                    }
                    if(!vis[tLx*c+tLy][(tFx+1)*c+tFy-1]){//右旋转
                        q.offerLast(new int[]{tLx*c+tLy,(tFx+1)*c+tFy-1});
                        vis[tLx*c+tLy][(tFx+1)*c+tFy-1] = true;
                    }
                }
            }
            else{//当前是垂直状态
                if(tFx+1 < r && grid[tFx+1][tFy] == 0 && !vis[(tLx+1)*c+tLy][(tFx+1)*c+tFy]){//水平向下
                    q.offerLast(new int[]{(tLx+1)*c+tLy,(tFx+1)*c+tFy});
                    vis[(tLx+1)*c+tLy][(tFx+1)*c+tFy] = true;
                }
                if(tFy+1 < c && grid[tFx][tFy+1] == 0 && grid[tLx][tLy+1] == 0){
                    if(!vis[tLx*c+tLy+1][tFx*c+tFy+1]){//水平向右
                        q.offerLast(new int[]{tLx*c+tLy+1, tFx*c+tFy+1});
                        vis[tLx*c+tLy+1][tFx*c+tFy+1] = true;
                    }
                    if(!vis[tLx*c+tLy][(tFx-1)*c+tFy+1]){//左旋转
                        q.offerLast(new int[]{tLx*c+tLy,(tFx-1)*c+tFy+1});
                        vis[tLx*c+tLy][(tFx-1)*c+tFy+1] = true;
                    }
                }
            }
            }
            ans++;
        }
        return -1;
    }
}

本题小结:（1）此题是走迷宫类的题目，和上述题目不同，走的方式有一定的限制，但是总体的额方法是类似的

               （2）本解法采用水平，垂直分类处理，会出现较多的if-else，非常不美观，容易出错，但是可以明确大体思路，更简便的做法可参考Ref.[2]

参考来源 Ref.

[1] 灵茶山艾府  还在 if-else？一个循环处理六种移动！（Python/Java/C++/Go）