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

代码随想录

计算每个数之间的差值，差值是正的就加到sum里，是负数就先把sum里的数加给result，然后把sum清空。最后循环结束时如果sum是正的，要把sum加到result里面

class Solution {
    public int maxProfit(int[] prices) {
        if(prices.length == 1)return 0;
        int result = 0;
        int sum = 0;
        int pre,cur;;
        int diff;
        for(int i = 0;i < prices.length - 1;i++){
            pre = prices[i];
            cur = prices[i + 1];
            diff = cur - pre;
            if(diff < 0){
                result += sum;
                sum = 0;
            }else{
                sum += diff;
            }
        }
        if(sum > 0)result += sum;
        return result;
    }
}

// 贪心思路
class Solution {
    public int maxProfit(int[] prices) {
        int result = 0;
        for (int i = 1; i < prices.length; i++) {
            result += Math.max(prices[i] - prices[i - 1], 0);
        }
        return result;
    }
}

55. 跳跃游戏

55. 跳跃游戏 - 力扣（LeetCode）

代码随想录

从后往前遍历 自己写的

从后往前遍历，首先看有没有数能到达最后一个数，然后再看前面的数能不能到达当前元素，一直往前走，最后看x的值判断，x的值是能够到达当前数的最小值

class Solution {
    public boolean canJump(int[] nums) {
        if(nums.length == 1)return true;
        int x = 1;
        for(int i = nums.length - 2;i >= 0;i--){
            if(nums[i] >= x){
                x = 1;
            }
            else x++;
        }
        if(x != 1)return false;
        else return true;
    }
}

从前往后，随想录的

从前往后，不断更新覆盖范围

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

45. 跳跃游戏 II - 力扣（LeetCode）

代码随想录

自己写的

class Solution {
    public int jump(int[] nums) {
        if(nums.length == 1)return 0;
        int foot = 1;
        int cover = nums[0];
        int maxCover = cover;
        for(int i = 0;i <= cover;i++){
            if(cover >= nums.length - 1){
                break;
            }
            if(nums[i] + i > maxCover){//写成cover会导致有多个大于cover的数时出错
                if(nums[i] + i >= nums.length - 1)return foot + 1;
                maxCover = nums[i] + i;
            }
            if(i == cover){
                cover = maxCover;
                foot++;
            }
        }
        return foot;
    }
}

随想录的

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 (maxDistance>=nums.length-1){
                count++;
                break;
            }
            //走到当前覆盖的最大区域时，更新下一步可达的最大区域
            if (i==curDistance){
                curDistance = maxDistance;
                count++;
            }
        }
        return count;
    }
}

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

本题简单一些，估计大家不用想着贪心 ，用自己直觉也会有思路。

代码随想录

int数组不能用lamda表达式

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

随想录

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

    }
}