一文带你领会BFS广搜

BFS（Breath First Search）算法套路框架

BFS问题的本质

概述

在一副图中找到从起点start到终点target的最近距离，这个例子听起来很枯燥，但是BFS算法问题其实就是在干这件事。

应用场景

连连看游戏中，消除两个方块不仅图案相同，而且还要保证两个方块直接的最短连线不能多于两个拐点，即两个方块直接的可达性问题

连连看的本质其实也是一张图，让你从起点走到终点，问最短路径这就是连连看的本质

BFS问题的解题方法

基本框架

基本思想

通过一个队列保存节点，然后通过该队列中的节点不断的去拓展，通过一个visited的set集合来存储已经访问过的节点对象

代码

  public int minDepth(TreeNode root, TreeNode target) {
       /*核心数据结构*/
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        /*通过数组判断，避免走回头路*/
        HashSet<TreeNode> vistied = new HashSet<TreeNode>();
        /*将起点加入队列*/
        queue.add(root);
        /*将起点加入visited中*/
        vistied.add(root);
        TreeNode node=null;
        int size;
        /*记录扩散的步数*/
        int depth=0;
        while(!queue.isEmpty()){
            size=queue.size();
            /*将当前队列中的节点向四周扩散*/
            for (int i = 0; i < size; i++) {
                node=queue.poll();
                /*判断该节点是不是目标节点*/
                if (node==target){
                    return depth+1;
                }
                /*将node的相邻节点加入队列*/
                if (node.left!=null){
                    queue.add(node.left);
                }
                if (node.right!=null){
                    queue.add(node.right);
                }
            }
            /*更新步数*/
            depth++;
        }
        /*返回步数*/
        return depth;
    }

二叉树的最小深度带你入门BFS

Leetcode二叉树的最小深度111：https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/

题目概述

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

示例 1：

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

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

BFS解题

本质上就是一个二叉树的层序遍历，平平无奇，所以说还是要基础扎实，要扎实的掌握基本数据结构的知识，解题难问题也就迎刃而解了

public class Leetcode111Solution2 {
    public int minDepth(TreeNode root) {
       /*结束循环条件*/
        if(root==null) return 0;
        /*创建队列*/
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        /*初始化队列*/
        queue.add(root);
        TreeNode node=null;
        int size;
        /*初始化步数*/
        int depth=0;
        /*while循环条件*/
        while(!queue.isEmpty()){
            size=queue.size();
            /*不断的去扩散队列中已经有的节点*/
            for (int i = 0; i < size; i++) {
                node=queue.poll();
                if (node.right==null&&node.left==null){
                    return depth+1;
                }
                if (node.left!=null){
                    queue.add(node.left);
                }
                if (node.right!=null){
                    queue.add(node.right);
                }
            }
            depth++;
        }
        return depth;
    }

      public class TreeNode {
      int val;
      TreeNode left;
      TreeNode right;
      TreeNode() {}
      TreeNode(int val) { this.val = val; }
      TreeNode(int val, TreeNode left, TreeNode right) {
          this.val = val;
          this.left = left;
          this.right = right;
      }
  }
}

消耗内存与时间情况

DFS解题

代码

class Solution {
  public int minDepth(TreeNode root) {
     /*结束循环条件*/
        if(root==null) return 0;
        else if (root.left==null) return minDepth(root.right)+1;
        else if (root.right==null) return minDepth(root.left)+1;
        return Math.min(minDepth(root.left)+1,minDepth(root.right)+1);
    }
}

消耗内存与时间的情况

解开密码的最少次数带你进阶BFS

Leetcode链接752打开转盘锁

题目概述

你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有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
解释：
无法旋转到目标数字且不被锁定。

示例 4:
输入: deadends = ["0000"], target = "8888"
输出：-1

代码

class Solution {
      public int openLock(String[] deadends, String target) {
        /*记录需要跳过的死亡密码*/
        HashSet<String> deadsset = new HashSet<String>();
        for (String deadend : deadends) {
            deadsset.add(deadend);
        }
        /*记录已经穷举过的密码*/
        HashSet<String> visited = new HashSet<String>();
        /*创建核心数据结构队列*/
        LinkedList<String> queue = new LinkedList<String>();
        /*所需的步骤*/
        int step = 0;
        /*初始化*/
        queue.add("0000");
        visited.add("0000");
        /*队列的大小*/
        int size;
        /*每次取出的字符串*/
        String tempStr;
        while (!queue.isEmpty()) {
            size = queue.size();
            /*将当前队列中的节点扩散*/
            for (int i = 0; i < size; i++) {
                tempStr = queue.poll();
                /*判断密码是否合法*/
                if (deadsset.contains(tempStr)) continue;
                /*判断密码是否到达终点*/
                if (tempStr.equals(target)) {
                    return step;
                }
                for (int i1 = 0; i1 < 4; i1++) {
                    String down = minusOne(tempStr, i1);
                    if (!visited.contains(down)) {
                        queue.offer(down);
                        visited.add(down);
                    }
                    String up = PlusOne(tempStr, i1);
                    if (!visited.contains(up)) {
                        queue.offer(up);
                        visited.add(up);
                    }
                }
            }
            step++;
        }
        return -1;
    }
    /*向下波动一次*/
    String minusOne(String s,int i){
        char[] chars = s.toCharArray();
        if (chars[i]=='0'){
            chars[i]='9';
        }else {
            chars[i]-=1;
        }
        return new String(chars);
    }
    /*向上波动一次*/
    String PlusOne(String s,int i){
        char[] chars = s.toCharArray();
        if (chars[i]=='9'){
            chars[i]='0';
        }else {
            chars[i]+=1;
        }
        return new String(chars);
    }
}

消耗内存与时间情况