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

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

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

题目链接：1005.K次取反后最大化的数组和

贪心算法

思路：本题需要使用两次贪心的策略。

1. 当数组中存在负数时，将各负数取反；
2. 当数组中均为正数时，选择最小正数多次取反，直到 k 消耗完毕。

本题靠感觉也可以做，但尽量锻炼贪心的思考方式。

class Solution {
    public int largestSumAfterKNegations(int[] nums, int K) {
    	// 将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小
    	
    	// ①IntStream.of(nums)将int数组转换成一个IntStream类型的流。
    	
		// ②通过boxed()方法将IntStream流中的每个元素都转换成一个对应的Integer对象，
		// 从而将流转换成一个Stream类型的流。
		
		// ③通过sorted((o1,o2)->Math.abs(o2)-Math.abs(o1))方法对Stream类型的流进行排序。
		// 排序使用的比较器是一个Lambda表达式(o1,o2)->Math.abs(o2)-Math.abs(o1)，
		// 该表达式根据o1和o2的绝对值之差来进行比较。
		// 因为要按照绝对值从大到小排序，所以o2的绝对值大于o1的绝对值时，返回负值，否则返回正值。
		// 通过mapToInt(Integer::intValue)将Stream类型的流转换成一个intStream类型的流。
		// 通过toArray()方法将IntStream类型的流转换成一个int类型的数组。
		
		nums = IntStream.of(nums)
			.boxed()
		    .sorted((o1, o2) -> Math.abs(o2) - Math.abs(o1))
		    .mapToInt(Integer::intValue).toArray();

		int len = nums.length;	    
		for (int i = 0; i < len; i++) {
	    	//从前向后遍历，遇到负数将其变为正数，同时K--
	    	if (nums[i] < 0 && K > 0) {
	    		nums[i] = -nums[i];
	    		K--;
			}
		}

		// 如果K还大于0，那么反复转变数值最小的元素，将K用完
		if (K % 2 == 1) nums[len - 1] = -nums[len - 1];
		return Arrays.stream(nums).sum();
    }
}

134. 加油站

题目链接：134. 加油站

贪心算法

思路：本题若使用暴力解法，即遍历每一个加油站为起点的情况，时间复杂度为O(n²)。注：for循环适合模拟从头到尾的遍历，而while循环适合模拟环形遍历，要善于使用while。
若使用贪心算法，如果总油量减去总消耗 >= 0，那么一定可以跑完一圈，说明各个站点的加油站剩油量 rest[i] 相加一定是 >= 0。每个加油站的剩余量 rest[i] 为 gas[i] - cost[i]。i 从 0 开始累加 rest[i]，和记为 curSum，一旦 curSum 小于零，说明 [0, i] 区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从 i+1 算起，再从 0 计算 curSum，如下图所示：
常见疑惑：有没有可能 [0，i] 区间选某一个作为起点，累加到 i 这里 curSum 是不会小于零呢？如图所示：
如果 curSum < 0 说明区间和1 + 区间和2 小于 0， 那么假设从上图中的位置开始计数 curSum不会小于0的话，就是 区间和2>0。区间和1 + 区间和2 < 0 同时区间和2 > 0，只能说明区间和1 < 0， 那么就会从假设的箭头初就开始重新选择起始位置了。因此对于本题：

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

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int curSum = 0; // 遍历至当前站点的油量（油箱剩余）
        int totalSum = 0; // 补充与消耗的总量
        int index = 0; // 记录起始位置
        for (int i = 0; i < gas.length; i++) {
            curSum += gas[i] - cost[i];
            totalSum += gas[i] - cost[i];
            if (curSum < 0) {
                index = (i + 1) % gas.length ; // 更新起始位置
                curSum = 0;
            }
        }
        if (totalSum < 0) return -1;
        return index;
    }
}

135. 分发糖果

题目链接：135. 分发糖果

贪心算法

思路：本题难点在于不能一起考虑，而应该先处理一部分，再处理另一部分，即两次贪心策略。

1. 先确定右边评分大于左边的情况（也就是从前向后遍历）。此时局部最优：只要右边评分比左边大，右边的孩子就多一个糖果；全局最优：相邻的孩子中，评分高的右孩子获得比左边孩子更多的糖果。
2. 再确定左边评分大于右边的情况（从后向前遍历）。反向遍历是因为 rating[5] 与 rating[4] 的比较要利用上 rating[5] 与 rating[6] 的比较结果，所以要从后向前遍历。

class Solution {
    public int candy(int[] ratings) {
        if(ratings.length == 1) return 1;
        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;
            // }
            candies[i] = ratings[i] > ratings[i - 1] ? candies[i - 1] + 1 : 1;
        }
        for(int i = ratings.length - 2; i >= 0; i--) {
            if(ratings[i] > ratings[i + 1]) {
                candies[i] = Math.max(candies[i + 1] + 1, candies[i]);
            }
        }
        int sum = 0;
        for(int i = 0; i < candies.length; i++) {
            sum += candies[i];
        }
        return sum;
    }
}