代码随想录算法训练营第31天 | 题目：56. 合并区间 738.单调递增的数字 968.监控二叉树 （可跳过）

代码随想录算法训练营第31天 | 题目：56. 合并区间 738.单调递增的数字 968.监控二叉树 （可跳过）

文章来源：代码随想录

题目名称：56. 合并区间

给出一个区间的集合，请合并所有重叠的区间。

示例 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] 可被视为重叠区间。
注意：输入类型已于2019年4月15日更改。 请重置默认代码定义以获取新方法签名

第一想法：

和之前的类似，找出重叠区域，然后记录开始端以及结束端，作为一个新的区间加入最后结果，如果不重叠就加入原数组

解答思路：

本题的本质其实还是判断重叠区间问题。

大家如果认真做题的话，话发现和我们刚刚讲过的452. 用最少数量的箭引爆气球 (opens new window)和 435. 无重叠区间 (opens new window)都是一个套路。

这几道题都是判断区间重叠，区别就是判断区间重叠后的逻辑，本题是判断区间重贴后要进行区间合并。

所以一样的套路，先排序，让所有的相邻区间尽可能的重叠在一起，按左边界，或者右边界排序都可以，处理逻辑稍有不同。

按照左边界从小到大排序之后，如果 intervals[i][0] <= intervals[i - 1][1] 即intervals[i]的左边界 <= intervals[i - 1]的右边界，则一定有重叠。（本题相邻区间也算重贴，所以是<=）

这么说有点抽象，看图：（注意图中区间都是按照左边界排序之后了）

知道如何判断重复之后，剩下的就是合并了，如何去模拟合并区间呢？

其实就是用合并区间后左边界和右边界，作为一个新的区间，加入到result数组里就可以了。如果没有合并就把原区间加入到result数组。

class Solution {
    public int[][] merge(int[][] intervals) {
   List<int[]> res = new LinkedList<>();
   Arrays.sort(intervals,(x,y)-> Integer.compare(x[0],y[0]));
      int start = intervals[0][0];
        int rightmostRightBound = intervals[0][1];
        for(int i=1;i<intervals.length;i++){
            if(intervals[i][0]<=rightmostRightBound){
           rightmostRightBound= Math.max(rightmostRightBound, intervals[i][1]);
        }else{
            res.add(new int[]{start, rightmostRightBound});
            start=intervals[i][0];
             rightmostRightBound = intervals[i][1];
        }
    }
     res.add(new int[]{start, rightmostRightBound});
        return res.toArray(new int[res.size()][]);
    }
}

收获：

z只是更改了判断排序后的操作，值得注意，代码中的加入结果是针对i的上一位，这导致在最后还需要将最末尾的数组加入结果中

题目名称：738.单调递增的数字

给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。

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

示例 1:

输入: N = 10
输出: 9
示例 2:

输入: N = 1234
输出: 1234
示例 3:

输入: N = 332
输出: 299
说明: N 是在 [0, 10^9] 范围内的一个整数。

第一想法：

一位一位处理，如果不是单调递增的，下一位一定会置9，由于要满足小于n，所以上一位要减一。

解答思路：

贪心算法
题目要求小于等于N的最大单调递增的整数，那么拿一个两位的数字来举例。

例如：98，一旦出现strNum[i - 1] > strNum[i]的情况（非单调递增），首先想让strNum[i - 1]–，然后strNum[i]给为9，这样这个整数就是89，即小于98的最大的单调递增整数。

这一点如果想清楚了，这道题就好办了。

此时是从前向后遍历还是从后向前遍历呢？

从前向后遍历的话，遇到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) {
    String s = String.valueOf(n);
    char[] chars= s.toCharArray();
    int start=s.length();
    for(int i =s.length()-2;i>=0;i--){
        if(chars[i]>chars[i+1]){
            chars[i]--;
            start=i+1;
        }
    }
            for (int i = start; i < s.length(); i++) {
            chars[i] = '9';
        }
          return Integer.parseInt(String.valueOf(chars));

    }

}

收获：

java字符串处理的地方忘记了需要补课，对不符合的尾端均置9很重要。

题目名称：968.监控二叉树（二刷）

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

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

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

示例 1：

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

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

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

第一想法：

解答思路：

困难：

收获：