贪心算法leetcode题目整理

分发饼干

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

跳跃游戏

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

给定一个非负整数数组，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个位置。

思路：我们不知道跳几步，也不知道按照当前的最大步数跳过去是不是能满足要求，局部最优解是每到一个地方跳最大，也就是获取最大覆盖范围，整体最优是最后得到整体的最大覆盖范围。

代码如下：

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;
    }
};

跳跃游戏II

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

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

你的目标是使用最少的跳跃次数到达数组的最后一个位置。

思路：这道题相比上一道题，多了跳跃次数限制的要求：

贪心的思路，局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最小步数。

思路虽然是这样，但在写代码的时候还不能真的能跳多远就跳多远，那样就不知道下一步最远能跳到哪里了。

所以真正解题的时候，要从覆盖范围出发，不管怎么跳，覆盖范围内一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最小步数！

这里需要统计两个覆盖范围，当前这一步的最大覆盖和下一步最大覆盖。

如果移动下标达到了当前这一步的最大覆盖最远距离了，还没有到终点的话，那么就必须再走一步来增加覆盖范围，直到覆盖范围覆盖了终点。

class Solution {
public:
    int jump(vector<int>& nums) {
        int curDistance = 0;    // 当前覆盖的最远距离下标
        int ans = 0;            // 记录走的最大步数
        int nextDistance = 0;   // 下一步覆盖的最远距离下标
        for (int i = 0; i < nums.size() - 1; i++) { // 注意这里是小于nums.size() - 1，这是关键所在
            nextDistance = max(nums[i] + i, nextDistance); // 更新下一步覆盖的最远距离下标
            if (i == curDistance) {                 // 遇到当前覆盖的最远距离下标
                curDistance = nextDistance;         // 更新当前覆盖的最远距离下标
                ans++;
            }
        }
        return ans;
    }
};

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

给定一个整数数组 A，我们只能用以下方法修改该数组：我们选择某个索引 i 并将 A[i] 替换为 -A[i]，然后总共重复这个过程 K 次。（我们可以多次选择同一个索引 i。）

以这种方式修改数组后，返回数组可能的最大和。

思路：首先按照绝对值大小从大到小进行排序（用到了cmp快排）然后从前向后遍历，如果遇到负数就转为正数，同时K--，然后如果K还大于零，此时分为两种情况，一种是k为偶数，这个时候不用管，因为（-1）^k为1，不影响结果。如k是奇数，则针对最小的数进行求反，从而减少整体和的损耗。

代码如下：

class Solution {
static bool cmp(int a, int b){
    return abs(a) > abs(b);
}
public:
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end(),cmp);
        for(int i = 0; i < nums.size(); i++){
           if(nums[i] < 0 && k > 0){
               nums[i] *= -1;
               k--;
           }
        }
        if(k % 2 == 1) nums[nums.size() - 1] *= -1;
        int result = 0;
        for(int a : nums) result += a;
        return result;
    }
};

加油站

https://leetcode.cn/problems/gas-station/

思路：

首先考虑如果使用暴力解法，将要面临环形的问题，也就是如何循环遍历数组，这里提供了一种使用while配合余数的单层循环思路：

代码如下：

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        for (int i = 0; i < cost.size(); i++) {
            int rest = gas[i] - cost[i]; // 记录剩余油量
//这里使用Index作为一圈的统计，通过当前数+1除以总大小求余数的思路，当余数为0的时候，也就是走了一圈的时候。
            int index = (i + 1) % cost.size();
            while (rest > 0 && index != i) { // 模拟以i为起点行驶一圈（如果有rest==0，那么答案就不唯一了）
                rest += gas[index] - cost[index];
                index = (index + 1) % cost.size();
            }
            // 如果以i为起点跑一圈，剩余油量>=0，返回该起始位置
            if (rest >= 0 && index == i) return i;
        }
        return -1;
    }
};

但是发现暴力解法超时了，需要考虑贪心算法：

那么我们通过暴力解法是不是可以想到，我们想要走完这一圈，油量一定要比损耗要高，那么我们从0开始，假如我们走到了3，这个时候我们的油量为负数，也就是说在0-3这一阶段我们从任何地方出发都不会回到原点，因为我们到3这里一定会断油。所以我们从4开始重新走

代码：

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int cursum = 0;
        int totalsum = 0;
        int start = 0;
        for(int i = 0; i < gas.size(); i++){
            cursum += gas[i] - cost[i];
            totalsum += gas[i] - cost[i];
            if(cursum < 0){
                start = i + 1;
                cursum = 0;
            }
            
        }
        if(totalsum < 0) return -1;
        return start;

    }
};

分发糖果

https://leetcode.cn/problems/candy/

思路：从前往后遍历，去查看后者是否大于前者，根据大小给予糖果；从后往前遍历，去查看前者是否大于后者，根据大小给予糖果；然后取糖果最大值：

代码如下：

class Solution {
public:
    int candy(vector<int>& ratings) {
        vector<int> candyVec(ratings.size(), 1);
        // 从前向后
        for (int i = 1; i < ratings.size(); i++) {
            if (ratings[i] > ratings[i - 1]) candyVec[i] = candyVec[i - 1] + 1;
        }
        // 从后向前
        for (int i = ratings.size() - 2; i >= 0; i--) {
            if (ratings[i] > ratings[i + 1] ) {
                candyVec[i] = max(candyVec[i], candyVec[i + 1] + 1);
            }
        }
        // 统计结果
        int result = 0;
        for (int i = 0; i < candyVec.size(); i++) result += candyVec[i];
        return result;
    }
};