【代码随想录Day32】贪心算法/DP

最新推荐文章于 2024-08-10 22:52:22 发布

lisatse0115

最新推荐文章于 2024-08-10 22:52:22 发布

阅读量44

点赞数

分类专栏：代码随想录文章标签： leetcode 算法 Powered by 金山文档

本文链接：https://blog.csdn.net/lisatse0115/article/details/129053515

版权

代码随想录专栏收录该内容

53 篇文章 0 订阅

订阅专栏

文章介绍了在LeetCode上关于股票买卖最佳时机II和跳跃游戏系列的解题方法，包括贪心算法和动态规划的实现。对于股票问题，两种策略分别从不同角度计算最大利润。跳跃游戏中，贪心算法和动态规划解决是否能到达终点的问题，以及最小步数的求解。

摘要由CSDN通过智能技术生成

122 买卖股票的最佳时机II

https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/

class Solution {  //贪心，收集正数的每天利润
    public int maxProfit(int[] prices) {
        int sum = 0;
        for (int i = 1; i < prices.length; i++) {
            if (prices[i] > prices[i - 1]) sum += prices[i] - prices[i - 1];
        }
        return sum;
    }
}
class Solution { //dp
    public int maxProfit(int[] prices) {
        int hold = -prices[0];
        int unhold = 0;
        for (int i = 1; i < prices.length; i++) {
            int temp = hold;
            hold = Math.max(unhold - prices[i], hold);
            unhold = Math.max(temp + prices[i], unhold);
        }
        return unhold;
    }
}

55 跳跃游戏

https://leetcode.cn/problems/jump-game/ 贪心很不好想，TO(n) SO(1)比dp快，维护一个 maxCover，在maxCover范围内依次遍历时，更新maxCover，直到maxCover能到 end，否则就是跳不到返回false;

class Solution {  //贪心
    public boolean canJump(int[] nums) {
        int maxCover = 0;
        for (int i = 0; i <= maxCover; i++) {
            if (i == nums.length - 1) return true;
            maxCover = Math.max(maxCover, i + nums[i]);
        }
        return false;
    }
}
class Solution { //从前向后dp
    public boolean canJump(int[] nums) {
        boolean[] dp = new boolean[nums.length];  //可不可以从0跳到i
        dp[0] = true;
        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j < i; j++) {
                if (dp[j] && nums[j] + j >= i) {
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[nums.length - 1];
    }
}
class Solution {  //从后向前dp
    public boolean canJump(int[] nums) {
        boolean[] dp = new boolean[nums.length];  //i可不可以跳到end
        dp[nums.length - 1] = true;
        for (int i = nums.length - 2; i >= 0; i--) {
            for (int j = i + 1; j <= i + nums[i]; j++) {
                if (j >= nums.length - 1 || dp[j] == true) {
                    dp[i] = true;
                    break;
                } 
            }
        }
        return dp[0];
    }
}

45 跳跃游戏II

https://leetcode.cn/problems/jump-game-ii/

由于要求最小步数，每走到maxCover时需要增加步数，增加一步后新的maxCover需要靠之前遍历过程中记录跟新NextCover得到。

class Solution {  //贪心, 需要把能到的地方按步数分层次，遍历时更新nextCov，当i到达maxCover时，加步数并把nextCov给maxCov
    public int jump(int[] nums) { 
        int maxCover = 0;          
        int maxNext = 0;           
        int minStep = 0;           
        for (int i = 0; i <= maxCover; i++) {
            if (i == nums.length - 1) break;
            maxNext = Math.max(maxNext, i + nums[i]);
            if (i == maxCover) {
                minStep++;
                maxCover = maxNext;
            } 
        }
        return minStep;
    }
}


class Solution {  //dp
    public int jump(int[] nums) {
        int[] dp = new int[nums.length];
        dp[nums.length - 1] = 0;
        for (int i = nums.length - 2; i >= 0; i--) {
            dp[i] = Integer.MAX_VALUE;                    
            if (i + nums[i] >= nums.length - 1) {             // bug nums[i] not dp[i]
                dp[i] = 1;
            } else {
                for (int j = 1; j <= nums[i]; j++) {                    //bug j <= nums[i] not j <= dp[i]
                    if (dp[i + j] != Integer.MAX_VALUE && dp[i] > dp[i + j] + 1) {
                        //dp[i] = Math.min(dp[i], dp[i + j] + 1);
                        dp[i] = dp[i + j] + 1;
                    }
                }
            }
        }
        return dp[0] == Integer.MAX_VALUE ? -1 : dp[0];
    }
}