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

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

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

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

为了尽可能的减少排序次数，代码如下：
排序涉及到java的流式操作，需要转换成数值流 -> 包装类 -> 排序 -> 基本类型数值流 -> 数组。

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        // Arrays.sort(nums, (o1, o2) -> Math.abs(o2) - Math.abs(o1)); // 需转化为包装类
        // 使用流式操作将int数组转换为Integer数组
        // 因为我们能够通过流中的sort方法来对元素进行自定义排序，所以要转换成流
        nums = IntStream.of(nums)   // 转换成数值流  将数组 nums 转换为一个 IntStream 对象。
                    .boxed()        // 装箱  
                    // boxed()的作用就是将基本（原始）类型的stream转成了包装（boxed）类型的Stream
                    .sorted((o1, o2) -> Math.abs(o2) - Math.abs(o1))
                    .mapToInt(Integer::intValue) //将 Stream<Integer> 对象中的元素转换为 IntStream 对象
                    .toArray();  // 将 IntStream 对象中的元素转换为一个 int 数组
                    
                    // .toArray(Integer[]::new);   // 将流转换为数组
        // Arrays.sort(numsInteger, (o1, o2) -> Math.abs(o2) - Math.abs(o1));
        // nums = Arrays.stream(numsInteger).mapToInt(Integer::intValue).toArray();
        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 == 1) nums[nums.length - 1] *= -1;
        return Arrays.stream(nums).sum();
    }
}

加油站

rest[i] = gas[i] - cost[i]

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

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

class Solution {
    // 从gas[i] >= cost[i]的位置出发
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int curSum = 0;
        int totalSum = 0;
        int start = 0;
        for (int i = 0; i < gas.length; i++) {
            curSum += gas[i] - cost[i];
            totalSum += gas[i] - cost[i];
            if (curSum < 0) {
                start = i + 1;
                curSum = 0;     // curSum从0开始
            }
        }
        if (totalSum < 0) return -1;
        return start;
    }
}

分发糖果

老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。

你需要按照以下要求，帮助老师给这些孩子分发糖果：

• 每个孩子至少分配到 1 个糖果。
• 相邻的孩子中，评分高的孩子必须获得更多的糖果。

那么这样下来，老师至少需要准备多少颗糖果呢？

---

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

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

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

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

取candyVec[i + 1] + 1 和 candyVec[i] 最大的糖果数量，candyVec[i]只有取最大的才能既保持对左边candyVec[i - 1]的糖果多，也比右边candyVec[i + 1]的糖果多。

class Solution {
    public int candy(int[] ratings) {
        /**
         分两个阶段
         1、起点下标1 从左往右，只要 右边 比 左边 大，右边的糖果=左边 + 1
         2、起点下标 ratings.length - 2 从右往左， 只要左边 比 右边 大，此时 左边的糖果应该 取本身的糖果数（符合比它左边大） 和 右边糖果数 + 1 二者的最大值，这样才符合 它比它左边的大，也比它右边大
    */
        int result = 0;
        int[] candies = new int[ratings.length];
        candies[0] = 1;
        for (int i = 1; i < ratings.length; i++) {
            if (ratings[i] > ratings[i - 1]) {
                candies[i] = candies[i - 1] + 1;
            } else {
                candies[i] = 1;
            }
        }

        for (int i = ratings.length - 1; i > 0; i--) {
            if (ratings[i] < ratings[i - 1]) {
                candies[i - 1] = Math.max(candies[i] + 1, candies[i - 1]);
            }
        }

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

        return result;
    }
}