代码随想录 Day41 动态规划09 LeetCode T121 买卖股票的最佳时机 T122 买卖股票的最佳时机II

前言

这两题看起来是不是有点眼熟,其实我们在贪心章节就已经写过了这两道题,当时我们用的是将利润分解,使得我们始终得到的是最大利润

假如第 0 天买入，第 3 天卖出，那么利润为：prices[3] - prices[0]。

相当于(prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])。

这样就是每天得到的最大利润 ,下面我也会给出贪心的思路

LeetCode T121 买卖股票的最佳时机

题目链接:121. 买卖股票的最佳时机 - 力扣（LeetCode）

题目思路:

我们还是用动规五部曲来解决问题

1.确定动规数组含义

这里我们定义两种状态,

1.dp[i][0] 表示持有股票的状态

2.dp[i][1]表示不持有股票的状态

所以此时的dp[i][0]和dp[i][1]都是持有股票时的最大钱数和不持有的最大钱数

注:这里的持有和不持有股票不是指当天买入股票,也可能是之前延续下来的一种状态

2.确定递推公式

这里持有股票可能是前面延续下来的一种状态也可能是当时购买股票的一个状态,我们取最大值即可

dp[i][0] = Math.max(dp[i-1][0],-prices[i])

同样下面也是一样我们讨论没有持有股票的最大值

dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]+prices[i])

3.初始化dp数组

由递推公式可知只要初始化第一个即可

dp[i][0] = -prices[0]

dp[i][1] = 0

4.确定遍历方式

顺序遍历,因为后一个结果的产生取决于前一个结果

5.打印dp数组排错

题目代码:

java 复制代码

//贪心
class Solution {
    public int maxProfit(int[] prices) {
        // 找到一个最小的购入点
        int low = Integer.MAX_VALUE;
        // res不断更新，直到数组循环完毕
        int res = 0;
        for(int i = 0; i < prices.length; i++){
            low = Math.min(prices[i], low);
            res = Math.max(prices[i] - low, res);
        }
        return res;
    }
}

//动规
class Solution {
    public int maxProfit(int[] prices) {
       if(prices.length<=1){
            return 0;
        }
        int[][] dp = new int[prices.length][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for(int i = 1;i<prices.length;i++){
            dp[i][0] = Math.max(dp[i-1][0],-prices[i]);
            dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]+prices[i]);
        }
        int result = Math.max(dp[prices.length-1][0],dp[prices.length-1][1]);
        return result;
    }
}

LeetCode T122 买卖股票的最佳时机 II

题目链接:122. 买卖股票的最佳时机 II - 力扣（LeetCode）

题目思路:

这道题和之前的区别就是买卖股票的次数不仅仅是一次了,所以我们需要将持有股票的状态修改一下,其余代码均不变

dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]-price[i])这是因为之前只能购买一次,所以不持有股票的状态的钱数一定是0,这里就不一样了,可以购买多次.

题目代码:

java 复制代码

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


    }
}



//动规
class Solution {
    public int maxProfit(int[] prices) {
       if(prices.length<=1){
            return 0;
        }
        int[][] dp = new int[prices.length][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for(int i = 1;i<prices.length;i++){
            dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]-prices[i]);
            dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]+prices[i]);
        }
        int result = Math.max(dp[prices.length-1][0],dp[prices.length-1][1]);
        return result;
    }
}