day31 贪心算法-mergeIntervals+monotoneIncreasingDigits+binaryTreeCameras

### 8.16 56. Merge Intervals
Given an array of intervals where intervals[i] = [starti, endi], merge all overlapping intervals, and return an array of the non-overlapping intervals that cover all the intervals in the input.
56. 合并区间  
本题也是重叠区间问题，如果昨天三道都吸收的话，本题就容易理解了。
https://leetcode.cn/problems/merge-intervals/description/
https://programmercarl.com/0056.%E5%90%88%E5%B9%B6%E5%8C%BA%E9%97%B4.html  
返回值是长度不一定的二维数组？不要直接new二维数组，先将一维数组存入list，再toArray即可。
这里是合并区间，需要将左右边界都保存下来。
```java
public class mergeIntervals {  
    public int[][] merge(int[][] intervals) {  
        List<int[]> result = new ArrayList<>();  
        Arrays.sort(intervals,(a,b) -> Integer.compare(a[0],b[0]));  
  
        int left = intervals[0][0];  
        int right = intervals[0][1];  
        for (int i = 1; i < intervals.length; i++) {  
        
        //这里其实是将当前左边界和上一组的右边界进行比对，并更新右边界。
        
            if(intervals[i][0] <= right){  
                right = Math.max(intervals[i][1],right);  
            }else{  
                result.add(new int[]{left,right});  
                left = intervals[i][0];  
                right = intervals[i][1];  
            }  
        }  
  
        result.add(new int[]{left,right});  
        return result.toArray(new int[result.size()][]);  
    }  
}  
class mergeIntervalsTest {  
    public static void main(String[] args) {  
        mergeIntervals example = new mergeIntervals();  
        int[][] intervals = {  
                //{1,3},{2,6},{8,10},{15,18}  
                {2,3},{4,5},{6,7},{8,9},{1,10}  
                //{-2147483646,-2147483645},{2147483646,2147483647}  
        };  
        int[][] result = example.merge(intervals);  
        for(int[] line : result){  
            System.out.print("[ ");  
            for(int i : line){  
                System.out.print(i + " ,");  
            }  
            System.out.print(" ] ");  
        }  
    }  
}
```
### 8.17 738. Monotone Increasing Digits
An integer has monotone increasing digits if and only if each pair of adjacent digits x and y satisfy x <= y.
Given an integer n, return the largest number that is less than or equal to n with monotone increasing digits.
https://leetcode.cn/problems/monotone-increasing-digits/description/
https://programmercarl.com/0738.%E5%8D%95%E8%B0%83%E9%80%92%E5%A2%9E%E7%9A%84%E6%95%B0%E5%AD%97.html  
这题的巧妙之处在于，找到第一个非单调递增的数字后，将它-1，后面的数字都改为9.
```java
public class monotoneIncreasingDigits {  
    public monotoneIncreasingDigits() {    }  
    public int monotoneIncreasingDigits(int n) {  
        String s = String.valueOf(n);  
        char[] chars = s.toCharArray();  
  
        //用于记录末尾的9从哪里开始  
        int start = chars.length;  
  
        for (int i = chars.length - 1; i > 0; i--) {  
            if(chars[i-1] > chars[i]){  
                chars[i-1]--;  
                start = i;  
            }  
        }  
  
//        for (int i = chars.length - 2; i >= 0; i--) {  
//            if(chars[i+1] < chars[i]){  
//                chars[i]--;  
//                start = i + 1;  
//            }  
//        }  //没有区别，写法不一样
  
//        System.out.println("start: " + start);  
  
        for (int i = start; i < chars.length; i++) {  
            chars[i] = '9';  
        }  
  
        return Integer.parseInt(new String(chars));  
    }  
}  
class monotoneIncreasingDigitsTest {  
    public static void main(String[] args) {  
        monotoneIncreasingDigits example = new monotoneIncreasingDigits();  
        System.out.println(example.monotoneIncreasingDigits(3452331));  
    }  
}
```
### 8.18 968. Binary Tree Cameras（选做）
You are given the root of a binary tree. We install cameras on the tree nodes where each camera at a node can monitor its parent, itself, and its immediate children.
Return the minimum number of cameras needed to monitor all nodes of the tree.
https://leetcode.cn/problems/binary-tree-cameras/description/ 
https://programmercarl.com/0968.%E7%9B%91%E6%8E%A7%E4%BA%8C%E5%8F%89%E6%A0%91.html  
碰到叶子节点，就让它的父节点放一个摄像头；向上遍历的时候每隔两个节点放一个摄像头。
如何实现？通过记录状态
三个状态：
0.无覆盖（没有被摄像头覆盖）
1.有摄像头
2.有覆盖
无摄像头的状态可以被0和1替代。
目的：尽可能地让叶子的父节点放摄像头。

三种情况：
1.左右孩子都有覆盖（2），父节点则无覆盖。（叶子节点返回2）
2.左右孩子有一个无覆盖，父节点需要装摄像头
3.左右孩子有一个有摄像头，父节点有覆盖。
4.遍历结束后，头结点没有覆盖，需要加一个摄像头

```java
public class binaryTreeCameras {  
    int result = 0;  
    public int minCameraCover(TreeNode root) {  
        //当头节点没有被覆盖，需要将一个头布置在头结点上。  
        if(traversal(root) == 0) result++;  
        return result;  
    }  
  
    public int traversal(TreeNode root){  
        //根节点不布置摄像头，直接返回有覆盖  
        if(root == null){  
            return 2;  
        }  
  
        int left = traversal(root.left);  
        int right = traversal(root.right);  
        // 如果左右节点都覆盖了的话, 那么本节点的状态就应该是无覆盖,没有摄像头  
        if(left == 2 && right == 2){  
            return 0;  
        //左右节点存在无覆盖状态,那 根节点此时应该放一个摄像头  
        }else if(left==0||right==0){  
            result++;  
            return 1;  
        }else{  
            //左右节点至少存在一个摄像头  
            return 2;  
        }  
    }  
}
```