代码随想录-动态规划-买卖股票的最佳时机（Java）

最新推荐文章于 2024-01-29 20:32:37 发布

溪溪1111

最新推荐文章于 2024-01-29 20:32:37 发布

阅读量153

点赞数

分类专栏：算法学习文章标签：动态规划 java 算法

本文链接：https://blog.csdn.net/weixin_45685902/article/details/129867315

版权

算法学习专栏收录该内容

26 篇文章 0 订阅

订阅专栏

买卖股票的最佳时机

链接: 121. 买卖股票的最佳时机

思路

不要急着否定自己的思路

可能不完全正确，但是有可取之处

本题肯定是要取最大差值

贪心算法

具体思想是找一个比较小的数，然后向右遍历，再找到一个右边使之差值最大的数

所以本题在遍历过程中，一边找最左最小的价格，一遍向右遍历找区间最大差值即最大利润\

动态规划

与打劫III有异曲同工之处，每个元素分成了两种状态，持有和不持有

确定dp数组（dp table）以及下标的含义

dp[i][0] 表示第i天持有股票所得最多现金，这里可能有同学疑惑，本题中只能买卖一次，持有股票之后哪还有现金呢？

其实一开始现金是0，那么加入第i天买入股票现金就是 -prices[i]，这是一个负数。

dp[i][1] 表示第i天不持有股票所得最多现金

注意这里说的是“持有”，“持有”不代表就是当天“买入”！也有可能是昨天就买入了，今天保持持有的状态

很多同学把“持有”和“买入”没区分清楚。

在下面递推公式分析中，我会进一步讲解。

确定递推公式

如果第i天持有股票即dp[i][0]，那么可以由两个状态推出来

第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金即：dp[i - 1][0]
第i天买入股票，所得现金就是买入今天的股票后所得现金即：-prices[i]

那么dp[i][0]应该选所得现金最大的，所以dp[i][0] = max(dp[i - 1][0], -prices[i]);

如果第i天不持有股票即dp[i][1]，也可以由两个状态推出来

第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金即：dp[i - 1][1]
第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金即：prices[i] + dp[i - 1][0]

同样dp[i][1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

这样递推公式我们就分析完了

dp数组如何初始化

由递推公式 dp[i][0] = max(dp[i - 1][0], -prices[i]); 和 dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);可以看出

其基础都是要从dp[0][0]和dp[0][1]推导出来。

那么dp[0][0]表示第0天持有股票，此时的持有股票就一定是买入股票了，因为不可能有前一天推出来，所以dp[0][0] -= prices[0];

dp[0][1]表示第0天不持有股票，不持有股票那么现金就是0，所以dp[0][1] = 0;

确定遍历顺序

从递推公式可以看出dp[i]都是由dp[i - 1]推导出来的，那么一定是从前向后遍历。

举例推导dp数组

代码

//贪心算法
class Solution {
    public int maxProfit(int[] prices) {
        if (prices.length == 1) return 0;
        int low = Integer.MAX_VALUE;
        int result = 0;
        // 取最左最小价格
        // 取区间最大利润
        for (int i = 0;i < prices.length;i++){
            low = Math.min(low,prices[i]);
            result = Math.max(result,prices[i] - low);
        }
        return result;
    }
}

//动态规划
// 解法1
class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) return 0;
        int length = prices.length;
        // dp[i][0]代表第i天持有股票的最大收益
        // dp[i][1]代表第i天不持有股票的最大收益
        int[][] dp = new int[length][2];
        int result = 0;
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < length; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], -prices[i]);
            dp[i][1] = Math.max(dp[i - 1][0] + prices[i], dp[i - 1][1]);
        }
        return dp[length - 1][1];
    }
}

//解法二
class Solution {
  public int maxProfit(int[] prices) {
    int[] dp = new int[2];
    // 记录一次交易，一次交易有买入卖出两种状态
    // 0代表持有，1代表卖出
    dp[0] = -prices[0];
    dp[1] = 0;
    // 可以参考斐波那契问题的优化方式
    // 我们从 i=1 开始遍历数组，一共有 prices.length 天，
    // 所以是 i<=prices.length
    for (int i = 1; i <= prices.length; i++) {
      // 前一天持有；或当天买入
      dp[0] = Math.max(dp[0], -prices[i - 1]);
      // 如果 dp[0] 被更新，那么 dp[1] 肯定会被更新为正数的 dp[1]
      // 而不是 dp[0]+prices[i-1]==0 的0，
      // 所以这里使用会改变的dp[0]也是可以的
      // 当然 dp[1] 初始值为 0 ，被更新成 0 也没影响
      // 前一天卖出；或当天卖出, 当天要卖出，得前一天持有才行
      dp[1] = Math.max(dp[1], dp[0] + prices[i - 1]);
    }
    return dp[1];
  }
}

买卖股票的最佳时机II

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

思路

贪心算法

贪心算法里面做过了

因为不止可以买卖一次，求最大利润

在遍历中，相邻两个元素差值大于0 的都相加

代码

//贪心算法
class Solution {
    public int maxProfit(int[] prices) {
        if (prices.length == 1) return 0;
        int result = 0;
        for (int i = 1;i < prices.length;i++){
            if (prices[i] - prices[i - 1] > 0){
                result += (prices[i] - prices[i - 1]);
            }
        }
        return result;
    }
}

//动态规划
// 0：未持有股票，1：持有股票
class Solution 
    // 实现1：二维数组存储
    // 可以将每天持有与否的情况分别用 dp[i][0] 和 dp[i][1] 来进行存储
    // 时间复杂度：O(n)，空间复杂度：O(n)
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n][2];     // 创建二维数组存储状态
        dp[0][0] = 0;                   // 初始状态
        dp[0][1] = -prices[0];
        for (int i = 1; i < n; ++i) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);    // 第 i 天，没有股票
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);    // 第 i 天，持有股票
        }
        return dp[n - 1][0];    // 卖出股票收益高于持有股票收益，因此取[0]
    }
}

//优化空间：一位滚动数组
class Solution {
    public int maxProfit(int[] prices) {
        int[] dp = new int[2];
        // 0表示未持有，1表示持有
        dp[0] = 0;
        dp[1] = -prices[0];
        for(int i = 1; i <= prices.length; i++){
            // 前一天持有; 既然不限制交易次数，那么再次买股票时，要加上之前的收益
            dp[1] = Math.max(dp[1], dp[0] - prices[i-1]);
            // 前一天卖出; 或当天卖出，当天卖出，得先持有
            dp[0] = Math.max(dp[0], dp[1] + prices[i-1]);
        }
        return dp[0];
    }
}

买卖股票的最佳时机III

链接: 123.买卖股票的最佳时机III

思路

因为最多两次，我的思路很简单直白，找一个地方设置while循环，小于等于2即可，但是无法判定卖出买入

本题还是按二维数组，第二个维度代表状态

具体含义见代码注释吧

然后递推公式很自然地写了出来

自己在这方面出了个错，是因为自己在复制代码后，修改复制的代码没修改完，把“+”写成了“-”

但在自己思路里这是对的，所以检查时总是再三忽略。

清空自己的思维，一步步思考

代码

class Solution {
    public int maxProfit(int[] prices) {
        if (prices.length == 1) return 0;
        // 含义：dp[i][0] 第i天持有股票的状态是未进行操作
        // dp[i][1] 第i天持有股票的状态是第一次买入
        // dp[i][2] 第i天持有股票的状态是第一次卖出
        // dp[i][3] 第i天持有股票的状态是第二次买入
        // dp[i][4] 第i天持有股票的状态是第二次卖出
        int[][] dp = new int[prices.length][5];
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];
        for (int i = 1;i < prices.length;i++){
            dp[i][1] = Math.max(dp[i - 1][1], - prices[i]);
            dp[i][2] = Math.max(dp[i - 1][2],dp[i - 1][1] + prices[i]);
            dp[i][3] = Math.max(dp[i - 1][3],dp[i - 1][2] - prices[i]);
            dp[i][4] = Math.max(dp[i - 1][4],dp[i - 1][3] + prices[i]);
        }
        return Math.max(dp[prices.length - 1][2],dp[prices.length - 1][4]);
    }
}
// 一位滚动数组，不断覆盖
class Solution {
    public int maxProfit(int[] prices) {
        if (prices.length == 1) return 0;
        int[] dp = new int[4];
        // dp[0]代表第一次买入
        // dp[1]代表第一次卖出
        // dp[2]代表第二次买入
        // dp[3]代表第二次卖出
        dp[0] = - prices[0];
        dp[1] = 0;
        dp[2] = -prices[0];
        dp[3] = 0;
        for (int i = 0;i < prices.length;i++){
            dp[0] = Math.max(dp[0],-prices[i]);
            dp[1] = Math.max(dp[1],dp[0] + prices[i]);
            dp[2] = Math.max(dp[2],dp[1] - prices[i]);
            dp[3] = Math.max(dp[3],dp[2] + prices[i]);
        }
        return dp[3];
    }
}

买卖股票的最佳时机IV

链接: 188.买卖股票的最佳时机IV

思路

本题思路与买卖股票III基本一致

观察买卖股票III，我们知道奇数为买入，偶数为卖出

然后由此写递推公式

一些赋值和循环时的边界条件要注意

还有一点是，在代码的世界里面没有2k+1这种说法

需要2*k + 1

代码

class Solution {
    public int maxProfit(int k, int[] prices) {
        if (prices.length == 0 || prices.length == 1){
            return 0;
        }
        int len = prices.length;
        // 奇数是买入  偶数是卖出
        int[][] dp = new int[len][2*k + 1];
        for (int j = 1;j <= k;j++){
            dp[0][2*j - 1] = -prices[0];
            dp[0][2*j] = 0;
        }
        for (int i = 1;i < len;i++){
            for (int j = 1;j <= k;j++){
                dp[i][2*j - 1] = Math.max(dp[i - 1][2*j - 1],dp[i - 1][2*j - 2] - prices[i]);
                dp[i][2*j] = Math.max(dp[i - 1][2*j],dp[i - 1][2*j - 1] + prices[i]);
            }
        }
        return dp[len - 1][2*k];
    }
}
// 一位滚动数组
//版本三：一维 dp数组
class Solution {
    public int maxProfit(int k, int[] prices) {
        if(prices.length == 0){
            return 0;
        }
        if(k == 0){
            return 0;
        }
        // 其实就是123题的扩展，123题只用记录2次交易的状态
        // 这里记录k次交易的状态就行了
        // 每次交易都有买入，卖出两个状态，所以要乘 2
        int[] dp = new int[2 * k];
        // 按123题解题格式那样，做一个初始化
        for(int i = 0; i < dp.length / 2; i++){
            dp[i * 2] = -prices[0];
        }
        for(int i = 1; i <= prices.length; i++){
            dp[0] = Math.max(dp[0], -prices[i - 1]);
            dp[1] = Math.max(dp[1], dp[0] + prices[i - 1]);
            // 还是与123题一样，与123题对照来看
            // 就很容易啦
            for(int j = 2; j < dp.length; j += 2){
                dp[j] = Math.max(dp[j], dp[j - 1] - prices[i-1]);
                dp[j + 1] = Math.max(dp[j + 1], dp[j] + prices[i - 1]);
            }
        }
        // 返回最后一次交易卖出状态的结果就行了
        return dp[dp.length - 1];
    }
}

最佳买卖股票实时机含冷冻期

链接: 309.最佳买卖股票时机含冷冻期

思路

本题主要是区分状态

具体可以区分出如下四个状态：

状态一0：持有股票状态（今天买入股票，或者是之前就买入了股票然后没有操作，一直持有）
不持有股票状态，这里就有两种卖出股票状态
- 状态二1：保持卖出股票的状态（两天前就卖出了股票，度过一天冷冻期。或者是前一天就是卖出股票状态，一直没操作）
- 状态三2：今天卖出股票
状态四3：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！

代码

class Solution {
    public int maxProfit(int[] prices) {
        if (prices.length == 1) return 0;
        // dp[i][0] 第i天状态：买入
        // dp[i][1] 第i天状态：卖出股票状态 且无冷冻期
        // dp[i][2] 第i天状态：今天卖出股票
        // dp[i][3] 第i天状态：冷冻期 不可持续只有一天
        int[][] dp = new int[prices.length][4];
        dp[0][0] = -prices[0];
        for (int i = 1;i < prices.length;i++){
            dp[i][0] = max(dp[i - 1][0],dp[i - 1][1] - prices[i],dp[i - 1][3] - prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1],dp[i - 1][3]);
            // dp[i][2] = Math.max(dp[i - 1][0] + prices[i]);
            dp[i][2] = dp[i - 1][0] + prices[i];
            dp[i][3] = dp[i - 1][2];
        }
        return max(dp[prices.length - 1][1],dp[prices.length - 1][2],dp[prices.length - 1][3]);
    }
    int max(int a,int b,int c){
        int d = Math.max(a,b);
        return Math.max(d,c);
    }
}

Math.max()只能比较两个值，所以定义了max函数

买卖股票的最佳时机含手续费

链接: 714.买卖股票的最佳时机含手续费

思路

思路与多次买卖一支股票差不多

只是在卖出时需要扣掉手续费

大胆做，加油！

代码

class Solution {
    public int maxProfit(int[] prices, int fee) {
        if (prices.length == 1) return 0;
        // dp[i][0] 第i天是买入的状态
        // dp [i][1] 第i天是卖出的状态
        int[][] dp = new int[prices.length][2];
        dp[0][0] = -prices[0];
        // 自己也在写这个时纠结，如果不是最大，其实没必要买入卖出了
        // dp[0][1] = -fee;
        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] -fee);
        }
        return dp[prices.length - 1][1];
    }
}