您现在的位置是：首页 >技术交流 >代码随想录算法训练营第三十四天 | 加油站题、左右贪心网站首页技术交流

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

文档讲解：代码随想录 (programmercarl.com)

视频讲解：贪心算法，这不就是常识？还能叫贪心？LeetCode：1005.K次取反后最大化的数组和_哔哩哔哩_bilibili

状态：能做出来。下面是文档的思路。

思路

1. 贪心的思路，局部最优：让绝对值大的负数变为正数，当前数值达到最大，整体最优：整个数组和达到最大。
2. 那么如果将负数都转变为正数了，K依然大于0，此时的问题是一个有序正整数序列，如何转变K次正负，让 数组和 达到最大。那么又是一个贪心：局部最优：只找数值最小的正整数进行反转，当前数值和可以达到最大（例如正整数数组{5, 3, 1}，反转1 得到-1 比 反转5得到的-5 大多了），全局最优：整个 数组和 达到最大。

这么一道简单题，就用了两次贪心！

本题的解题步骤为：

• 第一步：将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小
• 第二步：从前向后遍历，遇到负数将其变为正数，同时K–
• 第三步：如果K还大于0，那么反复转变数值最小的元素，将K用完
• 第四步：求和

class Solution {
static bool cmp(int a, int b) {
    return abs(a) > abs(b);
}
public:
    int largestSumAfterKNegations(vector<int>& A, int K) {
        sort(A.begin(), A.end(), cmp);       // 第一步
        for (int i = 0; i < A.size(); i++) { // 第二步
            if (A[i] < 0 && K > 0) {
                A[i] *= -1;
                K--;
            }
        }
        if (K % 2 == 1) A[A.size() - 1] *= -1; // 第三步
        int result = 0;
        for (int a : A) result += a;        // 第四步
        return result;
    }
};

134. 加油站

文档讲解：代码随想录 (programmercarl.com)

视频讲解：贪心算法，得这么加油才能跑完全程！LeetCode ：134.加油站_哔哩哔哩_bilibili

状态：暴力思路有，贪心思路没有。

思路

暴力方法

暴力的方法很明显就是O(n^2)的，遍历每一个加油站为起点的情况，模拟一圈。

如果跑了一圈，中途没有断油，而且最后油量大于等于0，说明这个起点是ok的。

for循环适合模拟从头到尾的遍历，而while循环适合模拟环形遍历，要善于使用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]; // 记录剩余油量
            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;
    }
};

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)

贪心算法

1. 首先，如果总油量减去总消耗小于零那么肯定跑不完一圈，否则，说明一定可以跑完一圈。

2. 每个加油站的剩余量rest[i]为gas[i] - cost[i]。

   i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。如下图

那么为什么一旦[0，i] 区间和为负数，起始位置就可以是i+1呢，i+1后面就不会出现更大的负数？

如果出现更大的负数，就是更新i，那么起始位置又变成新的i+1了。后面肯定会有一个位置是起始位置，因为一定可以跑完一圈。

那么局部最优：当前累加rest[i]的和curSum一旦小于0，起始位置至少要是i+1，因为从i之前开始一定不行。全局最优：找到可以跑一圈的起始位置。

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int totalSum = 0;
        for(int i = 0; i < gas.size(); ++i) totalSum += gas[i] - cost[i];
        if(totalSum < 0) return -1; //如果总油量减去总消耗小于零那么肯定跑不完一圈
        /*否则，说明一定可以跑完一圈*/

        int start = 0, curSum = 0;
        for(int i = 0; i < gas.size(); i++){
            curSum += gas[i] - cost[i];
            if(curSum < 0){
                start = i + 1;
                curSum = 0;
            }
        }
        return start;
    }
};

135. 分发糖果

文档讲解：https://programmercarl.com/0135.%E5%88%86%E5%8F%91%E7%B3%96%E6%9E%9C.html#%E6%80%9D%E8%B7%AF

视频讲解：贪心算法，两者兼顾很容易顾此失彼！LeetCode：135.分发糖果_哔哩哔哩_bilibili

状态：不会做。看视频讲解会比较直观。

思路

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 sum = 0;
        for(int i = 0; i < candyVec.size(); i++) sum += candyVec[i];
        return sum;
    }
};