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

打卡第34天，贪心算法，还是没领悟到精髓。

今日任务

• 1005.K次取反后最大化的数组和
• 134.加油站
• 135.分发糖果

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

给你一个整数数组 nums 和一个整数 k，按以下方法修改该数组：

• 选择某个下标 i 并将nums[i] 替换为 -nums[i] 。

重复这个过程恰好 k 次。可以多次选择同一个下标 i 。
以这种方式修改数组后，返回数组 可能的最大和 。

我的题解

贪心想法，如果 数组有负数，优先变为正数，当数组已经没有负数了，k 为偶数，则多次选择同一下标替换，结果不变，k为奇数，优先选择最小的数替换。

class Solution {
public:
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end());
        int sum = 0;
        int minNum = INT_MAX;
        // 1.负数个数小于k，全部负数替换为正数，k依然未使用完，当 剩余k 为奇数，总和 减去2倍修改后数组的最小的正数就是结果
        // 2.负数个数大于等于k，直接将较小的负数替换为正数，总和就是答案
        for(int i = 0; i < nums.size(); i++) {
            if(k > 0 && nums[i] < 0) {
                nums[i] = 0 - nums[i];
                k--;
            }
            if(minNum > nums[i]) minNum = nums[i];
            sum += nums[i];
        }
        if(k > 0 && k % 2 != 0) sum = sum -  2 * minNum;
        return sum;
    }
};

代码随想录

贪心的思路，局部最优：让绝对值大的负数变为正数，当前数值达到最大，整体最优：整个数组和达到最大。

那么本题的解题步骤为：

• 第一步：将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小
• 第二步：从前向后遍历，遇到负数将其变为正数，同时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.加油站

在一条环路上有 n 个加油站，其中第 i 个加油站有汽油 gas[i] 升。

你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第i+1个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。

给定两个整数数组 gas 和 cost ，如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。

代码随想录

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.分发糖果

n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。
你需要按照以下要求，给这些孩子分发糖果：

• 每个孩子至少分配到 1 个糖果。
• 相邻两个孩子评分更高的孩子会获得更多的糖果。

请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。

代码随想录

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

此时局部最优：只要右边评分比左边大，右边的孩子就多一个糖果，全局最优：相邻的孩子中，评分高的右孩子获得比左边孩子更多的糖果。

再确定左孩子大于右孩子的情况（从后向前遍历）

遍历顺序这里有同学可能会有疑问，为什么不能从前向后遍历呢？

因为 rating[5]与rating[4]的比较 要利用上 rating[5]与rating[6]的比较结果，所以 要从后向前遍历。

如果从前向后遍历，rating[5]与rating[4]的比较 就不能用上 rating[5]与rating[6]的比较结果了 。

所以确定左孩子大于右孩子的情况一定要从后向前遍历！

class Solution {
public:
    int candy(vector<int>& ratings) {
        vector<int> candyNums(ratings.size(), 1);
        for(int i = 1; i < ratings.size(); i++) {
            if(ratings[i] > ratings[i - 1]) {
                candyNums[i] = candyNums[i - 1] + 1;
            }
        }

        for(int i = ratings.size() - 2; i >= 0; i--) {
            if(ratings[i] > ratings[i + 1]) {
                candyNums[i] = max(candyNums[i], candyNums[i + 1] + 1);
            }
        }
        int res = 0;
        for(int i = 0; i < candyNums.size(); i++) res += candyNums[i];
        return res;
    }
};