_32LeetCode代码随想录算法训练营第三十二天-贪心算法 | 738.单调递增的数字 、714.买卖股票的最佳时机含手续费、968.监控二叉树

_32LeetCode代码随想录算法训练营第三十二天-贪心算法 | 738.单调递增的数字 、714.买卖股票的最佳时机含手续费、968.监控二叉树

题目列表

• 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

题目

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

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

示例 1:

输入: n = 10
输出: 9

示例 2:

输入: n = 1234
输出: 1234

示例 3:

输入: n = 332
输出: 299

思路

首先将n转换为字符串strNum

遇到strNum[i - 1] > strNum[i]的情况，让strNum[i - 1]–，记录最终改变strNum[i]的位置，它以及它后面的元素全部变为9。

从后往前遍历。

代码

/*
 * @lc app=leetcode.cn id=738 lang=cpp
 *
 * [738] 单调递增的数字
 */

// @lc code=start
class Solution {
public:
    int monotoneIncreasingDigits(int n) {
        //将数据转换为字符串
        string str = to_string(n);
        int flag = str.size();//记录从什么地方开始变为9
        for(int i = str.size() - 1; i > 0; i--)
        {
            //如果遇到str[i - 1] > str[i]，那么就将str[i - 1]--，并将str[i]设置为9
            if(str[i - 1] > str[i])
            {
                str[i - 1]--;
                flag = i;
            }                
        }
        //将flag位置及其后面的元素全部置为'9'
        for(int i = flag; i < str.size(); i++)
        {
            str[i] = '9';
        }
        return stoi(str);
    }
};
// @lc code=end

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

题目

给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

**注意：**这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

示例 1：

输入：prices = [1, 3, 2, 8, 4, 9], fee = 2
输出：8
解释：能够达到的最大利润:  
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8

示例 2：

输入：prices = [1,3,7,5,10,3], fee = 3
输出：6

说明

是动态规划的经典题目，贪心算法比较拗口，因此跳过。

968.监控二叉树

代码随想录地址：https://programmercarl.com/0968.%E7%9B%91%E6%8E%A7%E4%BA%8C%E5%8F%89%E6%A0%91.html

题目

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

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

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

示例 1：

输入：[0,0,null,0,0]
输出：1
解释：如图所示，一台摄像头足以监控所有节点。

示例 2：

输入：[0,0,null,0,null,0,null,null,0]
输出：2
解释：需要至少两个摄像头来监视树的所有节点。 上图显示了摄像头放置的有效位置之一。

提示：

1. 给定树的节点数的范围是 [1, 1000]。
2. 每个节点的值都是 0。

思路

整体思路

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

为什么不从头节点开始安装摄像头，因为要计算最少的监控数量；如果从头节点开始，那么最多也就能省下一个摄像头，从叶子节点开始，就能省下很多摄像头。

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

本题的两个难点：

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

难点1

选择后序遍历，也就是左右中的遍历，以达到从叶子节点开始考虑安装摄像头。

难点2

使用状态转移的方式，综合考虑所有节点只可能有这三种状态。

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

空节点应该是哪种状态？如果空节点为无覆盖，那么空节点的父节点——叶子节点也是无覆盖的，需要在叶子节点放摄像头，不符合要求最少摄像头数量；如果空节点有摄像头，那么叶子节点就是有覆盖的，叶子节点的父节点是无覆盖的，不需要在叶子节点的父节点放置摄像头，不成立；如果空节点为有覆盖，那么叶子节点就是无覆盖的，需要在叶子节点的父节点放置摄像头，成立。因此，空节点应该是有覆盖的状态。

因此递归的终止条件为：

// 空节点，该节点有覆盖
if (cur == NULL) return 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：头结点没有覆盖

其实就是三种情况，当前节点为状态0、1、2

代码

/*
 * @lc app=leetcode.cn id=968 lang=cpp
 *
 * [968] 监控二叉树
 */

// @lc code=start
/**
 * 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 {
private:
    int result;
    int traversal(TreeNode* cur) {

        // 空节点，该节点有覆盖
        if (cur == NULL) return 2;

        int left = traversal(cur->left);    // 左
        int right = traversal(cur->right);  // 右

        // 情况1
        // 左右节点都有覆盖，那么其父节点无覆盖，返回0
        if (left == 2 && right == 2) return 0;

        // 情况2
        // left == 0 && right == 0 左右节点无覆盖
        // left == 1 && right == 0 左节点有摄像头，右节点无覆盖
        // left == 0 && right == 1 左节点有无覆盖，右节点摄像头
        // left == 0 && right == 2 左节点无覆盖，右节点覆盖
        // left == 2 && right == 0 左节点覆盖，右节点无覆盖
        if (left == 0 || right == 0) {
            result++;
            return 1;//在当前节点放置摄像头
        }

        // 情况3
        // left == 1 && right == 2 左节点有摄像头，右节点有覆盖
        // left == 2 && right == 1 左节点有覆盖，右节点有摄像头
        // left == 1 && right == 1 左右节点都有摄像头
        // 其他情况前段代码均已覆盖，前面已经判断了左右至少有一个无覆盖的情况
        if (left == 1 || right == 1) return 2;

        // 以上代码我没有使用else，主要是为了把各个分支条件展现出来，这样代码有助于读者理解
        // 这个 return -1 逻辑不会走到这里。
        return -1;
    }

public:
    int minCameraCover(TreeNode* root) {
        result = 0;
        // 情况4
        if (traversal(root) == 0) { // root 无覆盖
            result++;
        }
        return result;
    }
};
// @lc code=end

贪心算法总结

代码随想录地址：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

贪心简单题

• 贪心算法：分发饼干(opens new window)
• 贪心算法：K次取反后最大化的数组和(opens new window)
• 贪心算法：柠檬水找零(opens new window)

贪心中等题

• 贪心算法：摆动序列(opens new window)
• 贪心算法：单调递增的数字(opens new window)

贪心解决股票问题

• 贪心算法：买卖股票的最佳时机II(opens new window)
• 贪心算法：买卖股票的最佳时机含手续费(opens new window)

两个维度权衡问题

在出现两个维度相互影响的情况时，两边一起考虑一定会顾此失彼，要先确定一个维度，再确定另一个一个维度。

• 贪心算法：分发糖果(opens new window)
• 贪心算法：根据身高重建队列

贪心难题

贪心解决区间问题

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

其他难题

贪心算法：最大子序和 (opens new window)

贪心算法：加油站 (opens new window)

贪心算法：我要监控二叉树！ (opens new window)