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

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

1. 学习文章链接：
2. 思路：见注释1、2、3、4。
3. 代码：

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        // 1. 将数组元素按绝对值从大到小排序。
        nums = IntStream.of(nums)  //IntStream创建数字流，of则是输入一个数组
            .boxed()               //返回一个包含此流元素的流，每个元素都装在整数中
            .sorted((o1, o2) -> Math.abs(o2) - Math.abs(o1))    //排序
            .mapToInt(Integer::intValue)
            .toArray();
        // 2. 从前向后遍历，遇到负数将其变为正数，同时K--,注意这里不用管k是否小于零。
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] < 0) {
                nums[i] = -nums[i];
                k--;
            }
            
        }
        // 3.如果K还大于0，那么反复转变数值最小的元素，将K用完
        while (k > 0) {
            nums[nums.length - 1] = -nums[nums.length - 1];
            k--;
        }
        // 4.求和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum;
    }
}

134. 加油站

1. 学习文章链接：
2. 思路：见注释一、二、三。
3. 代码：

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int curSum = 0;
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < gas.length; i++) {
            int gap = gas[i] - cost[i];
            curSum += gap;
            min = curSum > min ? min : curSum;
        }
        // 情况一：汽油总和不能跑完全程
        if (curSum < 0) return -1;
        // 情况二：汽油能跑完全程，且全程不出现燃油亏负的情况，所以0为出发位置。
        if (min >= 0) return 0;
        // 所注释掉的循环不可用。
        // for (int i = 0; i <= gas.length - 1; i++) {
        //     int gap = gas[i] - cost[i];
        //     min += gap;
        //     if (min >= 0) {
        //         return i;
        //     }
        // }
        // 情况三：0非出发位置，向后遍历，寻找出发位置。
        // 为什么不能向前遍历呢？值得思考。
        for (int i = gas.length - 1; i > 0; i--) {
            int gap = gas[i] - cost[i];
            min += gap;
            if (min >= 0) {
                return i;
            }
        }
        return -1;
    }
}

135. 分发糖果

1. 学习文章链接：
2. 思路：两次赋值、赋值需要比较原始值和遍历的前一个位置值加1。
3. 代码：

class Solution {
    public int candy(int[] ratings) {
        int[] res = new int[ratings.length];
        Arrays.fill(res, 1);
        for (int i = 1; i < ratings.length; i++) {
            int gap = ratings[i] - ratings[i - 1];
            if (gap > 0) res[i] = Math.max(res[i], res[i - 1] + 1);
            
        }
        // 为什么不直接res[i]++?    --->    会造成糖果的浪费，因为题目要求是至少。
            // 例如[1, 3, 2, 2, 1], 7颗就满足了。使用res[i]++, 结果为8颗。

        // 为什么不直接res[i] = res[i - 1] + 1;会修改之前添加的值。
            // 例如res[i] = 3, res[i - 1] = 1, 如果按照res[i] = res[i - 1] + 1计算，res[i]修改为2。

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