贪心算法学习（03）（代码随想录）

贪心算法理解

这学习以下5 道题（柠檬水找零、分发糖果等）是贪心算法在生活场景、数值调整与队列重构中的典型应用，核心不依赖区间操作，而是 “策略设计 + 有序处理” 的结合。先针对问题提炼局部最优规则（如找零优先保 5 元、分糖果分两轮遍历），再通过排序（如按绝对值 / 身高排序）或定向遍历（左右遍历、从后往前），让每步局部最优自然累积为全局最优。学习《代码随想录》笔记。

1. 题目：135. 分发糖果（最少糖果数）

题目分析

135. 分发糖果

n 个孩子站成一排，每个孩子至少 1 颗糖果，且相邻孩子中评分高的得更多糖果，求最少需准备的糖果数。核心是 “分两次遍历：先保证左到右的规则，再保证右到左的规则”。

代码解析

#include <vector>
#include <algorithm>
using namespace std;

class Solution {
public:
    int candy(vector<int>& ratings) {
        int n = ratings.size();
        if(n == 0) return 0;
        vector<int> candies(n, 1); // 初始化：每个孩子至少1颗糖果
        
        // 第一次遍历：左到右，确保“右边评分高的孩子比左边多”
        for(int i=0;i<n-1;i++){
            if(ratings[i+1] > ratings[i]){
                candies[i+1] = candies[i] + 1;
            }
        }
        
        // 第二次遍历：右到左，确保“左边评分高的孩子比右边多”（不破坏左到右的结果）
        for(int i=n-2;i>=0;i--){
            if(ratings[i] > ratings[i+1]){
                // 取max：保证既满足左>右，又不覆盖左到右时的更大值
                candies[i] = max(candies[i], candies[i+1] + 1);
            }
        }
        
        // 计算总糖果数
        int total = 0;
        for(int c : candies) total += c;
        return total;
    }
};

贪心思路提炼

• 局部最优 1（左到右）：只关注右边比左边评分高的情况，给右边多 1 颗糖果。
• 局部最优 2（右到左）：只关注左边比右边评分高的情况，给左边 “当前糖果数” 与 “右边 + 1” 的最大值。
• 全局最优：两次遍历后，所有相邻孩子的规则都满足，且总糖果数最少。

2. 题目：860. 柠檬水找零

860. 柠檬水找零

题目分析

柠檬水售价 5 美元，顾客付 5/10/20 美元，初始无零钱，需正确找零（净收入 5 美元），判断能否给所有顾客找零。核心是 “优先用大面额零钱找零，减少小面额零钱消耗”。

代码解析

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        bool canChange = true;
        int five = 0, ten = 0; // 记录5美元、10美元的数量（20美元无需记录，无法找零）
        
        for(int bill : bills){
            if(bill == 5){
                five++; // 收5美元，无需找零，5元数量+1
            }else if(bill == 10){
                ten++; // 收10美元，需找5美元
                if(five >= 1) five--;
                else{
                    canChange = false;
                    break;
                }
            }else if(bill == 20){
                // 收20美元，优先用10+5找零（减少10元消耗，保留更多5元找零）
                if(ten >= 1 && five >= 1){
                    ten--;
                    five--;
                }else if(five >= 3){ // 无10元时，用3张5元找零
                    five -= 3;
                }else{
                    canChange = false;
                    break;
                }
            }
        }
        return canChange;
    }
};

贪心思路提炼

• 局部最优：面对 20 美元找零时，优先用 10+5 的组合（而非 3 张 5 元），因为 5 元是找零 10 美元的唯一货币，需尽量保留。
• 全局最优：所有顾客都能正确找零。

3. 题目：1005. K 次取反后最大化的数组和

1005. K 次取反后最大化的数组和

题目分析

给定整数数组和 K，每次可将任意元素取反，恰好执行 K 次，求修改后数组的最大可能和。核心是 “优先反转绝对值大的负数，最后若 K 剩奇数则反转最小绝对值的数（相当于反复反转）”。

代码解析

class Solution {
public:
    // 自定义排序：按绝对值从大到小排，优先处理绝对值大的数
    static bool cmp(const int &a, const int &b){
        return abs(a) > abs(b);
    }
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        int sum = 0;
        sort(nums.begin(), nums.end(), cmp); // 按绝对值降序排序
        for(int i=0;i<nums.size()&&k>0;i++){
            if(nums[i] < 0){ // 优先反转负数（绝对值大的先转）
                nums[i] = -nums[i];
                k--;
            }
        }
        // 若K仍为奇数，反转最小绝对值的数（此时数组全非负，最后一个数绝对值最小）
        if(k % 2 == 1) nums[nums.size()-1] *= -1;
        // 计算最终数组和
        for(int num : nums) sum += num;
        return sum;
    }
};

贪心思路提炼

• 局部最优 1：每次反转时，优先选择 “绝对值最大的负数”，让数组和增加最多。
• 局部最优 2：若 K 剩奇数，反转 “绝对值最小的数”，让数组和减少最少。
• 全局最优：经过 K 次反转后，数组和最大。

4. 题目：406. 根据身高重建队列

406. 根据身高重建队列

题目分析

给定 people 数组（每个元素 [hi, ki] 表示身高 hi，前面有 ki 个≥hi 的人），重建符合要求的队列。核心是 “先排身高高的人，再按 ki 插入对应位置”—— 身高高的人不受身高矮的人影响。

代码解析

class Solution {
public:
    // 排序依据：按身高降序排，身高相同则按ki升序排
    static bool cmp(const vector<int>& a, const vector<int>& b){
        if(a[0] == b[0]) return a[1] < b[1];
        return a[0] > b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        vector<vector<int>> res;
        sort(people.begin(), people.end(), cmp); // 按身高降序排序
        // 按ki插入对应位置：ki即为该人在当前队列中的索引
        for(int i=0;i<people.size();i++){
            res.insert(res.begin() + people[i][1], people[i]);
        }
        return res;
    }
};

贪心思路提炼

• 局部最优：先处理身高高的人，他们的 ki 直接对应队列中的位置（因为后续插入的人身高更矮，不影响他们的 ki 计数）。
• 全局最优：最终队列满足每个人的 [hi, ki] 要求。

5. 题目：738. 单调递增的数字

738. 单调递增的数字

题目分析

给定整数 n，返回 “小于或等于 n 的最大单调递增数字”（单调递增指相邻位数 x≤y）。核心是 “从后往前找第一个递减位，将高位减 1，低位全设为 9”。

代码解析

class Solution {
public:
    int monotoneIncreasingDigits(int n) {
        if(n < 10) return n; // 个位数本身单调递增
        vector<int> digits; // 存储n的每一位（从低位到高位）
        while(n != 0){
            digits.push_back(n % 10);
            n /= 10;
        }
        int flag = 0; // 标记从哪一位开始需要设为9
        // 从低位往高位遍历（digits[0]是个位，digits[1]是十位）
        for(int i=0;i<digits.size()-1;i++){
            if(digits[i] < digits[i+1]){ // 发现当前位（低位）小于高位，需调整
                digits[i+1]--; // 高位减1
                flag = i+1; // 标记：从当前高位的下一位（i）开始，所有低位设为9
            }
        }
        // 将flag之前的低位（包括flag-1）全设为9
        for(int i=0;i<flag;i++) digits[i] = 9;
        // 重构数字
        int res = 0;
        for(int i=0;i<digits.size();i++){
            res += digits[i] * pow(10, i);
        }
        return res;
    }
};

贪心思路提炼

• 局部最优：找到第一个 “低位 < 高位” 的位置，将高位减 1（避免递减），并标记后续低位全设为 9（最大化数字）。
• 全局最优：最终得到的数字是小于等于 n 的最大单调递增数。

贪心算法总结

综合，跟随代码随想录，结合前面所学习的内容，学习了贪心算法的经典例题16道：

（一）场景 1：分配

场景特点：贴合现实规则（找零、分资源），核心是 “优先保留稀缺资源” 或 “最小资源满足最大需求”。

（二）场景 2：序列优化

场景特点：围绕 “数组 / 序列的差值、和、利润” 优化，核心是 “忽略无效局部（平坡、负数），聚焦有效变化”。

（三）场景 3：覆盖

场景特点：围绕 “范围覆盖”（数组跳跃、区间重叠、字符串片段），核心是 “最大化局部覆盖范围，减少操作次数”。

（四）场景 4：数值排序与队列重构

场景特点：需打破无序状态，核心是 “按关键维度排序（绝对值、身高），再定向调整数值或插入位置”。