第三十一天|贪心算法| 56. 合并区间，738.单调递增的数字 ， 968.监控二叉树

目录

56. 合并区间

方法1：fff

看方法2：fff优化版

方法3：

738.单调递增的数字

968.监控二叉树（贪心+二叉树）

---

56. 合并区间

判断重叠区间问题，与452和435是一个套路

方法1：fff

看方法2：fff优化版

• 使用currentInterval来追踪当前合并的区间，而不是在原数组上修改值。
• 每当找到一个不重叠的区间时，将currentInterval添加到result，并开始一个新的currentInterval。

class Solution {
    public int[][] merge(int[][] intervals) {
        // 方法1：fff
//        if (intervals.length == 1){
//            return intervals;
//        }
//        Arrays.sort(intervals,(a,b)->Integer.compare(a[0],b[0]));
//        int[][] result = new int[intervals.length][];
//        int row = 0;
//        for (int i = 0; i < intervals.length - 1; i++) {
//            if (intervals[i + 1][0] <= intervals[i][1]){
//                intervals[i + 1][0] = Math.min(intervals[i][0],intervals[i + 1][0]);
//                intervals[i + 1][1] = Math.max(intervals[i][1],intervals[i + 1][1]);
//            } else {
//                result[row++] = intervals[i];
//            }
//        }
//        result[row] = intervals[intervals.length - 1];
//        int[][] res = new int[row+1][];
//        int i = 0;
//        for (int[] r : result){
//            if (r == null){
//                break;
//            }
//            res[i++] = r;
//        }
//        return res;

        // 方法2：fff优化版
        if (intervals.length == 1){
            return intervals;
        }
        // 排序的时间复杂度是O(n log n), n是intervals数组的长度。
        Arrays.sort(intervals,(a,b)->Integer.compare(a[0],b[0]));
        List<int[]> result = new LinkedList<>();
        int[] currentInterval = intervals[0]; // 使用currentInterval来追踪当前合并的区间，而不是在原数组上修改值。
        for (int i = 1; i < intervals.length ; i++) {
            if (intervals[i][0] <= currentInterval[1]){
                // 合并
                currentInterval[1] = Math.max(currentInterval[1], intervals[i][1]);
            } else {
                result.add(currentInterval);
                currentInterval = intervals[i];
            }
        }
        result.add(currentInterval);
        return result.toArray(new int[result.size()][]);
    }
}

方法3：

看方法2或者3都可以，复杂度是一样的。都挺好的。

• 代码结构：方法3实现直接使用LinkedList<int[]>的getLast()和removeLast()来获取和更新最后一个合并区间，代码更加简洁且避免了在原数组上修改数据。
• 操作顺序：方法3实现中，每次更新最后一个区间的值时，先移除再添加，这样减少了代码复杂性；而方法2实现会在原数组上更新，代码稍显繁琐。

    class Solution {
        public int[][] merge(int[][] intervals) {
            //方法3：
            LinkedList<int[]> res = new LinkedList<>();
            Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
            res.add(intervals[0]);
            for (int i = 1; i < intervals.length; i++) {
                if (intervals[i][0] <= res.getLast()[1]) {
                    int start = res.getLast()[0];
                    int end = Math.max(intervals[i][1], res.getLast()[1]);
                    res.removeLast();
                    res.add(new int[]{start, end});
                } else {
                    res.add(intervals[i]);
                }
            }
            return res.toArray(new int[res.size()][]);
        }
    }

738.单调递增的数字

思路：

例如98，一旦出现strNum[i - 1] > strNum[i]的情况（非单调递增），首先想让strNum[i - 1]减一，strNum[i]赋值9，这样这个整数就是89。

并且需要注意：用一个flag来标记从哪里开始赋值9。后面的都要赋值9。

遍历顺序：从后向前遍历

从前向后遍历的话，遇到strNum[i - 1] > strNum[i]的情况，让strNum[i - 1]减一，但此时如果strNum[i - 1]减一了，可能又小于strNum[i - 2]。

这么说有点抽象，举个例子，数字：332，从前向后遍历的话，那么就把变成了329，此时2又小于了第一位的3了，真正的结果应该是299。

那么从后向前遍历，就可以重复利用上次比较得出的结果了，从后向前遍历332的数值变化为：332 -> 329 -> 299

    class Solution {
        public int monotoneIncreasingDigits(int n) {
            if (n < 10) {
                return n;
            }
            String str = n + "";
            char[] ch = str.toCharArray();
            int index = ch.length;
            for (int i = ch.length - 1; i > 0; i--) {
                if (ch[i] < ch[i-1]) {
                    index = i;
                    ch[index-1]--;
                }
            }
            for (int i = index; i < ch.length; i++) {
                ch[i] = '9';
            }
            String res = new String(ch);
            return Integer.parseInt(res);
        }
    }

968.监控二叉树（贪心+二叉树）

思路：

摄像头可以覆盖上中下三层，如果把摄像头放在叶子节点上，就浪费的一层的覆盖。

所以把摄像头放在叶子节点的父节点位置，才能充分利用摄像头的覆盖面积。

那么有同学可能问了，为什么不从头结点开始看起呢，为啥要从叶子节点看呢？

因为头结点放不放摄像头也就省下一个摄像头， 叶子节点放不放摄像头省下了的摄像头数量是指数阶别的。

所以我们要从下往上看，局部最优：让叶子节点的父节点安摄像头，所用摄像头最少，整体最优：全部摄像头数量所用最少！

大体思路就是从低到上，先给叶子节点父节点放个摄像头，然后隔两个节点放一个摄像头，直至到二叉树头结点。

此时这道题目还有两个难点：

1. 二叉树的遍历 （后序遍历）
2. 如何隔两个节点放一个摄像头

• 如何隔两个节点放一个摄像头

此时需要状态转移的公式，大家不要和动态的状态转移公式混到一起，本题状态转移没有择优的过程，就是单纯的状态转移！

来看看这个状态应该如何转移，先来看看每个节点可能有几种状态，分别有三个数字来表示：

• 0：该节点无覆盖
• 1：本节点有摄像头
• 2：本节点有覆盖

（空节点的状态只能是有覆盖，这样就可以在叶子节点的父节点放摄像头了）

• 单层逻辑处理。

主要有如下四类情况：

• 情况1：左右节点都有覆盖

左孩子有覆盖，右孩子有覆盖，那么此时中间节点应该就是无覆盖的状态了。

• 情况2：左右节点至少有一个无覆盖的情况

此时摄像头的数量要加一，并且return 1，代表中间节点放摄像头。

• 情况3：左右节点至少有一个有摄像头

如果是以下情况，其实就是 左右孩子节点有一个有摄像头了，那么其父节点就应该是2（覆盖的状态）

• left == 1 && right == 2 左节点有摄像头，右节点有覆盖
• left == 2 && right == 1 左节点有覆盖，右节点有摄像头
• left == 1 && right == 1 左右节点都有摄像头

• 情况4：头结点没有覆盖

以上都处理完了，递归结束之后，可能头结点 还有一个无覆盖的情况，如图：

所以递归结束之后，还要判断根节点，如果没有覆盖，result++

   class Solution {
        int res = 0;

        public int minCameraCover(TreeNode root) {
            // 对根节点的状态做检验,防止根节点是无覆盖状态
            if (minCame2(root) == 0) {
                res++;
            }
            return res;
        }

        /**
         * 节点的状态值：
         * 0 表示 无覆盖
         * 1 表示 有摄像头
         * 2 表示 有覆盖
         * 后序遍历，根据左右节点的情况,来判读 自己的状态
         */

        // 流程清晰版
        public int minCame(TreeNode root) {
            if (root == null) {
                // 空节点默认为 有覆盖状态，避免在叶子节点上放摄像头
                return 2;
            }
            int left = minCame(root.left);
            int right = minCame(root.right);
            //中，逻辑处理
            // 如果左右节点都覆盖了的话, 那么本节点的状态就应该是无覆盖,没有摄像头
            if (left == 2 && right == 2) {
                return 0;
            } else if (left == 0 || right == 0) {
                // 左右节点是无覆盖状态,那 根节点此时应该放一个摄像头
                res++;
                return 1;
            } else {
                //左右节点至少存在 1个摄像头,那么本节点就是处于被覆盖状态
                return 2;
            }
        }

        // 简化分支版本
        public int minCame2(TreeNode root) {
            if (root == null) {
                return 2;
            }
            int left = minCame2(root.left);
            int right = minCame2(root.right);
            // 有任意一个子节点为无覆盖，就需要当前节点放相机
            if (left == 0 || right == 0) {
                res++;
                return 1;
            }
            if (left == 2 && right == 2) { // 左右子树都是有覆盖，那么此时返回无覆盖
                return 0;
            }
            return 2; // 剩下情况就是左右子树有可能为 1 有摄像头，即当前节点被监控
        }
    }

第三十一天的总算是结束了，直冲Day32！