代码随想录 贪心1

1.分发饼干

https://leetcode.cn/problems/assign-cookies/

class Solution {
public:
    //为了满足更多的小孩，就不要造成饼干尺寸的浪费。
    //大尺寸的饼干既可以满足胃口大的孩子也可以满足胃口小的孩子，那么就应该优先满足胃口大的。
    //这里的局部最优就是大饼干喂给胃口大的，充分利用饼干尺寸喂饱一个，全局最优就是喂饱尽可能多的小孩。
    //尝试使用贪心策略，先将饼干数组和小孩数组排序。然后从后向前遍历小孩数组，用大饼干优先满足胃口大的，并统计满足小孩数量。
    
    int findContentChildren(vector<int>& g, vector<int>& s) {
        //排序
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        //大尺寸饼干，优先满足胃口大的小孩
        int index = s.size()-1; //采用指针index指向饼干尺寸，避免依次循环
        int result = 0;
            //遍历小孩的胃口
        for(int i = g.size()-1;i>=0;i--){
            if(index >= 0 && g[i] <= s[index]){
                index--;
                result++;
            }
        }
        return result;

    }
};

2.最大子数组和

https://leetcode.cn/problems/maximum-subarray/submissions/

class Solution {
public:
    //局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。
    //全局最优：选取最大“连续和”
    
    int maxSubArray(vector<int>& nums) {
        int result = INT32_MIN;
        cout<<result;
        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;
    }
};

3.买卖股票的最佳时机 II

https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/

class Solution {
public:
   //最终利润是可以分解的
    //prices[3] - prices[0]。相当于(prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])。
    //此时就是把利润分解为每天为单位的维度，而不是从0天到第3天整体去考虑

    //也就是，我要求0天买入，3天卖出的利润，只需要求出前面每一天与前一天的利润，之后求和即可。
    //所以最大利润，为相邻两天利润序列中，为正数元素之和
    
    int maxProfit(vector<int>& prices) {
        int result =0;
        for(int i=1;i<prices.size();i++){
            result += max(prices[i]-prices[i-1],0);//正数元素之和
        }
        return result;
    }
};

4.跳跃游戏

https://leetcode.cn/problems/jump-game/submissions/

class Solution {
public:
    // 不一定非要明确一次究竟跳几步，每次取最大的跳跃步数，这个就是可以跳跃的覆盖范围。
    // 那么这个问题就转化为跳跃覆盖范围究竟可不可以覆盖到终点！
    // 贪心算法局部最优解：每次取最大跳跃步数（取最大覆盖范围），整体最优解：最后得到整体最大覆盖范围，看是否能到终点。
    
    bool canJump(vector<int>& nums) {
        int cover = 0;
        if (nums.size() == 1) return true; // 只有一个元素，就是能达到

        for (int i = 0; i <= cover; i++) { // 注意这里是小于等于cover
            cover = max(i + nums[i], cover);
            if (cover >= nums.size() - 1) return true; // 说明可以覆盖到终点了
        }

        return false;
    }
};