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

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

本题简单一些，估计大家不用想着贪心 ，用自己直觉也会有思路。

题目链接/讲解： 代码随想录

重点：

总共涉及到了两次贪心，第一次贪心是因为要把负数取反成正数，保证和最大，第二次贪心是负数取反完了，k依旧还有次数保留

第一次贪心（负数取反变正数）：

1. 局部最优：让绝对值大的负数变为正数，当前数值达到最大

2. 全局最优：整个数组和达到最大

第二次贪心（k次数还没用完，把最小的正数反复取反）：

1. 局部最优：只找数值最小的正整数进行反转，当前数值和可以达到最大

2. 全局最优：整个数组和达到最大

思路：

1. 将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小

IntStream.of和Arrays.stream都是返回了IntStream，然后再boxed就可以变成stream流来操作

nums = IntStream.of(nums)
        .boxed()
        .sorted((o1, o2) -> Math.abs(o2) - Math.abs(o1))
        .mapToInt(Integer::intValue).toArray();

2. 从前向后遍历，遇到负数将其变为正数，同时k--

for (int i = 0; i < nums.length; i++) {
    if (nums[i] < 0 && k > 0) {
        nums[i] = -nums[i];
        k--;
    }
}

3. 如果k还大于0，那么反复转变数值最小的元素，将k用完

if (k % 2 != 0) {
    nums[nums.length - 1] = -nums[nums.length - 1];
}

4. 求和

IntStream.of(nums).sum()

public int largestSumAfterKNegations(int[] nums, int k) {
    // 将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小
    nums = IntStream.of(nums)
            .boxed()
            .sorted((o1, o2) -> Math.abs(o2) - Math.abs(o1))
            .mapToInt(Integer::intValue).toArray();
    // 从前向后遍历，遇到负数将其变为正数，同时k--
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] < 0 && k > 0) {
            nums[i] = -nums[i];
            k--;
        }
    }
    // 如果k还大于0，那么反复转变数值最小的元素，将k用完
    if (k % 2 != 0) {
        nums[nums.length - 1] = -nums[nums.length - 1];
    }
    // 求和
    return IntStream.of(nums).sum();
}

134. 加油站

本题有点难度，不太好想，推荐大家熟悉一下方法二 

题目链接/讲解：代码随想录

重点：

两种解法，一种暴力解法，一种贪心算法

贪心算法：

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

全局最优：找到可以跑一圈的起始位置。

思路：

暴力解法：

以每个加油站为起点不断尝试，只要净油量大于0就说明依旧可以跑到下一个油站，直到跑到起点位置，只要中间净油量小于0了，说明无法接着跑了

贪心算法：

1. 先判断是否存在答案，不存在返回-1

int totalSum = 0;
for (int i = 0; i < gas.length; i++) {
    totalSum += gas[i] - cost[i];
}
if (totalSum < 0) return -1;

2. 计算curSum，如果当前i的curSum小于0，说明[0, i]这个区间都不可能作为起点，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。

int curSum = 0;
int result = 0;
for (int i = 0; i < gas.length; i++) {
    // 计算当前净油量
    curSum += gas[i] - cost[i];
    // 如果当前净油量小于零，说明[0, i]区间都不能作为起始位置
    // 因为这个区间选择任何一个位置作为起点，到i这里都会断油
    // 那么起始位置从i+1算起，再从0计算curSum
    if (curSum < 0) {
        // 尝试i+1
        result = (i + 1) % gas.length;
        // curSum重新从0开始计算
        curSum = 0;
    }
}
return result;

// 暴力解法
public int canCompleteCircuit(int[] gas, int[] cost) {
    for (int i = 0; i < cost.length; i++) {
        // 以i为起点，跑到下一个加油站的净油量
        int rest = gas[i] - cost[i];
        // 下一个油站的index
        int nextStation = (i + 1) % cost.length;
        // 以i为起点，不断的计算每个油站的净油量
        // 如果rest小于0，直接去尝试以i+1为起点
        while (rest > 0 && nextStation != i) {
            rest += gas[nextStation] - cost[nextStation];
            nextStation = (nextStation + 1) % cost.length;
        }
        // 说明当前起点可以
        if (rest >= 0 && nextStation == i) {
            return i;
        }
    }
    // 没有找到合适的起点
    return -1;
}

// 贪心算法
public int canCompleteCircuit(int[] gas, int[] cost) {
    // 先判断是否存在答案
    // 总油量减去总消耗大于等于零那么一定可以跑完一圈
    int totalSum = 0;
    for (int i = 0; i < gas.length; i++) {
        totalSum += gas[i] - cost[i];
    }
    // 不存在答案
    if (totalSum < 0) return -1;
    // 肯定存在答案
    int curSum = 0;
    int result = 0;
    for (int i = 0; i < gas.length; i++) {
        // 计算当前净油量
        curSum += gas[i] - cost[i];
        // 如果当前净油量小于零，说明[0, i]区间都不能作为起始位置
        // 因为这个区间选择任何一个位置作为起点，到i这里都会断油
        // 那么起始位置从i+1算起，再从0计算curSum
        if (curSum < 0) {
            // 尝试i+1
            result = (i + 1) % gas.length;
            // curSum重新从0开始计算
            curSum = 0;
        }
    }
    return result;
}

135. 分发糖果

本题涉及到一个思想，就是想处理好一边再处理另一边，不要两边想着一起兼顾，后面还会有题目用到这个思路

题目链接/讲解：代码随想录

重点：

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

2. 贪心算法

局部最优：

• 一次是从左到右遍历，只比较右边孩子评分比左边大的情况。
• 一次是从右到左遍历，只比较左边孩子评分比右边大的情况。

全局最优：相邻的孩子中，评分高的孩子获得更多的糖果。

思路：

1. 先确定右边评分大于左边的情况（也就是从前向后遍历）

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

// 右孩比左孩评分高, i为右孩
for (int i = 1; i < ratings.length; i++) {
    if (ratings[i] > ratings[i - 1]) {
        candy[i] = candy[i - 1] + 1;
    }
}

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

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

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

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

// 左孩比右孩评分高, i为左孩
for (int i = ratings.length - 2; i >= 0; i--) {
    if (ratings[i] > ratings[i + 1]) {
        // candy[i]为计算好的右孩比左孩评分高的结果
        candy[i] = Math.max(candy[i], candy[i + 1] + 1);
    }
}

public int candy(int[] ratings) {
    int result = 0;
    int[] candy = new int[ratings.length];
    candy[0] = 1;
    // 右孩比左孩评分高, i为右孩
    for (int i = 1; i < ratings.length; i++) {
        if (ratings[i] > ratings[i - 1]) {
            candy[i] = candy[i - 1] + 1;
        } else {
            candy[i] = 1;
        }
    }
    // 左孩比右孩评分高, i为左孩
    for (int i = ratings.length - 2; i >= 0; i--) {
        if (ratings[i] > ratings[i + 1]) {
            // candy[i]为计算好的右孩比左孩评分高的结果
            candy[i] = Math.max(candy[i], candy[i + 1] + 1);
        }
    }
    for (int num : candy) {
        result += num;
    }
    return result;
}