代码随想录算法训练营第三十七天| 56. 合并区间、738. 单调递增的数字、968. 监控二叉树

[LeetCode] 56. 合并区间
[LeetCode] 56. 合并区间 文章解释

[LeetCode] 56. 合并区间 视频解释

题目：

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

提示：

• 1 <= intervals.length <= 10^4
• intervals[i].length == 2
• 0 <= starti <= endi <= 10^4

[LeetCode] 56. 合并区间

自己看到题目的第一想法

    按照边界排序，从头往后遍历列表，如果当前节点和处理完重叠的到的区间依旧有重叠， 则继续合并并扩大区间。 直到当前节点和区间不重叠，则保存一次结果。

看完代码随想录之后的想法

    和第一想法差不多。

class Solution {
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals, new Comparator<int[]>() {
             @Override
            public int compare(int[] a, int[] b) {
                return a[0] - b[0];
            }
        });
        LinkedList<int[]> result = new LinkedList<>();
        for (int i = 1; i < intervals.length; i++) {
            if (intervals[i][0] <= intervals[i - 1][1]) {
                intervals[i][0] = intervals[i - 1][0];
                intervals[i][1] = Math.max(intervals[i][1], intervals[i - 1][1]);
            } else {
                result.add(intervals[i - 1]);
            }
        }
        result.add(intervals[intervals.length - 1]);
        return result.toArray(new int[result.size()][2]);
    }
}

自己实现过程中遇到哪些困难

    无。

[LeetCode] 738. 单调递增的数字
[LeetCode] 738. 单调递增的数字 文章解释

[LeetCode] 738. 单调递增的数字 视频解释

题目：

当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。

给定一个整数 n ，返回 小于或等于 n 的最大数字，且数字呈 单调递增 。

示例 1:

输入: n = 10
输出: 9

示例 2:

输入: n = 1234
输出: 1234

示例 3:

输入: n = 332
输出: 299

提示:

• 0 <= n <= 10^9

[LeetCode] 738. 单调递增的数字

自己看到题目的第一想法

    从最低位开始往前比， 如果地位比高位小的话， 高位 -1， 地位变成9. Duang-》 100 的时候出现异常了。最右边的零没有比从右往左数第二位的0小， 因此不处理。 从右往左数第二个0比1小， 因此变成9， 1变成0.最后得到结果90， 期望值99。

    然后想说， 如果遇到1变为0， 那就要把1后面的都变成9，但是要怎么变呢？这里可以思考一下， 当1变为0时，为了数字最大， 1后面的一定要变成9，当1后面的数字变成9，9后面的数字要不小于9，因此就全部是9了。这里脑子就已经转偏了， 一直想着处理100时， 当1变成0的时候有问题。

    然而其实只要出现高位-1的情况，低位为了最大值都应该变成9. 这样这一题就特别简单了。

看完代码随想录之后的想法

    豁然开朗，真的是又简单又直接。

class Solution {
    public int monotoneIncreasingDigits(int n) {
        // 这里的小巧思真妙，一开始思考怎么分割数字还耗费了不少时间。
        int nineStart = -1;
        char[] chars = new String(n + "").toCharArray();
        for (int i = chars.length - 2; i >= 0; i--) {
            if (chars[i] - '0' > chars[i + 1] - '0') {
                chars[i]--;
                nineStart = i + 1;
            }
        }
        for (int i = nineStart; i >= 0 && i < chars.length; i++) {
            chars[i] = '9';
        }
        return Integer.parseInt(new String(chars));
    }
}

自己实现过程中遇到哪些困难

    无。

[LeetCode] 968. 监控二叉树

[LeetCode] 968. 监控二叉树 文章解释

[LeetCode] 968. 监控二叉树 视频解释

题目：

给定一个二叉树，我们在树的节点上安装摄像头。

节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。

计算监控树的所有节点所需的最小摄像头数量。

示例 1：

输入：[0,0,null,0,0]
输出：1
解释：如图所示，一台摄像头足以监控所有节点。

示例 2：

​​​​​​​

输入：[0,0,null,0,null,0,null,null,0]
输出：2
解释：需要至少两个摄像头来监视树的所有节点。 上图显示了摄像头放置的有效位置之一。

提示：

1. 给定树的节点数的范围是 [1, 1000]。
2. 每个节点的值都是 0。

[LeetCode] 968. 监控二叉树

自己看到题目的第一想法

    不就是递归一下吗， 一个 traversal(root, !needCamera) 函数就可以了， 为什么说是困难呢？

    提交后才发现需要最小的摄像头数量。

看完代码随想录之后的想法

    难倒是不难， 重要的是想法。

/**
 * 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 {
    // 0 无覆盖 1 有摄像头 2 有覆盖
    // 无覆盖 无覆盖    -》 有摄像头  0 0 -〉1
    // 无覆盖 有摄像头  -》 有摄像头  0 1 -〉1
    // 无覆盖 有覆盖    -》 有摄像头  0 2 -〉1
    // 有摄像头 无覆盖   -》 有摄像头 1 0 -〉1
    // 有摄像头 有摄像头 -》 有覆盖   1 1 -〉2
    // 有摄像头 有覆盖   -》 有覆盖   1 2 -〉2
    // 有覆盖 无覆盖     -》有摄像头  2 0 -〉1
    // 有覆盖 有摄像头   -》 有覆盖   2 1 -〉2
    // 有覆盖 有覆盖     -》无覆盖    2 2 -〉0
    // 综上，有1不一定为2，但是当排除掉有0一定为1后，剩余的有1就一定为2
    // 因此可以得出状态推倒公式：0 || 0 -》1 1｜｜1 =〉2 2&&2 =》0
    int count = 0;
    public int minCameraCover(TreeNode root) {
        int childState = traversal(root);
        if (childState == 0) {
            count++;
        }
        return count;
    }
    private int traversal(TreeNode node) {
        // 这里很关键，空节点要赋值为有覆盖。无覆盖和有摄像头都会导致叶子结点状态异常。
        // 空节点为无覆盖， 叶子结点就需要有摄像头。
        // 空节点为有摄像头，叶子结点的福节点就变成无覆盖。而实际这时候叶子结点就变为无覆盖了。ERROR。

        if (node == null) {
            return 2;
        }
        int left = traversal(node.left);
        int right = traversal(node.right);
        if (left == 0 || right == 0) {
            count++;
            return 1;
        } else if (left == 1 || right == 1) {
            return 2;
        } else {
            return 0;
        }
    }
}

自己实现过程中遇到哪些困难

    想不出来， 根本想不出来。 这一题关键不在于实现有难度， 而在于思路，在于状态推导公式这个思路根本想不到。