LeetCode 热题 HOT 100(P31~P40)

 系列文章： 

LeetCode 热题 HOT 100(P1~P10)-CSDN博客

LeetCode 热题 HOT 100(P11~P20)-CSDN博客

LeetCode 热题 HOT 100(P21~P30)-CSDN博客

LeetCode 热题 HOT 100(P31~P40)-CSDN博客

LC76minimum_window

. - 力扣（LeetCode）

题目：

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。

解法：

滑动窗口的思路，右游标可以探查到能满足条件的位置，关键的是左游标怎么确定合适的位置，因为左游标前面可能刚好是不在t中的字母。这个是第一个难点，这里通过维护一个缓存来表示字母的消耗情况，然后左游标就可以根据当前所在字母是否被过量使用判断。还有就是确定好了第一个滑动窗口left、right 之后怎么进入下一个滑动窗口的判断。这个时候left 游标要往前移动一位，同时字母消耗的缓存需要相应的处理，然后就可以继续往前滚动。

public String minWindow(String s, String t) {
        // 这里根据题目给出的限定条件，只有英文字母，所以可以使用128位asc 来表示
        int[] cache = new int[128];
        int cnt = t.length();
        for (int i = 0; i < t.length(); i++) {
            cache[t.charAt(i)]++;
        }
        int begin = 0, min = 0;
        for (int left = 0, right = 0; right < s.length(); right++) {
            if (cache[s.charAt(right)] > 0) {
                cnt--;
            }
            // 这里无差别-1，这样如果是负数就说明是t之外多余的
            cache[s.charAt(right)]--;
            if (cnt == 0) { //说明包含t
                while (cache[s.charAt(left)] < 0) { // left指针尽可能往右走
                    cache[s.charAt(left)]++;
                    left++;
                }
                final int len = right - left + 1;
                if (min == 0 || len < min) {
                    min = len;
                    begin = left;
                }

                //left 指针继续往前走，这个时候就破坏原来符合的情况了
                cache[s.charAt(left)]++;
                cnt++;
                left++;
            }
        }
        return s.substring(begin, begin + min);
    }

根据上面的思路结合代码就比较好理解了，这里缓存用int 数组表示，我发现很多时候数组比map 操作起来方便太多，这里先通过t 进行int 数组的初始化，然后在迭代过程中直接对下标-1，这样就能方便左游标是否可以往前移动。

这里还有个小技巧就是用cnt 来辅助判断是否满足条件，这样就不用轮询数组来判断。

LC78subsets

. - 力扣（LeetCode）

题目：

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的
子集（幂集）。解集 不能包含重复的子集。你可以按 任意顺序 返回解集。

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

解法：

这类题目一闻就是递归的味道，基本套递归模板就可以了，这里要注意的是不要走回头路。

List<List<Integer>> result = new ArrayList<>();

    public List<List<Integer>> subsets(int[] nums) {
        dfs(nums, new ArrayList<>(), 0);
        return result;
    }

    private void dfs(int[] nums, List<Integer> path, int level) {
        result.add(new ArrayList<>(path));
        for (int i = level; i < nums.length; i++) {
            path.add(nums[i]);
            dfs(nums, path, i + 1);
            path.remove(path.size() - 1);
        }
    }

在上面就是通过level 控制，注意在for 循环中下一次递归的时候不是level+1 而是i+1，需要注意体会里面的区别。

LC79word_search

. - 力扣（LeetCode）

题目：

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true

解法：

基本也是递归的思路，首选肯定能通过循环判断word 第一个字母是否匹配，这样才有继续的基础，接下来就是往上下左右遍历可能的情况，这里的难点是怎么不走回头路，主要有2种思路：

1. 使用一个额外的缓存来标识已经走过的路。
2. 直接在原数组中用一个特殊字符覆盖已经走过的路径，这样肯定不会走回头路，因为字符肯定不匹配。

从代码整洁性来说第二种方式更优，这里的难点是递归完下一层之后要对之前造成的影响进行复原，这个不论选择哪种方式都一样。

public boolean exist(char[][] board, String word) {
        final int m = board.length, n = board[0].length;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (dfs(board, i, j, word, 0)) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean dfs(char[][] board, int i, int j, String word, int index) {
        if (index == word.length()) {
            return true;
        }
        if (i < 0 || i == board.length || j < 0 || j == board[0].length || word.charAt(index) != board[i][j]) {
            return false;
        }
        // 占掉一个位置，避免走回头路
        board[i][j] = '#';
        boolean result = dfs(board, i - 1, j, word, index + 1) || dfs(board, i, j - 1, word, index + 1) ||
                         dfs(board, i + 1, j, word, index + 1) || dfs(board, i, j + 1, word, index + 1);
        board[i][j] = word.charAt(index);
        return result;
    }

LC84largest_rectangle

. - 力扣（LeetCode）

题目：

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。

输入：heights = [2,1,5,6,2,3]
输出：10
解释：最大的矩形为图中红色区域，面积为 10

解法：

一般这类n根柱子、n个容器求最大面积的问题基本是用单调递增栈来解决。但是常规的单调递增栈需要解决刚开始栈中没元素的情况，以及最后栈中还遗留元素的情况。这样代码写起来就非常冗长，而且容易出错。

这里就涉及一个单调栈的优化技巧，通过左右哨兵的加入，就可以避免处理这些异常情况。

 public int largestRectangleArea(int[] heights) {
        //维护一个单调递增栈
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(-1); //放入左哨兵，能保证他始终在栈里面
        int max = 0;
        for (int i = 0; i <= heights.length; i++) { // 这里使用heights.length 作为右哨兵
            while (getH(heights, i) < getH(heights, stack.peek())) {
                final Integer pre = stack.pop();
                int area = (i - stack.peek() - 1) * getH(heights, pre);
                max = Math.max(max, area);
            }
            stack.push(i);
        }
        return max;
    }

    private int getH(int[] heights, int index) {
        if (index == -1 || index == heights.length) {
            return -1;
        }
        return heights[index];
    }

这里通过左哨兵-1，保证了栈中肯定有值，而且下标0 的元素加入的时候天然满足递增条件。然后右哨兵-1 能保证把栈中所有元素都倒逼出来，这样就不用处理栈中还留有元素的情况。

LC94binary_tree

. - 力扣（LeetCode）

题目：

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

解法：

如果用递归的方法是很简单的，思路也很清晰。通过代码能直观感受

 public List<Integer> inorderTraversalRecur(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        result.addAll(inorderTraversalRecur(root.left));
        result.add(root.val);
        result.addAll(inorderTraversalRecur(root.right));
        return result;
    }

如果不能使用递归，或者想要挑战下自己，那这道题的难度就上升了一个等级。核心是遍历的时候必然会用到栈，但是怎么判断当前节点是之前已经迭代过可以直接输出，还是需要迭代子节点。这里有2种解法：

第一种：颜色标记法，就是在node 中增加颜色属性，用于标识当前是否可以直接输出

public List<Integer> inorderTraversalColor(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Deque<ColorNode> stack = new ArrayDeque<>();
        stack.push(new ColorNode(0, root));

        while (!stack.isEmpty()) {
            final ColorNode cnode = stack.pop();
            TreeNode node = cnode.node;
            if (node == null) {
                continue;
            }
            if (cnode.color == 0) {
                //需要注意这里的顺序，因为是栈所以要先放最后轮询的节点
                stack.push(new ColorNode(0, node.right));
                stack.push(new ColorNode(1, node));
                stack.push(new ColorNode(0, node.left));
            } else {
                result.add(node.val);
            }
        }
        return result;
    }

    static class ColorNode {

        /**
         * 表示是否应该输出，0，表示未遍历子树，1表示输出当前值
         */
        int color;
        TreeNode node;

        public ColorNode(int color, TreeNode node) {
            this.color = color;
            this.node = node;
        }
    }

可以发现，通过增加一个颜色字段之后这里用0、1 表示是否需要迭代子节点，整体代码逻辑就很顺，比较符合我们的逻辑。

还有一种是纯用栈的方式，这样就需要维护一个cur 指针，同时判断cur 和栈的情况，在cur 不为空的时候不断往左树迭代同时入栈，如果cur 为空就出栈，并把cur 指向右节点。

 public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> stack = new ArrayDeque<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
                //不断往左子树迭代，并将当前节点保存到栈中
                stack.push(cur);
                cur = cur.left;
            } else { //左子树走到底，进行出栈并记录
                final TreeNode node = stack.pop();
                result.add(node.val);
                // 如果有右节点继续上面的过程
                cur = node.right;
            }
        }
        return result;
    }

代码虽然比上一种简洁，但是理解难度高了不少，如果吃透这种写法，基本也能玩得转二叉树类型的题目了。

LC96unique_binary

. - 力扣（LeetCode）

题目：

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。

输入：n = 3
输出：5

解法：

看着像二叉树类型的题目，实际是动态规划的思路，核心就是动态数组的定义和动态方程的推导：

i 表示以第i个节点(从1开始)为根节点的子树，左子树个数为i，右子树个数为n-i-1
f(i) 表示i为根节点时组合个数，G(i) 表示i个节点存在的组合
G(n)=f(1)+f(2)+...+f(n)
f(i)=G(i−1)∗G(n−i)
G(n) = G(0)*G(n-1) + G(1)*G(n-2)+...+G(n-1)*G(0)
dp[n] 表示n 个节点的组合数

尝试自己推导一遍，还是能理解的，代码写出来其实很简单

 public int numTrees(int n) {
        if (n < 2) {
            return 1;
        }
        int[] dp = new int[n + 1];
        dp[0] = 1;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            //以第j个为 根节点时对应的组合数
            for (int j = 1; j <= i; j++) {
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }
        return dp[n];
    }

但是不理解上面的推导过程，确实是看不懂。

LC98validate_binary

. - 力扣（LeetCode）

题目：

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

• 节点的左

  子树

  只包含 小于 当前节点的数。
• 节点的右子树只包含 大于 当前节点的数。
• 所有左子树和右子树自身必须也是二叉搜索树。

解法：

刚一开始，就想到了用递归的方法来解决这个问题，先判断当前节点是否合法（左值<当前值<右值），递归判断左节点，最后递归右节点。结果啪啪打脸，这里存在一个问题是这样的判断不严谨，可能左子树其中一个叶子节点满足直属父节点和兄弟节点的关系，但是并不满足跟祖父节点的约束。

因此这里需要基于中序遍历是递增关系这条更严格的约束条件。

 Integer preVal;

    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }
        if (!isValidBST(root.left)) {
            return false;
        }
        if (preVal != null && root.val <= preVal) {
            return false;
        }
        preVal = root.val;
        return isValidBST(root.right);
    }

注意这里使用了包装类型Integer，方便处理第一次赋值的特殊情况。

LC101symmetric_tree

. - 力扣（LeetCode）

题目：

给你一个二叉树的根节点 root ， 检查它是否轴对称。

解法：

这类一想就有很多子情况需要判断的题目，基本要么递归要么动态规划。或者说他俩基本是一回事。

实际就是判断左节点跟右节点是否对称

 public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        return dfs(root.left, root.right);
    }

    private boolean dfs(TreeNode left, TreeNode right) {
        if (left == null && right == null) {
            return true;
        }
        // 到这里说明left和right 不会同时为null，那么其中有一个null 就说明不对称
        if (left == null || right == null) {
            return false;
        }
        if (left.val != right.val) {
            return false;
        }
        return dfs(left.left, right.right) && dfs(left.right, right.left);
    }

可以看到复杂的地方是对边界情况的处理，是否都为null啊，或者其中一个为null，当都不为null 的时候判断是否相等。然后最后再递归，注意这里left.left 对应right.right，这个看下轴对称示意图就很好理解了。

LC102binary_tree

. - 力扣（LeetCode）

题目：

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

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

解法：

首先想到的是通过队列进行广度遍历，但是第二个问题是怎么知道当前是那一层，因为需要按层输出。这里有个小技巧就是在遍历队列的时候，直接判断当前队列的长度，这个就是当前层的节点数。

 public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Queue<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            final int size = queue.size();
            List<Integer> levelResult = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                final TreeNode node = queue.poll();
                levelResult.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(levelResult);
        }
        return result;
    }

行数虽多，但是很多是对边界情况的处理，整体还是很好理解的。

LC104maximum_depth

. - 力扣（LeetCode）

题目：

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

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

题解：

这个也是递归的思路，从左子树、右子树中选择最深的节点数+1 就是当前的最大深度。

 public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }

代码非常简单，只能说递归真是非常强大。