代码随想录训练营第二十八天 | 122.买卖股票的最佳时机II 55. 跳跃游戏 45.跳跃游戏II 1005.K次取反后最大化的数组和

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

想来，动规要比贪心简单。贪心有点抽象了。

贪心：如果能赚钱，就要买卖股票。

class Solution {
    public int maxProfit(int[] prices) {
        int[] dp = new int[prices.length];
        dp[0] = 0;
        for(int i=1; i<prices.length; i++){
            int temp = prices[i]-prices[i-1];
            dp[i] = temp > 0 ? dp[i-1]+temp: dp[i-1];
        }
        return dp[prices.length-1];
    }
}

55. 跳跃游戏

class Solution {
    public boolean canJump(int[] nums) {
        int cur = 0; 
        int maxIndex = cur + nums[cur]; // 期望的最大位置
        int right = maxIndex; // 区间的最右边
        for(cur = 1; cur<nums.length && right<nums.length; ){
            // 更新cur与对应的maxIndex：从cur遍历到right
            for(; cur<=right; cur++){
                maxIndex = Math.max(maxIndex, cur + nums[cur]);
            }
            if(right==maxIndex) break; // 区间遍历完，但是没更新期望边界
            right = maxIndex;
        }
        if(right>=nums.length-1) return true;
        return false;
    }
}

代码随想录版本：

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

45.跳跃游戏II

第一次尝试：时间复杂度太高

class Solution {
    public int jump(int[] nums) {
        int[][] dp = new int[nums.length][2]; // 0表示需要几跳； 1表示从哪个位置跳过来——传递
        for(int i=0; i<nums.length; i++){
            Arrays.fill(dp[i], Integer.MAX_VALUE);
        }
        
        dp[0][0] = 0;
        dp[0][1] = 0;
        int i;
        for(i=0; i<nums.length; i++){ // 更新下一步
            for(int k=i+1; k<=i+nums[i] && k<nums.length; k++){
                if(dp[k][0] > dp[i][0]+1){
                    dp[k][0] = dp[i][0] + 1;
                    dp[k][1] = i;
                }
            }
        }
        return dp[nums.length-1][0];
    }
}

代码随想录版本：

// 版本二
class Solution {
    public int jump(int[] nums) {
        int result = 0;
        // 当前覆盖的最远距离下标
        int end = 0;
        // 下一步覆盖的最远距离下标
        int temp = 0;
        for (int i = 0; i <= end && end < nums.length - 1; ++i) {
            temp = Math.max(temp, i + nums[i]);
            // 可达位置的改变次数就是跳跃次数
            if (i == end) {
                end = temp;
                result++;
            }
        }
        return result;
    }
}

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

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        // 第一次排序，找到所有负数
        Arrays.sort(nums);

        // 处理负数
        int i = 0;
        while (i < nums.length && nums[i] < 0 && k > 0) {
            nums[i] = -nums[i]; // 取反
            k--;
            i++;
        }

        // 如果 k 用完了，直接返回数组的和
        if (k == 0) {
            return Arrays.stream(nums).sum();
        }

        // 如果 k 还有剩余，需要处理剩下的正数
        // 再次排序，找到最小的正数
        Arrays.sort(nums);

        // 如果 k 是奇数，取反最小的正数
        if ((k & 1) != 0) {
            nums[0] = -nums[0];
        }

        // 返回数组的和
        return Arrays.stream(nums).sum();
    }
}

代码随想录版本：

1. IntStream.of() 基本类型的流，不会装箱。
2. 排序：按照绝对值从大到小排序

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();
	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();

    }
}

// 版本二：排序数组并贪心地尽可能将负数翻转为正数，再根据剩余的k值调整最小元素的符号，从而最大化数组的总和。
class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        if (nums.length == 1) return nums[0];

        // 排序：先把负数处理了
        Arrays.sort(nums); 

        for (int i = 0; i < nums.length && k > 0; i++) { // 贪心点, 通过负转正, 消耗尽可能多的k
            if (nums[i] < 0) {
                nums[i] = -nums[i];
                k--;
            }
        }

        // 退出循环, k > 0 || k < 0 (k消耗完了不用讨论)
        if (k % 2 == 1) { // k > 0 && k is odd：对于负数：负-正-负-正
            Arrays.sort(nums); // 再次排序得到剩余的负数，或者最小的正数
            nums[0] = -nums[0];
        }
        // k > 0 && k is even，flip数字不会产生影响: 对于负数: 负-正-负；对于正数：正-负-正 

        int sum = 0;
        for (int num : nums) { // 计算最大和
            sum += num;
        }
        return sum;
    }
}