代码随想录训练营day37

第八章 贪心算法 part06

1.LeetCode. 单调递增的数字

1.1题目链接：738.单调递增的数字

文章讲解：代码随想录
视频讲解：B站卡哥视频

1.2思路：题目要求小于等于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

本题只要想清楚个例，例如98，一旦出现strNum[i - 1] > strNum[i]的情况（非单调递增），首先想让strNum[i - 1]减一，strNum[i]赋值9，这样这个整数就是89。就可以很自然想到对应的贪心解法了。

想到了贪心，还要考虑遍历顺序，只有从后向前遍历才能重复利用上次比较的结果。

最后代码实现的时候，也需要一些技巧，例如用一个flag来标记从哪里开始赋值9

1.3附加代码如下所示：

class Solution {
public:
    int monotoneIncreasingDigits(int n) {
        string strNum=to_string(n);//将数字转化为字符串
        int flag=strNum.size();//初始化falg,不能随意初始化flag，防止不走第一个循环时候直接走第二个循环了，即题目是符合提议的递增数字不需要进行改变
        //采用从后往前进行遍历寻找不符合递增的位置
        for(int i=strNum.size()-1;i>0;i--)
        {
            if(strNum[i-1]>strNum[i])
            {
                strNum[i-1]--;
                flag=i;
            }
        }
        for(int i=flag;i<strNum.size();i++)
        {
            strNum[i]='9';//从最后找到的非递增位置向后更新字符为9
        }
        return stoi(strNum);//字符串转化为数字

    }
};

2.LeetCode. 监控二叉树

2.1题目链接：968.监控二叉树

文章讲解：代码随想录
视频讲解：B站卡哥视频

2.2思路：从题目中示例，其实可以得到启发，我们发现题目示例中的摄像头都没有放在叶子节点上！

这是很重要的一个线索，摄像头可以覆盖上中下三层，如果把摄像头放在叶子节点上，就浪费的一层的覆盖。

所以把摄像头放在叶子节点的父节点位置，才能充分利用摄像头的覆盖面积。

那么有同学可能问了，为什么不从头结点开始看起呢，为啥要从叶子节点看呢？

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

所以我们要从下往上看，局部最优：让叶子节点的父节点安摄像头，所用摄像头最少，整体最优：全部摄像头数量所用最少！
此时，大体思路就是从低到上，先给叶子节点父节点放个摄像头，然后隔两个节点放一个摄像头，直至到二叉树头结点。

此时这道题目还有两个难点：

二叉树的遍历
如何隔两个节点放一个摄像头

如何隔两个节点放一个摄像头
此时需要状态转移的公式，大家不要和动态的状态转移公式混到一起，本题状态转移没有择优的过程，就是单纯的状态转移！

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

有如下三种：

该节点无覆盖
本节点有摄像头
本节点有覆盖
我们分别有三个数字来表示：

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

四种情况：
情况1：左右节点都有覆盖
左孩子有覆盖，右孩子有覆盖，那么此时中间节点应该就是无覆盖的状态了。

如图：

情况2：左右节点至少有一个无覆盖的情况
如果是以下情况，则中间节点（父节点）应该放摄像头：

left == 0 && right == 0 左右节点无覆盖
left == 1 && right == 0 左节点有摄像头，右节点无覆盖
left == 0 && right == 1 左节点有无覆盖，右节点摄像头
left == 0 && right == 2 左节点无覆盖，右节点覆盖
left == 2 && right == 0 左节点覆盖，右节点无覆盖

情况3：左右节点至少有一个有摄像头
如果是以下情况，其实就是 左右孩子节点有一个有摄像头了，那么其父节点就应该是2（覆盖的状态）

left == 1 && right == 2 左节点有摄像头，右节点有覆盖
left == 2 && right == 1 左节点有覆盖，右节点有摄像头
left == 1 && right == 1 左右节点都有摄像头

情况4：头结点没有覆盖
以上都处理完了，递归结束之后，可能头结点 还有一个无覆盖的情况，如图：

2.3附加代码如下所示：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

//采用后序遍历 
class Solution {
public:
    int result;
    int traversal(TreeNode*node)
    {
        if(node==NULL)return 2;//这里要特别处理空节点情况，空节点要被安置为被覆盖状态才能达到是子节点的父节点尽量安置摄像头实现摄像头最小数量化
        int left=traversal(node->left);//左
        int right=traversal(node->right);//右
        //中  要考虑四种情况，最后一种头节点没有呗监视到要另外处理
        if(left==2&&right==2)return 0;//左右孩子都被覆盖了，返回父节点值0，表示父节点未被覆盖
        if(left==0||right==0)
        {
           result++;
           return 1;//左右孩子之一未被覆盖，返回父节点1，表示父节点需要有摄像头 
        }
        if(left==1||right==1)return 2;//左右孩子之一右摄像头了，返回2，表示父节点被覆盖了

        return -1;
    }
    int minCameraCover(TreeNode* root) {
        result=0;
        if(traversal(root)==0)//第四种情况，遍历结束，头节点没有被覆盖
        {
            result++;
        }
        return result;

    }
};

3.总结：

代码随想录
（1）贪心简单题
以下三道题目就是简单题，大家会发现贪心感觉就是常识。是的，如下三道题目，就是靠常识，但我都具体分析了局部最优是什么，全局最优是什么，贪心也要贪的有理有据！
贪心算法：分发饼干
贪心算法：K次取反后最大化的数组和
贪心算法：柠檬水找零

（2）贪心算法中等题
贪心中等题，靠常识可能就有点想不出来了。开始初现贪心算法的难度与巧妙之处。
贪心算法：摆动序列
贪心算法：单调递增的数字
（3）贪心解决股票问题
大家都知道股票系列问题是动规的专长，其实用贪心也可以解决，而且还不止就这两道题目，但这两道比较典型，我就拿来单独说一说
贪心算法：买卖股票的最佳时机II
贪心算法：买卖股票的最佳时机含手续费

（4）两个维度权衡问题
在出现两个维度相互影响的情况时，两边一起考虑一定会顾此失彼，要先确定一个维度，再确定另一个一个维度。
贪心算法：分发糖果
贪心算法：根据身高重建队列

（5）贪心解决区间问题

贪心算法：跳跃游戏
贪心算法：跳跃游戏II
贪心算法：用最少数量的箭引爆气球
贪心算法：无重叠区间
贪心算法：划分字母区间
贪心算法：合并区间

（6）其他难题
贪心算法：最大子序和 贪心算法：最大子序和其实是动态规划的题目，但贪心性能更优，很多同学也是第一次发现贪心能比动规更优的题目。

贪心算法：加油站 贪心算法：加油站可能以为是一道模拟题，但就算模拟其实也不简单，需要把while用的很娴熟。但其实是可以使用贪心给时间复杂度降低一个数量级。

最后贪心系列压轴题目贪心算法：我要监控二叉树！贪心算法：我要监控二叉树 (opens new window)，不仅贪心的思路不好想，而且需要对二叉树的操作特别娴熟，这就是典型的交叉类难题了。

贪心专题汇聚为一张图：