代码随想录算法训练营day34|k次取反后最大化的数组和、加油站、分发糖果

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

1005. K 次取反后最大化的数组和 - 力扣（LeetCode）

能否直接使用排序API？

如果使用了排序API之后呢，先判断当前元素是不是负数，如果是，就将其取反。直到当前元素不是负数，就一直对其取反。

第一版代码：

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        int index = 0;
        int count = 0;
        int sum = 0;
        Arrays.sort(nums);
        while(count<k){
            if(nums[index]<0){
                nums[index] = -nums[index];
                index++;
                count++;
            }
            else{
               if((k-count) % 2 ==1){
                   nums[index] = -nums[index];
                   count = k;
               }
               else if((k-count) % 2 ==0){
                   count = k;
               }
            }
        }
        for(int x : nums){
            sum += x;
        }
        return sum;
    }
}

错误点：

当我们的数组剩余变化次数为奇数时，而最后一个待变换的值为正数，它比前一个带变换的值变为正数后大，此时我们需要对前一个进行重复变换。

我们直接在k范围内将数组中的元素变为正数后，再去判断k是否大于0，如果是，还需要进一步判断。

 

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        int sum = 0;
        Arrays.sort(nums);
        //先将所有负数变为正数
        for(int i = 0;i<nums.length && k>0;i++){
            if(nums[i]<0){
                nums[i] = -nums[i];
                k--;
            }
        }
        //结束循环，如果此时k还大于0，需要对此时数组中的最小值进行变换
        if(k%2 == 1){
            Arrays.sort(nums);
            nums[0] = -nums[0];
        } 
        for(int x : nums){
            sum += x;
        }
        return sum;
    }
}

2023.4.17 加油站

134. 加油站 - 力扣（LeetCode）

我们可以发现，如果想要能够走完一圈，那么总的消耗量一定是小于等于加油量的，

而我们每个站点的剩余油量就为gas[i]-cost[i]

 

从下标0作为起点开始，累计每个站点的剩余油量，如果油量小于0，显然是不能作为起点，因此我们需要更新起点为i+1,直到遍历完整个数组，如果剩余油量小于0，显然不能构成一个循环。如果剩余油量大于0，那么我们的起点就是i

因为想要构成循环，如果前半部分剩余总和小于0了，那么后半部分的剩余油量一定是大于等于前半部分亏损的油量的。

        int start = 0;
        for(int i = 0;i<gas.length;i++){
            curSum += gas[i] - cost[i];
            allSum += gas[i]-cost[i];
            if(curSum<0){//当前剩余油量小于0，说明不能以当前位置为起点，更新起始点坐标
            curSum = 0;
            start = i+1;
            }
        }
        //结束循环后，如果总的剩余量还小于0，显然不能构成循环，返回-1
        if(allSum <0){
            return -1;
        }
        return start;
    }
}

2023.4.17 分发糖果

135. 分发糖果 - 力扣（LeetCode）

要想实现相邻两个孩子评分更高的孩子获得更多的糖果，我们不能同时考虑两边，因为如果同时考虑两边，会牵扯到很多互相干扰的情况，因此，我们的策略就是先从一边开始考虑。比如先考虑每个节点的左边节点或者右边节点情况，然后叠加起来。

注意，如果我们时考虑节点的右边大小情况，我们必须从后往前遍历，这样的结果才会从右影响到左边，否则会出现错误。

例：

 

如果从前往后遍历，比较左孩子比右子的大的情况，当最后两位左比右大事，会导致其结果没有传递到左边，导致我们的结果出现误差。因此从后往前遍历，比较左边比右边大，这样结果造成的影响才会传递。

同理，我们比较右边比左边大时，结果是向右传递的，就可以使用从前往后遍历了。

class Solution {
    public int candy(int[] ratings) {
        int length = ratings.length;
        int[] res = new int[length];
        int sum = 0;
        res[0] = 1;
        //先比较右边是否大于左边，从前向后遍历
        for(int i = 1;i<length;i++){
            if(ratings[i]>ratings[i-1]){
                res[i] = res[i-1] + 1;
            }
            else{
                res[i] = 1;            
            }
        }
        //再比较左边大于右边的情况，从后向前遍历
        for(int i = length-2;i>=0;i--){
            if(ratings[i] > ratings[i+1] && res[i] <= res[i+1]){
                res[i] = res[i+1] +1;
            }
        }
        //计算总和
        for(int x:res){
            sum += x;
        }
        return sum;
    }
}