代码随想录训练营第三十四天打卡|1005.K次取反后最大化的数组和 134. 加油站 135. 分发糖果

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

1.要达到最大化数组和，很自然地想到优先把小的负数取反。如果负数全部取反之后，翻转次数k还有剩余，那么就考虑把当前数组最小数（是个正数）反复取反。朴素思考的过程中自然而然地采用了贪心策略。

class Solution {
public:
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end()); //排序
        for (int i = 0; i < nums.size() && k > 0; i++) {
            if (nums[i] <= 0) { //从小到大把数组非正数取反
                nums[i] = -nums[i];
                k--;
            } else
                break; //如果k用不完就跳出循环
        }
        //此时数组全为正数，若k为偶数，则结束取反
        if (k % 2 == 1) { //若k为奇数，把数组排序，把最小值取反
            sort(nums.begin(), nums.end());
            nums[0] = -nums[0];
            k = 0;
        }
        int sum = 0; //计算数组和
        for (int num : nums)
            sum += num;
        return sum;
    }
};

2.随想录版，区别在于排序的时候是按绝对值从大到小排序的。那么当把负数全部翻转为正数之后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. 加油站

1.上来没什么思路，考虑暴力法，写了两层循环。两个测试用例没过，超时了。（虽然是暴力法，但其实模拟过程也不简单，代码也是修改了几次，可读性一般，仅供参考）

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int i = 0;
        int size = gas.size();
        while (i < size) {
            if (gas[i] >= cost[i] && gas[i] != 0) {
                int sum = 0, j = 0;
                for (j = 0; j < size; j++) {
                    sum += gas[(i + j) % size] - cost[(i + j) % size];
                    if (sum < 0)
                        break;
                }
                if (j == size)
                    return i;
                else {
                    i++;
                }
            } else
                i++;
        }
        return -1;
    }
};

2.贪心策略：构造加油与消耗汽油的差值数组，计算剩余油量。剩余油量<0，一定跑不了一圈，因为无论从哪个加油站开始，总汽油不够用一定跑不完。剩余油量>=0，一定能跑完一圈。为什么？因为差值数组一定能分成连续的两部分，一部分之和>=0(这部分的开头必须>=0，保证能从这里起跑)，另一部分之和<=0，且这两部分之和一定>=0，这时候>=0的那一部分的开头就是起始位置。

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        vector<int> diff; //计算差值
        for (int i = 0; i < gas.size(); i++) {
            diff.push_back(gas[i] - cost[i]);
        }
        int sum = 0;
        for (int i = 0; i < diff.size(); i++) {
            sum += diff[i];
        }
        if (sum < 0) //剩余油量<0，一定跑不了一圈
            return -1;
        int count = 0, start = 0; //否则，则一定能跑一圈
        for (int j = 0; j < diff.size(); j++) {
            count += diff[j];
            if (count < 0) { //剩余油量<0，则起始位置至少是j+1
                start = j + 1;
                count = 0; //重置剩余油量
            }
        }
        return start;
    }
};

3.全局考虑法，情况1和2都比较容易理解，关键是如何理解情况3。情况3是从后往前填平之前的漏洞，这个漏洞在之后碰到>=0的rest都不再更新了，因为漏洞是最小值。所以只要从后往前填平漏洞就能找到起始位置，因为这时候就相当于找到了一个起始位置>=0的部分，且这部分之和>=0,且这部分之和与另一之和<=0的部分之和>=0。(>=0的那部分往后继续行驶的过程中不可能<0，否则就违背了与另一部分之和的和>=0这个条件)

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int curSum = 0;
        int min = INT_MAX; // 从起点出发，油箱里的油量最小值
        for (int i = 0; i < gas.size(); i++) {
            int rest = gas[i] - cost[i];
            curSum += rest;
            if (curSum < min) {
                min = curSum;
            }
        }
        if (curSum < 0)
            return -1; // 情况1
        if (min >= 0)
            return 0; // 情况2
                      // 情况3
        for (int i = gas.size() - 1; i >= 0; i--) {
            int rest = gas[i] - cost[i];
            min += rest;
            if (min >= 0) {
                return i;
            }
        }
        return -1;
    }
};

135. 分发糖果

1.没有想到两次遍历的贪心策略。第一反应是从左向右依次遍历，遇见一个处理一个。没有找到统一的处理逻辑，没写出来，看过官方题解后发现是统计升序序列、降序序列的逻辑。逻辑不是很难理解，但写出来要考虑很多细节相当困难。而贪心策略很难想到，但理解了这种逻辑，代码就很好写了，故在此只考虑贪心算法。

class Solution {
public:
    int candy(vector<int>& ratings) {
        if (ratings.size() == 1)
            return 1;
        vector<int> candy; //糖果数组，初值全设为1
        for (int i = 0; i < ratings.size(); i++) {
            candy.push_back(1);
        }
        //从前往后遍历，确定右边评分高的孩子比左边孩子多一颗糖
        for (int i = 1; i < ratings.size(); i++) {
            if (ratings[i] > ratings[i - 1]) {
                candy[i] = candy[i - 1] + 1;
            }
        }
        //从后往前遍历，确保左边评分高的孩子比右边孩子至少多一颗糖
        for (int i = ratings.size() - 2; i >= 0; i--) {
            if (ratings[i] > ratings[i + 1]) {
                candy[i] = max(candy[i], candy[i + 1] + 1);
            }
        }
        int result = 0;
        for (int a : candy)
            result += a; //收集结果
        return result;
    }
};

今日总结：资本家算法。