LeetCode | C++ 贪心算法——1005.K次取反后最大化的数组和 、134. 加油站、135. 分发糖果

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

贪心的思路：

（1）局部最优：让绝对值大的负数变为正数，当前数值达到最大，整体最优：整个数组和达到最大。

（2）如果负数全变为整数，K依然大于0，局部最优：只找数值最小的正整数进行反转，当前数值和可以达到最大，全局最优：整个 数组和 达到最大。

本题的解题步骤为：

• 第一步：将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小
• 第二步：从前向后遍历，遇到负数将其变为正数，同时K–
• 第三步：如果K还大于0，那么反复转变数值最小的元素，将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] = -nums[i];
            }
        }
        if (k % 2 == 1) nums[nums.size() - 1] = -nums[nums.size() - 1];
 
        int sum = 0;
        for (int i : nums) {
            sum += i;
        }
        return sum;
    }
};

134. 加油站

暴力解法

暴力解法：主要是模拟跑一圈的过程，可以使用取余% 来模拟 ： index = (index + 1) % cost.size()

暴力解法会超出时间限制

for循环适合模拟从头到尾的遍历，而while循环适合模拟环形遍历，要善于使用while！

class Solution {
public:
    // 暴力解法
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        for (int i = 0; i < gas.size(); i++) {
            int rest = gas[i] - cost[i];
            int index = (i + 1) % gas.size();
            while (rest > 0 && index != i) { // 如果有rest==0，那么答案就不唯一了
                rest += gas[index] - cost[index];
                index = (index + 1) % gas.size();
            }
            if (rest >= 0 && index == i) return i; 
        }
        return -1;
    }
};

贪心解法

贪心解法：

如果所有站点的剩油量之和 totalSum 小于0，说明无论如何也是跑不完一圈的

i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。 这个证明：可以通过举反例：假设从[0,i]之间可以，会推出矛盾

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

class Solution {
public:
    // 贪心解法
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int totalSum = 0;
        int curSum = 0;
        int startIndex = 0;
        for (int i = 0; i < gas.size(); i++) {
            int rest = gas[i] - cost[i];
            curSum += rest;
            totalSum += rest;
            if (curSum < 0){
                curSum = 0;
                startIndex = i + 1;
            }
        }
        if (totalSum < 0) return -1;
        return startIndex;
    }
};

135. 分发糖果

这道题目一定是要确定一边之后，再确定另一边，例如比较每一个孩子的左边，然后再比较右边，如果两边一起考虑一定会顾此失彼。

首先从左向右遍历，先确定右边评分大于左边的情况，只要右边比左边的大，右边就比左边多一个糖果，全局最优：相邻的孩子中，评分高的右孩子获得比左边孩子更多的糖果

然后再从右向左遍历，确定左边比右边大的情况，只要左边比右边的大，左边就比右边多一个糖果，此时candyVec[i]（第i个小孩的糖果数量）就有两个选择了，一个是candyVec[i + 1] + 1（从右边这个加1得到的糖果数量），一个是candyVec[i]（之前比较右孩子大于左孩子得到的糖果数量）。

局部最优：取candyVec[i + 1] + 1 和 candyVec[i] 最大的糖果数量，保证第i个小孩的糖果数量既大于左边的也大于右边的。全局最优：相邻的孩子中，评分高的孩子获得更多的糖果。

总结：先考虑一边，再确定另一边，然后去两者中最大的那个。

class Solution {
public:
    int candy(vector<int>& ratings) {
        int result = 0;
        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);
            }
        }

        for (int i : candyVec) {
            result += i;
        }
        return result;
    }
};