代码随想录算法训练营第37天｜738.单调递增的数字，714. 买卖股票的最佳时机含手续费，968.监控二叉树，总结

738.单调递增的数字

力扣

思路：

1. 局部最优：遇到strNum[i-1]>strNum[i]的情况，让strNUm[i-1]--，然后strNum[i]变为9，以保证这两位变成最大单调递增整数。全局最优：得到小于等于N的最大单调递增的整数。

2. 从后往前遍历，以保证不改变已经遍历过的结果。

class Solution {
    public int monotoneIncreasingDigits(int n) {
        String s = String.valueOf(n);
        char[] chars = s.toCharArray();//利用char[]数组原地修改
        int start = s.length();//标记赋值9从哪里开始
        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));
    }
}

714. 买卖股票的最佳时机含手续费

力扣

思路：贪心算法

1. 由于本题有手续费，所以可能会出现买卖利润不足以覆盖手续费的情况；

2. 贪心策略：最低值买入，最高值（算上手续费还有盈余）卖出；寻找买入日和卖出日；买入日：遇到价格更低点就记录；卖出日：只要当前价格大于（最低价格+手续费），就可以收获利润，准确的卖出日为连续收获利润区间的最后一天。

3. 情况一：今天可以收获利润，但不是收获利润区间里的最后一天，持有股票。情况二：前一天是收获利润区间的最后一天（即已经卖出），今天重新记录最小价格。情况三：不操作，保持原有状态（买入，卖出，不买不卖）。

class Solution {
    public int maxProfit(int[] prices, int fee) {
        int sum = 0;
        int buy = prices[0]+fee;//记录最低价格
        for(int p:prices){
            if(p+fee<buy){//情况二：重新买入
                buy=p+fee;
            }else if(p>buy){//情况一：可获利
                sum+=p-buy;
                buy=p;//还在收获利润的区间里，并非真正的卖出，不需要考虑fee
            }
        }
        return sum;
    }
}

思路：动态规划

1. dp状态：dp[i][0/1]【i：天数，0/1：是否持有股票】；

2. dp公式：dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]+prices[i]-fee)；dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]-prices[i])；

class Solution {
    public int maxProfit(int[] prices, int fee) {
        int[][] dp = new int[prices.length][2];
        dp[0][0]=0;
        dp[0][1]=-prices[0];
        for(int i=1;i<prices.length;i++){
            dp[i][0]=Math.max(dp[i-1][0],dp[i-1][1]+prices[i]-fee);
            dp[i][1]=Math.max(dp[i-1][1],dp[i-1][0]-prices[i]);
        }
        return dp[prices.length-1][0];
    }
}

968.监控二叉树

力扣

思路：

1. 摄像头可以覆盖上中下三层；把摄像头放在叶子节点的父节点位置，才能充分利用摄像头的覆盖面积。局部最优：让叶子节点的父节点安摄像头，所用摄像头最少，整体最优：全部摄像头数量所用最少。

2. 【遍历顺序】从下往上，因此使用后序遍历；

3. 【隔两个节点放一个摄像头】0表示该节点无覆盖，1表示本节点有摄像头，2表示本节点有覆盖；其中，空节点的状态只能是有覆盖。

4. 【递归终止条件】遇到空结点，返回2；

5. 【单层逻辑处理】情况1:左右节点都有覆盖（2），那么中间节点无覆盖（0）；情况2:左右节点至少有一个无覆盖（0），那么中间节点放摄像头（1）；情况3:左右节点至少有一个摄像头（1），那么中间节点有覆盖（2）；情况4:递归完后若头节点没有覆盖，result++；

class Solution {
    int res = 0;
    public int minCameraCover(TreeNode root) {
        //检验根节点状态，防止根节点为无覆盖
        if(minCame(root)==0) res++;
        return res;
    }
    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{
            return 2;
        }
    }
}

总结

贪心算法总结篇