代码随想录-Day36-贪心算法-LetCode738. 单调递增的数字||452. 用最少数量的箭引爆气球||435. 无重叠区间||56. 合并区间

738. 单调递增的数字

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

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

        贪心思路：核心思想就是保证这个数从最大位到最小位逐渐递增，诶过不符合则需要求出比他小的最大值的符合条件的，于是我们可以从后面遍历，char[i]>char[i+1] 一旦不满足条件，将高位柱子减一，低位数字变成九，并且记录当前字符的位置index，循环结束之后，将index之后的所有数字都变为9.返回结果即可。

class Solution {
    public int monotoneIncreasingDigits(int n) {
        // 如果遇到前一位大雨后一位也就是不是递增的数字，处理逻辑就是
        //前一位减一后一位直接变为9保证是单调子增的二而且是最大的
        //这就是局部贪心的思路，循环往复可以推出全局最优
        String s=String.valueOf(n);
        //转换为字符数组方便遍历
        int len=s.length();
        char[] chars = s.toCharArray();
        //记录9的个数
        int nineSum=len;
        //从后往前的遍历顺序也是右考究的，因为这样遍历之后就不会
        //担心 后面出问题，因为已经是最大的了，但是前面不一样
        for(int i=len-2;i>=0;i--){
            if(chars[i]>chars[i+1]){
                chars[i]--;
                nineSum=i+1;
            }
        }
        //便利完之后将所有需要变为9的更新
        //中途可能是会有不需要变为9的，但是比他大的哪一位已经递减了
        //所以为了保证返回最大数字我们需要讲后面所有的变为9
        for(int i=len-1;i>=nineSum;i--){
            chars[i]='9';
        }
        
        return Integer.parseInt(String.valueOf(chars));
    }
}

968. 监控二叉树

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

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

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

        贪心思路：贪心思路，尽量让叶子结点的父节点装上摄像头，可以保证摄像头覆盖尽可能多的结点，所以我们对于二叉树可以采取后序遍历的方式，让根节点知道叶子结点的状态，进而做出判断，那么子结点有哪几种状态囊？

        0：无覆盖

        1：有摄像头，必然覆盖

        2，被覆盖

之后，确定终止条件，就是当遍历到空，返回被覆盖状态，注意这里只能是被覆盖，如果是无覆盖则摄像头放置在叶子结点，如果有摄像头叶子结点的根节点无覆盖

if(cur==null) return 被覆盖

开始遍历左右子树，并接受返回状态

处理单层递归逻辑

        //左右孩子都是有覆盖则根节点才可以是无覆盖
        if(left==2 && right==2) return 0；
        //如果左右孩有一个为无覆盖，那么根节点就应该是有摄像头
        if(left==0||right==0){
            res++;
            return 1;
        }
        //如果左右孩子有一个有摄像头，则根节点一定谁有覆盖状态
        if(left==1||right==1) return 2;

 完整代码：

/**
 * 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 {
    int res=0;
    public int minCameraCover(TreeNode root) {
        //徐傲最后单独判断根节点情况，因为如果左右孩子有覆盖
        //那么根节点会被标记为无覆盖，后续才会增加摄像头，
        //但是此时循化遍历结束
        if(dfs(root)==0) res++;
        return res;
    }
    public int dfs(TreeNode cur){
        //0 无覆盖
        //1 有摄像头
        //2 有覆盖
        //若当前节点为空，只能是有覆盖的情况
        if(cur==null) return 2;
        int left=dfs(cur.left);
        int right=dfs(cur.right);
        
        //左右孩子都是有覆盖则根节点才可以是无覆盖
        if(left==2 && right==2) return 0;
        
        //如果左右孩有一个为无覆盖，那么根节点就应该是有摄像头
        if(left==0||right==0){
            res++;
            return 1;
        }
        
        //如果左右孩子有一个有摄像头，则根节点一定谁有覆盖状态
        if(left==1||right==1) return 2;
        //为了代码不报错，真正的递归不会执行到这里
        return -1;
        
    }
}

贪心算法结束，总的来说感觉并没有递归和回溯那么困难，但是也有不晓得难度，主要是那个弯能不能转过来，能不能想到那个贪心的思路，还有一点代码技巧，总结起来就是，要么简单到死，要么难道爆炸，所以贪心类的题目还是要多刷，掌握思路。

                                                                                                                                By-三条直线围墙