BFS&（二叉树+字符串+数组）

1.二叉树的最小深度

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        //使用BFS算法，，start是根节点，target是最近的叶子节点
        if(root==null){
            return 0;
        }
        int depth=1;
        //定义一个队列存储节点
        Deque<TreeNode> queue=new LinkedList<>();
        //把根节点先放进队列
        queue.offer(root);
        while(!queue.isEmpty()){
            int sz=queue.size();
            for(int i=0;i<sz;i++){
                TreeNode cur=queue.poll();
                //判断是否为叶子节点
                if(cur.left==null && cur.right==null){
                    return depth;
                }
                if(cur.left!=null){
                    queue.offer(cur.left);
                }
                if(cur.right!=null){
                    queue.offer(cur.right);
                }
            }
            depth++;
        }
        return depth;
    }
}

2.打开转盘锁

class Solution {
    public int openLock(String[] deadends, String target) {
        //使用BFS算法
        //定义步数
        int steps=0;
        //使用一个hashset存储deadends
        HashSet<String> dead=new HashSet<>();
        for(String d:deadends){
            dead.add(d);
        }
        //起始字符串
        String start="0000";
        //BFS算法使用队列存储周围节点
        Deque<String> queue=new LinkedList<>();
        queue.offer(start);
        //记录访问过的密码
        HashSet<String> visited=new HashSet<>();
        visited.add(start);

        //开始使用while循环遍历
        while(!queue.isEmpty()){
            int sz=queue.size();
            for(int i=0;i<sz;i++){
                String cur=queue.poll();
                if(dead.contains(cur)){
                    continue;
                }
                if(target.equals(cur)){
                    return steps;
                }
                //密码总共4位，遍历每个位置，将每个位置加1或者减1，判断得到的字符串是否位target
                for(int j=0;j<4;j++){
                    //向上拧得到的字符串
                    String up=plusOne(cur,j);
                    if(!visited.contains(up)){
                        queue.offer(up);
                        visited.add(up);
                    }
                    //向下拧得到的字符串
                    String down=subOne(cur,j);
                    if(!visited.contains(down)){
                        queue.offer(down);
                        visited.add(down);
                    }
                }
            }
            steps++;
        }
        return -1;//找不到解锁方式，则返回-1
    }

    public String plusOne(String s,int j){
        char[] c=s.toCharArray();
        if(c[j]=='9'){
            c[j]='0';
        }else{
            c[j]++;
        }
        return new String(c);
    }

    public String subOne(String s,int j){
        char[] c=s.toCharArray();
        if(c[j]=='0'){
            c[j]='9';
        }else{
            c[j]--;
        }
        return new String(c);
    }
}

3.滑动谜题

class Solution {
    public int slidingPuzzle(int[][] board) {
        //使用BFS算法，使用字符串存储数组当前数字位置状态
        //定义步数
        int step=0;
        //start状态
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<2;i++){
            for(int j=0;j<3;j++){
                sb.append(board[i][j]+"");
            }
        }
        //target状态
        String target="123450";
        //使用哈社团存储遍历过的状态
        HashSet<String> visited=new HashSet<>();
        //BFS算法使用队列进行遍历
        Deque<String> queue=new LinkedList<>();
        
        queue.offer(sb.toString());
        visited.add(sb.toString());

        //为了后面遍历时候可以找到0和哪个位置进行交换，这里定义一个数组记录二维数组中每个位置的邻居位置
        int[][] neighbor={
            {1,3},
            {0,2,4},
            {1,5},
            {0,4},
            {1,3,5},
            {2,4}
        };

        //开始遍历
        while(!queue.isEmpty()){
            int sz=queue.size();
            for(int i=0;i<sz;i++){
                String cur=queue.poll();
                //如果和target相等，就返回步数
                if(target.equals(cur)){
                    return step;
                }
                //让0和邻居位置交换
                //首先需要找到0的位置
                int index=cur.indexOf('0');
                for(int j=0;j<neighbor[index].length;j++){
                    char[] ch=cur.toCharArray();
                    char temp=ch[neighbor[index][j]];
                    //交换0和邻居的位置
                    ch[neighbor[index][j]]='0';
                    ch[index]=temp;
                    String swap=new String(ch);
                    if(visited.contains(swap)){
                        continue;
                    }
                    queue.offer(swap);
                    visited.add(swap);
                }
            }
            step++;
        }
        //找不到返回-1
        return -1;
    }
}