Day 34 | 1005. Maximize Sum Of Array After K Negations | 134. Gas Station

本文链接：https://blog.csdn.net/kyle313606922/article/details/128702162

LeetCode 1005. Maximize Sum Of Array After K Negations

Question Link

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        // 1、Order the array by the absolute value from big to small.
        nums = IntStream.of(nums)
                .boxed()    // Covert the original stream to the boxed Stream
                .sorted((o1, o2) -> Math.abs(o2) - Math.abs(o1))
                .mapToInt(Integer::intValue).toArray();

        int len = nums.length;
        // 2、Traverse from front to back. Do negation and k-- when meeting negative numbers
        for(int i = 0; i < len; i++){
            if(nums[i] < 0 && k > 0){
                nums[i] = -nums[i];
                k--;
            }
        }
        // 3、If k > 0, repeatedly negate the smallest element
        if(k % 2 == 1)
            nums[len - 1] = - nums[len - 1];

        // 4、Sum up
        return Arrays.stream(nums).sum();
    }
}

Order the array by the absolute value from big to small.
Traverse from front to back. Do negation and k-- when meeting negative numbers
If k > 0, repeatedly negate the smallest element
Sum up

LeetCode 134. Gas Station

Question Link

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;
    }
}

If the total gas minus the total consumption, then the car must be able to complete a lap. It demonstrates that the sum of rest gas(gas[i] - cost[i]) in every station must be bigger or equal to 0

LeetCode 135. Candy

Question Link

class Solution {
    public int candy(int[] ratings) {
        int len = ratings.length;
        int[] candyVec = new int[len];
        candyVec[0] = 1;

        // From left to right
        for(int i = 1; i < len; i++)
            candyVec[i] = (ratings[i] > ratings[i-1]) ? candyVec[i-1] + 1 : 1;
        
        // From right to left
        for(int i = len - 2; i >= 0; i--){
            if(ratings[i] > ratings[i+1])
                candyVec[i] = Math.max(candyVec[i], candyVec[i+1] + 1);
        }
        
        return Arrays.stream(candyVec).sum();
    }
}

We used two greedy strategies for this question:

Traverse from left to right, only handle the situations the right rating value is larger than the left rating value
Traverse from right to left, only handle the situations the left rating value is larger than the right rating value

In this way, we derive the global optimum from the local optimum