代码随想录DAY28|122.买卖股票的最佳时机II、55. 跳跃游戏、45.跳跃游戏II、1005.K次取反后最大化的数组和

1. 买卖股票的最佳时机II

力扣

题目中给出最多持有一股，而且可以当天买入卖出。拆解一下最终利润，假如第 0 天买入，第 3 天卖出，那么利润为：prices[3] - prices[0]。相当于(prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])。也即只要相邻两天有利润就买入卖出，这样最终利润最大。代码要从第二天开始写，因为第二天才能开始有利润。

class Solution {
    public int maxProfit(int[] prices) {
        int profit = 0;
        for(int i = 1; i < prices.length; i++){
            if(prices[i] > prices[i-1]){
                profit += prices[i]- prices[i-1];
            }
        }
        return profit;
    }
}

2. 跳跃游戏

力扣
本题有两种写法，循环控制条件本质上一样。写法一中未单独写数组长为一的情况，但是判断条件中已经排除掉了。

遍历当前最大范围内的所有元素，每遍历一个元素就记录一下最大值，如果最后最大值超过数组长度则可以到达终点。

//写法一
class Solution {
    public boolean canJump(int[] nums) {
        int max = nums[0];
        for(int i = 1; i < nums.length; i++){
            if(i <= max && (i + nums[i]) >= max ){
                max = i + nums[i];
            }
        }
        if(max >= nums.length - 1){
            return true;
        }
        return false;
    }
}

//写法2
class Solution {
    public boolean canJump(int[] nums) {
        if (nums.length == 1) {
            return true;
        }
        //覆盖范围, 初始覆盖范围应该是0，因为下面的迭代是从下标0开始的
        int coverRange = 0;
        //在覆盖范围内更新最大的覆盖范围
        for (int i = 0; i <= coverRange; i++) {
            coverRange = Math.max(coverRange, i + nums[i]);
            if (coverRange >= nums.length - 1) {
                return true;
            }
        }
        return false;
    }
}

3. 跳跃游戏II

力扣
本题是求解到数组尾部的最小跳跃次数，而且题目说明一定可以达到终点。

思路是遍历当前最大范围，并更新下一步的最大范围。如果当前最大范围内走到底还没到终点，就加一步，同时遍历下一层最大范围。

class Solution {
    public int jump(int[] nums) {
        if (nums == null || nums.length == 0 || nums.length == 1) {
            return 0;
        }
        //记录跳跃的次数
        int count=0;
        //当前的覆盖最大区域
        int curDistance = 0;
        //最大的覆盖区域
        int maxDistance = 0;
        for (int i = 0; i < nums.length; i++) {
            //在可覆盖区域内更新最大的覆盖区域
            maxDistance = Math.max(maxDistance,i+nums[i]);
            //走到当前覆盖的最大区域时，更新下一步可达的最大区域
            if (i==curDistance){
                curDistance = maxDistance;
                count++;
                if(curDistance >= nums.length - 1){
                	break;
                }
            }
        }
        return count;
    }
}

以上写法可以简化，重点在于控制遍历的范围到nums.length - 2。对于方法一，达到当前层末尾的时候要更新最大值加一步，同时判断新的最大值是否超过终点，如果是就break返回步数。统一处理的做法是，只更新最大值并加一步，但for循环遍历的结尾是 i < nums.length - 1。当指针遍历到此处时有两种情况：1. 移动下标等于当前覆盖最大距离下标， 需要再走一步（即 ans++），因为最后一步一定是可以到的终点。（题目假设总是可以到达数组的最后一个位置），如图：

2.移动下标小于当前覆盖最大距离下标，说明当前覆盖最远距离就可以直接达到终点了，不需要再走一步，即不会进入最后的判断加步数语句。如图：

代码如下

class Solution {
    public int jump(int[] nums) {
        // int position = nums.length - 1;
        // int step = 0;
        // while(position > 0){
        //     for(int i = 0; i < position;i++){
        //         if(i + nums[i] >= position){
        //             position = i;
        //             step++;
        //             break;
        //         }
        //     }
        // }
        // return step;

        //方法二 从前向后遍历
        int step = 0;
        int max = 0;
        int end = 0;
        for(int i = 0; i < nums.length - 1 ;i++){
            if(i <= max && i + nums[i] > max){
                max = i + nums[i];
            }
            if(i == end){
                end = max;
                step++;
            }
        }
        return step;
    }
}

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

力扣

两种方法，一个是按绝对值排序数组，一个是按大小排序。两种的基本思路是一样的：先把大的负数取正，如果k还有剩余就把最小的那个非负数取反。

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

第二种写法注意处理完负数要重新排序一遍数组

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] < 0 && k > 0) {
                nums[i] = -nums[i];
                k--;
            } else {
                break;
            }
        }
        if (k % 2 == 1) {
            Arrays.sort(nums);
            nums[0] = -nums[0];
        }
        int res = 0;
        for (int num : nums) {
            res += num;
        }
        return res;
    }
}