LeetCode DFS、BFS篇(102、200、111、752)

102. 二叉树的层序遍历

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

示例：

二叉树：[3,9,20,null,null,15,7],

3

/

9 20

/

15 7

返回其层次遍历结果：

[

[3],

[9,20],

[15,7]

]

//思路1BFS，优化广度遍历，一层一层放进deque进行遍历,遍历完一层就用list装完加入res
//思路2DFS，每一层递归都用index做标记

solution1 BFS 迭代

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

solution 2 DFS 递归

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null){
            return res;
        }
        dfs(res,root,1);
        return res;
    }
    public void dfs(List<List<Integer>> res,TreeNode node,int index){
        if (res.size()<index){
            res.add(new ArrayList<Integer>());
        }
        res.get(index-1).add(node.val);
        if (node.left != null){
            dfs(res,node.left,index+1);
        }
        if (node.right != null){
            dfs(res,node.right,index+1);
        }
    }
}

200. 岛屿数量

给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1:

输入:

[

['1','1','1','1','0'],

['1','1','0','1','0'],

['1','1','0','0','0'],

['0','0','0','0','0']

]

输出: 1

示例 2:

输入:

[

['1','1','0','0','0'],

['1','1','0','0','0'],

['0','0','1','0','0'],

['0','0','0','1','1']

]

输出: 3

解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。

//思路1：用DFS把1以及周围的点变为0,用静态变量g保存grid，可以让不太的方法修改它
//思路2：用BFS将1以及周围变为0

solution1 DFS

class Solution {
    char[][] g;
    public int numIslands(char[][] grid) {
        int res = 0;
        g = grid;
        int re = 0;
        for (int i=0; i<g.length; i++){
            for (int j=0; j < g[i].length; j++){
                if (g[i][j] == '1') {
                    sink(i,j);
                    res ++;
                }
            }
        }
        return res;

    }
    public void sink(int i,int j){
        //终止条件
        if(i < 0 || j < 0 || i >= g.length || j >= g[0].length || g[i][j] == '0') return;
        //当前层
        g[i][j] = '0';
        //下一层
        sink(i + 1, j);
        sink(i, j + 1);
        sink(i - 1, j);
        sink(i, j - 1);

    }
}

solution2 BFS

class Solution {
    char[][] g;
    public int numIslands(char[][] grid) {
        int res = 0;
        g = grid;
        for (int i=0; i<g.length; i++){
            for (int j=0; j < g[i].length; j++){
                if (g[i][j] == '1') {
                    bfs(i,j);
                    res ++;
                }
            }
        }
        return res;
    }
    public void bfs(int i,int j){
        g[i][j] = '0';
        int x = g.length;
        int y=g[0].length;
        int code = i*y + j;
        ArrayDeque<Integer> deque = new ArrayDeque<>();
        deque.push(code);
        while(!deque.isEmpty()){
            code = deque.pop();
            int n = code/y;
            int m = code%y;
            if (n>0 && g[n-1][m] == '1'){
                deque.push((n-1)*y+m);
                g[n-1][m] = '0';
            }
            if (n<x-1 && g[n+1][m] == '1'){
                deque.push((n+1)*y+m);
                g[n+1][m] = '0';
            }
            if (m>0 && g[n][m-1] == '1'){
                deque.push(n*y+(m-1));
                g[n][m-1] = '0';
            }
            if (m<y-1 && g[n][m+1] == '1'){
                deque.push(n*y+(m+1));
                g[n][m+1] = '0';
            }
        }
    }
}

111. 二叉树的最小深度

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

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

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

示例:

给定二叉树 [3,9,20,null,null,15,7],

3

/

9 20

/

15 7

返回它的最小深度 2.

class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) return 0;
        Deque<TreeNode> dq = new LinkedList<>();
        //往队列添加元素
        dq.offer(root);
        int depth = 1;
        while( !dq.isEmpty()){
            int len = dq.size();
            //以当前队列中的所有节点向四周扩撒
            for(int i = 0; i < len; i ++){
                TreeNode node = dq.poll();
                if(node.left == null && node.right == null){
                    return depth;
                }
                if (node.left != null){
                    dq.offer(node.left);
                }
                if (node.right != null){
                    dq.offer(node.right);
                }
            }
            //增加深度
            depth++;
        }
        return depth;

    }
}
// 思路1: 运用BFS，以面单位进行搜索，使用dq进行保存

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

提示：

死亡列表 deadends 的长度范围为 [1, 500]。

目标数字 target 不会在 deadends 之中。

每个 deadends 和 target 中的字符串的数字会在 10,000 个可能的情况 '0000' 到 '9999' 中产生。

solution1

class Solution {
    public int openLock(String[] deadends, String target) {
        //死亡之组
        Set<String> deads = new HashSet<String>();
        for (String s:deadends){ deads.add(s);}
        //遍历队列
        Deque<String> dq = new LinkedList<String>();
        //已遍历
        Set<String> visited = new HashSet<String>();
        //深度
        int depth = 0;
        dq.offer("0000");
        visited.add("0000");

        while(!dq.isEmpty()){
            int sz = dq.size();
            // 以面为单位遍历
            for (int i = 0; i < sz; i++){
                String curr = dq.poll();

                if (deads.contains(curr)) continue;
                if (curr.equals(target)) return depth; //不能用==

                for (int j = 0; j < 4; j++){
                    String plus = plusOne(curr,j);
                    if (!visited.contains(plus)){
                        dq.offer(plus);
                        visited.add(plus);
                    }
                    String minus = minusOne(curr,j);
                    if (!visited.contains(minus)){
                        dq.offer(minus);
                        visited.add(minus);
                    }
                }
            }
            depth++;
        }
        return -1;
    }
    // 目标转盘+1
    private String plusOne(String s,int j){
        char[] c = s.toCharArray();
        if (c[j] == '9'){
            c[j] = '0';
        }else{
            c[j]+=1;
        }
        return new String(c);
    }
    // 目标转盘-1
    private String minusOne(String s,int j){
        char[] c = s.toCharArray();
        if (c[j] == '0'){
            c[j] = '9';
        }else{
            c[j]-=1;
        }
        return new String(c);
    }

}
//运用BFS，以“0000”为根，所有转动情况为根的子节点