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

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

力扣

思路：

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

2. 将数组按绝对值从大到小排序。从前往后遍历，当遇到负数时，将其变为正数，k--；

3. 反复转变数值最小的元素，直到k=0。

class Solution {
    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();
        for(int i=0;i<nums.length;i++){
            if(nums[i]<0 && k>0){
                nums[i]=-nums[i];
                k--;
            }
        }
        if(k%2==1) nums[nums.length-1]=-nums[nums.length-1];
        return Arrays.stream(nums).sum();
    }
}

134. 加油站

力扣

思路1：从全局进行贪心选择

1. 若gas总和小于cost总和，那么一定跑不完一圈，return -1；

2. rest[i] = gas[i]-cost[i]，i从0开始计算累加到最后一站，如果累加没有出现负数，返回0；

3. 累加的最小值为负数，那么汽车就要从非0节点出发，从后向前，看哪个节点能这个负数填平，这个节点就是出发节点。

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int sum = 0;
        int min = 0;
        for(int i=0;i<gas.length;i++){
            sum += gas[i]-cost[i];
            min = Math.min(sum,min);
        }
        if(sum<0) return -1;
        if(min>=0) return 0;
        for(int i=gas.length-1;i>0;i--){
            min += gas[i]-cost[i];
            if(min>=0) return i;
        }
        return -1;
    }
}

思路2：贪心算法

1. 若gas总和大于等于cost总和，那么一定可以跑完一圈；

2. i 从 0 开始累加 rest[i]【gas[i]-cost[i]】，记为curSum，一旦curSum<0，则说明[0,i]区间不能作为起始位置，起始位置从i+1算起，重新计算curSum；

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

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int cur = 0;
        int total = 0;
        int idx = 0;
        for(int i=0;i<gas.length;i++){
            total += gas[i]-cost[i];
            cur += gas[i]-cost[i];
            if(cur<0){
                idx = (i+1)%gas.length;
                cur = 0;
            }
        }
        if(total<0) return -1;
        return idx;
    }
}

135. 分发糖果

力扣

思路：

1. 需要确定一边之后，再确定另一边；

2. 从前向后遍历，确定右边评分大于左边的情况。局部最优：只要右边评分比左边大，右边的孩子就多一个糖果；全局最优：相邻的孩子中，评分高的右孩子获得比左边孩子更多的糖果； 

3. 从后向前遍历，确定左边评分大于右边的情况。局部最优：当左边 (i) 评分大于右边 (i+1) 时，第i个小孩的糖果数量为 candyVec[i+1]+1 和 candyVec[i] 中的最大值；全局最优：相邻的孩子中，评分高的孩子获得更多的糖果。

class Solution {
    public int candy(int[] ratings) {
        int len = ratings.length;
        int[] candyVec = new int[len];
        candyVec[0] = 1;
        for(int i=1;i<len;i++){
            candyVec[i] = ratings[i]>ratings[i-1]? candyVec[i-1]+1:1;
        }
        for(int i=len-2;i>=0;i--){
            if(ratings[i]>ratings[i+1]){
                candyVec[i] = Math.max(candyVec[i],candyVec[i+1]+1);
            }
        }
        int sum = 0;
        for(int num:candyVec){
            sum += num;
        }
        return sum;
    }
}