算法刷题 Day 37 | ● 738.单调递增的数字 ● 714. 买卖股票的最佳时机含手续费 ● 968.监控二叉树

738.单调递增的数字

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

Tips：

局部最优：遇到strNum[i - 1] > strNum[i]的情况，让strNum[i - 1]--，然后strNum[i]给为9，可以保证这两位变成最大单调递增整数。

全局最优：得到小于等于N的最大单调递增的整数。

但这里局部最优推出全局最优，还需要其他条件，即遍历顺序，和标记从哪一位开始统一改成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 == 0) return 0;
        vector<int> num;
        while(n!=0){
            int temp = n % 10;
            n = n /10;
            num.push_back(temp);
        }
        
        int flag = -1;

        for(int i = 0; i< num.size() - 1;i++){
            if(num[i]<num[i+1]){
                flag = i;
                num[i+1]--;
            }
        }

        int result = 0;
        for(int i = num.size() - 1; i>=0;i--){
            result *= 10;
            if(i <= flag){
                result += 9;
            }
            else{
                result += num[i];
            }
        }
        return result;
    }
};

字符串写法：

class Solution {
public:
    int monotoneIncreasingDigits(int N) {
        string strNum = to_string(N);
        // flag用来标记赋值9从哪里开始
        // 设置为这个默认值，为了防止第二个for循环在flag没有被赋值的情况下执行
        int flag = strNum.size();
        for (int i = strNum.size() - 1; i > 0; i--) {
            if (strNum[i - 1] > strNum[i] ) {
                flag = i;
                strNum[i - 1]--;
            }
        }
        for (int i = flag; i < strNum.size(); i++) {
            strNum[i] = '9';
        }
        return stoi(strNum);
    }
};

714.买卖股票的最佳时机含手续费 （可以跳过）

贪心解法可以跳过，有点难以理解，即使理解了，后面也会忘，还是在动态规划章节在好好做本题。

https://programmercarl.com/0714.%E4%B9%B0%E5%8D%96%E8%82%A1%E7%A5%A8%E7%9A%84%E6%9C%80%E4%BD%B3%E6%97%B6%E6%9C%BA%E5%90%AB%E6%89%8B%E7%BB%AD%E8%B4%B9.html

Tips：

我的题解：

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int result = 0;
        int cost = prices[0];
        for(int i=1; i< prices.size(); i++){
            if(prices[i] < cost){
                cost = prices[i];
            }

            if(prices[i] >= cost && prices[i] <= cost+fee){
                // 保持原有状态（因为此时买则不便宜，卖则亏本）
                // 在这个区间什么都不需要做，做了也是白折腾，这部分代码仅为说明逻辑，是冗余的。
                // 因为如果买入的话，成本比在之前卖出的最高价还高，那还干脆不如不在之前卖掉了
                continue;
            }

            if(prices[i] > cost + fee){
                result += prices[i] - cost - fee;
                //如果还在收获利润的区间里，
                //表示并不是真正的卖出，而计算利润每次都要减去手续费，
                //所以要让minPrice = prices[i] - fee;
                //这样在明天收获利润的时候，才不会多减一次手续费
                cost = prices[i] - fee;
            }
        }
        return result;
    }
};

968.监控二叉树 （可以跳过）

本题是贪心和二叉树的一个结合，比较难，一刷大家就跳过吧。

https://programmercarl.com/0968.%E7%9B%91%E6%8E%A7%E4%BA%8C%E5%8F%89%E6%A0%91.html

Tips：这道题其实想清楚思路后很直观，一定是要从下向上地去安排摄像头的位置。

为什么不从头结点开始看起呢，为啥要从叶子节点看呢？

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

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

局部最优推出全局最优，找不出反例，那么就按照贪心来！

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

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

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

来看看这个状态应该如何转移，先来看看每个节点可能有几种状态：

有如下三种：

• 该节点无覆盖
• 本节点有摄像头
• 本节点有覆盖

我们分别有三个数字来表示：

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

我的题解：

class Solution {
public:
    // 状态转移函数：
    // 0: 无覆盖
    // 1：有摄像头
    // 2：有覆盖
    int result;

    int traversal(TreeNode* node){
        if(node == NULL){
            // 空节点视为有覆盖处理
            return 2;
        }

        int left = traversal(node->left);
        int right = traversal(node->right);

        if(left == 0 || right == 0){
            result++;
            return 1;
        }
        else if(left == 1 || right == 1){
            return 2;
        }
        else if(left == 2 && right == 2){
            return 0;
        }
        return -1;
    }

    int minCameraCover(TreeNode* root) {
        result = 0;
        if(traversal(root) == 0){
            result++;
        }
        return result;
    }
};

总结

可以看看贪心算法的总结，贪心本来就没啥规律，能写出个总结篇真的不容易了。

https://programmercarl.com/%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%E6%80%BB%E7%BB%93%E7%AF%87.html