【Leetocode】买卖股票

最新推荐文章于 2024-03-07 22:32:30 发布

霜霖❀

最新推荐文章于 2024-03-07 22:32:30 发布

阅读量112

点赞数

分类专栏：算法文章标签：动态规划算法买卖股票

本文链接：https://blog.youkuaiyun.com/xueyinglys/article/details/125360172

版权

算法专栏收录该内容

22 篇文章

订阅专栏

本文探讨了使用动态规划解决不同限制下股票交易的最大利润问题，包括有限交易次数和无限交易次数的情况。通过状态转移方程，展示了如何在遍历股票价格数组时计算最大收益。同时，给出了简洁的空间复杂度优化解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这种题的有一种通解，
设dp[i][k]是第i天进行了k次交易的最大收益，dp[i][k][0]是第i天进行了k次交易手上没有股票的最大收益，dp[i][k][1]是第i天进行了k次交易手上还有股票的最大收益。当买入时说明进行了一次新交易，而当遍历数组时，最后一天的最大收益应该是dp[i][k][0]（卖出去肯定比在自己手上收益更大）
状态转义方程如下：

dp[i][k][0]：在第i天可以是休息和卖出，休息时则前一天也没有股票，可以表示为dp[i-1][k][0]；卖出则说明前一天有股票，可以表示为dp[i-1][k][1]+prices[i]
dp[i][k][1]：在第i天可以是休息和买入，休息时说明前一天有股票，表示dp[i-1][k][1]，买入则说明前一天没有股票且交易数要减一，表示dp[i-1][k-1][0]-prices[i]

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

买卖股票的最佳时机（k=1）

来源：leetocde的121题
题目：
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

题解： 利用通解

// dp[i][k][0]=max(dp[i-1][1][0], dp[i-1][1][1]+prices[i])
// dp[i][k][1]=max(dp[i-1][0][1], dp[i-1][0][0]-prices[i])
//这里的第二个转移方程，dp[i][0][0]是第i天进行了0次交易，所以是0
```js
let dp=new Array(prices.length).fill(0).map(v => new Array(2).fill(0));
    dp[0][0]=0;
    dp[0][1]=-prices[0];

    for(let 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], -prices[i])
    }
    return dp[prices.length-1][0]

题解： 一次遍历，用当天股票价格减去之前天的股票最低价格就是截止当天时买卖股票的最大利润

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
    let minV=prices[0];
    let p=0;
    for(let i=1;i<prices.length;i++){
        if(prices[i]<minV){
            minV=prices[i];
        }else if(prices[i]-minV>=p){
            p = prices[i]-minV
        }
    }
    return p;
};

买卖股票的最佳时机II（k=正无穷）

leetcode链接
题目： 给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在同一天出售。返回你能获得的最大利润。
示例：

输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
     总利润为 4 + 3 = 7 。
输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
     总利润为 4 。

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。

题解： 利用通解，这里的k是不限制的，正无穷，所以k和k-1是相等的，现在用空间复杂度为O(1)的写法

//现在状态转移方程
//dp[i][k][0] = Math.max(dp[i-1][k][0], dp[i-1][k][1]+prices[i])
//dp[i][k][1] = Math.max(dp[i-1][k][1], dp[i-1][k][0]-prices[i])
var maxProfit = function(prices) {
    let profit0=0;
    let profit1=-prices[0];

    for(let i=0;i<prices.length;i++){
      let newProfit0  = Math.max(profit0, profit1+prices[i]);
      let newProfit1 = Math.max(profit1, profit0-prices[i])
      profit0 = newProfit0;
      profit1 = newProfit1
    }
    return profit0;
};

题解：

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
    let profit = 0;
    for(let i=1;i<prices.length;i++){
        if(prices[i]-prices[i-1]>0){
            profit += prices[i]-prices[i-1]
        }
    }
    return profit;
};

股票问题系列通解

买卖股票的最佳时机III（k=2）

题目：给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成两笔交易。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
    let len = prices.length;
    let dp = new Array(len).fill(0).map(v => new Array(3).fill(0).map(v=> new Array(2)));
    dp[0][1][0] = 0;
    dp[0][1][1] = -prices[0];
    dp[0][2][0] = 0;
    dp[0][2][1] = -prices[0];
    //状态转移方程
    //dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1]+prices[i]  ) 
    //dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k][0]-prices[i])                                                        
    for(let i=1;i<len;i++){
        dp[i][2][0] = Math.max(dp[i-1][2][0], dp[i-1][2][1]+prices[i])
        dp[i][2][1] = Math.max(dp[i-1][2][1], dp[i-1][1][0]-prices[i])
        dp[i][1][0] = Math.max(dp[i-1][1][0], dp[i-1][1][1]+prices[i])
        dp[i][1][1] = Math.max(dp[i-1][1][1], -prices[i])
    }
    return dp[len-1][2][0]
};