代码随想录算法训练营第23天 | 第八章 贪心算法 part01

第八章 贪心算法 part01

贪心算法其实就是没有什么规律可言，所以大家了解贪心算法就了解它没有规律的本质就够了。不用花心思去研究其规律，没有思路就立刻看题解。基本贪心的题目有两个极端，要不就是特简单，要不就是死活想不出来。学完贪心之后再去看动态规划，就会了解贪心和动规的区别。

• 将问题分解为若干个子问题
• 找出适合的贪心策略
• 求解每一个子问题的最优解
• 将局部最优解堆叠成全局最优解

理论基础

• 贪心算法理论基础

455. 分发饼干

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int i=g.size()-1;//孩子胃口值
        int j=s.size()-1;//饼干尺寸 s[j]
        int result=0;
       while (i >= 0&& j >= 0) {
            if (s[j] >= g[i]) {
                result++;
                j--;
            }
            i--;
        }
        return result;
    }
};

最开始写的是双层循环，后来发现能单层循环就单层循环。单层循环还好写些。代码思路确保每个饼干都被用来满足尽可能“大”的孩子的胃口。其实我感觉优先让胃口最小的孩子被满足也是一个合理的思路。但是确实不能先遍历饼干，在遍历胃口，虽然我觉得理论上是可以的，但是得要两个for循环，确实复杂度会增加。

376. 摆动序列

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        int result = 1;
        int pre = 0, cur = 0;
        for(int i=1;i<nums.size();i++)
        {
            cur = nums[i] - nums[i - 1];
            if ((currDiff > 0 && prevDiff <= 0) || (currDiff < 0 && prevDiff >= 0)) {
                result++;
                pre = cur; 
            }                  
        }
        return result;
    }
};

这题看着挺简单的，我就想着可不可以直接前一个差值*后一个差值<0来判断，结果最大的问题要考虑初始两个值，以及如果差值为0的情况，一下子变得复杂了。就得更改下条件
(currDiff > 0 && prevDiff <= 0) || (currDiff < 0 && prevDiff >= 0)，因为它既能捕捉正负趋势的变化，又能忽略零值对趋势的影响。这种方法可以处理零值的边界情况，确保摆动序列的计算符合逻辑。
当 currDiff > 0 且 prevDiff <= 0 时，说明当前序列从非正（小于等于0）转变为正数，形成了一个 “摆动”。
当 currDiff < 0 且 prevDiff >= 0 时，说明当前序列从非负（大于等于0）转变为负数，也形成了一个 “摆动”。
这种条件可以捕捉到从零穿过的情况。例如，当相邻元素的差值恰好为0时，前后序列趋势没有改变，因此不计入摆动。
它能处理由正数变成负数，或者由负数变成正数的所有情况，包括零值的边界。
知道这几点，就不难了。确实都是细节

53. 最大子序和

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result = INT32_MIN;
        int count = 0;
        for(int i=0;i<nums.size();i++)
        {
            count+=nums[i];
            if(count>=result)
            result=count;
             if(count<0)
            count=0;
        }
        return result;
    }
};

这题的思路就是遍历 nums，从头开始用 count 累积，如果 count 一旦加上 nums[i]变为负数，那么就应该从 nums[i+1]开始从 0 累积 count 了，因为已经变为负数的 count，只会拖累总和。
别看贪心理论很直白，有时候看似是常识，但贪心的题目一点都不简单！确实好难
不少同学认为 如果输入用例都是-1，或者 都是负数，这个贪心算法跑出来的结果是 0， 这是又一次证明脑洞模拟不靠谱的经典案例，建议大家把代码运行一下试一试，就知道了，也会理解 为什么 result 要初始化为最小负数了。确实开始我也这么想得,后来写的时候，才意识到，为什么count+=nums[i];这句话要放在前面，先加了，再判断，<0就抛弃，即便<0,也是在一遍遍遍历更新。
贪心算法确实挺难的，一点学习更新。