你真的会买股票吗？三道题教你买股票(动态规划)

最新推荐文章于 2024-07-24 20:44:05 发布

友人A

最新推荐文章于 2024-07-24 20:44:05 发布

阅读量155

点赞数 2

分类专栏： Leetcode 简单题刷题文章标签：动态规划算法数据结构 c语言

本文链接：https://blog.csdn.net/2302_76866243/article/details/130462447

版权

Leetcode 简单题刷题专栏收录该内容

12 篇文章 0 订阅

订阅专栏

文章目录

一 121. 买卖股票的最佳时机 1
122. 买卖股票的最佳时机 II
123. 买卖股票的最佳时机 III
复盘

一 121. 买卖股票的最佳时机 1

1.题目描述

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

示例 2：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

提示：

1 <= prices.length <= 105
0 <= prices[i] <= 104

2.问题分析

先来回顾动态规划的基本操作步骤
1.决定dp数组的定义，其意义一般是题目所求的答案
2.确定状态转移方程或者说是递推关系式
3.确定初始值（递推关系式无法适用的范围）
4.根据初始值与状态转移方程求目标值
返回最后所需要的目标值
1.由于题目要求最大利润，那么我们所定义的数其意义就是最大利润，而且题目没有其他的限制条件，可以先确定为一维数组，dp[i]代表前n天所得到的最大利润
2.确定方程式，在0与价格和之前最小价格的差值之间取最大值dp[i]=max(dp[i-1],prise[i]-min)
3.初始的min为prise[0];随后逐渐更改min
4.求目标值

3.代码实现

int Max(int x,int y)
{
    return(x>y?x:y);
}
int maxProfit(int* prices, int pricesSize){
    int dp[pricesSize];
     dp[0]=0;//初始值
    int min=prices[0],i; //初始值
    for(i=1;i<pricesSize;i++)
    {
        if(prices[i]<min)
         min=prices[i];
        dp[i]=Max(dp[i-1],prices[i]-min);//递推关系式
    }
    return dp[i-1];
}

注意：由于这道题相对简单，还有其他的办法，如一次遍历

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = (int)prices.size(), ans = 0;
        for (int i = 0; i < n; ++i){
            for (int j = i + 1; j < n; ++j) {
                ans = max(ans, prices[j] - prices[i]);
            }
        }
        return ans;
    }
};

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

1.题目描述

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在同一天出售。

返回你能获得的最大利润。

示例 1：

输入：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 。

示例 2：

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

示例 3：

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

提示：

1 <= prices.length <= 3 * 104
0 <= prices[i] <= 104

2.问题分析

于上一题不同的是这次可以进行多次操作，但是依旧走我们的步骤
1.确定dp的含义是该天的最大利润，问题来了，之前我们dp[i]代表的是第i天的最大利润，这是因为第i天一定是卖出了股票，但是现在不一定了，有可能手持股票继续交易，也有可能股票出售不在交易。那么现在的递推关系式怎么办？
仔细一想其实题目中隐含了状态条件，每天的状态有两种：持有股票与不持有股票，除了天数，每天又增加了两个状态，所以我们设计dp[i][0],dp[i][1]，标志每天的两种状态下的最大利润。
2.确定初始值。dp[0][0]表示第一天不买股票，即0；dp[0][1]代表第一天买进股票，即-prise[0];
3.确定递推关系式：
如果这一天没有股票，有可能是前一天依然没有股票然后没有操作，也有可能是前一天持有股票在今天卖了，两者情况取最大值：

dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prise[i]);

如果这一天有股票，也有两种情况，要么昨天就有股票今天没有操作，或者昨天没有股票今天买进，两者取最大值

dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prise[i]);

4.根据初始值与递推关系式求解目标值

3.代码展示

int max(int x,int y)
{
    return x>y?x:y;
}
int maxProfit(int* prices, int pricesSize){
    if(pricesSize<2)
    return 0;
    int dp[pricesSize][2];
    dp[0][0]=0;
    dp[0][1]=-prices[0];//初始值
    int i=0,j;
    for(i=1;i<pricesSize;i++)
    {
        dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]);
        dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i]);//递推关系式
    }
    return (dp[i-1][0]);
}

4. 其他解法（贪心算法）

本题目还可以用贪心算法求解
贪心就是只考虑本次的最优解，每次步骤都是最优解，最后加起来也是最优解

每次将股票于下一天的作比较，如果涨了就买，不涨就不买

int maxProfit(int* prices, int pricesSize){
    int i,ans=0;
    for(i=0;i<pricesSize-1;i++)
    {
        if(prices[i]<prices[i+1])
        ans+=(prices[i+1]-prices[i]);
    }
    return ans;
}

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

1.题目描述

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成两笔交易。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

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

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这个情况下, 没有交易完成, 所以最大利润为 0。

示例 4：

输入：prices = [1]
输出：0

提示：

1 <= prices.length <= 105
0 <= prices[i] <= 105

2.问题分析

是不是感觉有点吃力？没关系因为这是leetcode的困难的题目让我们先分析一波
1.确定dp的含义，就是第i天的最大利润，有了第二道题目的基础，这道题增加了一个限制条件：只能操作2次，又与第二道不同了
第二题目之中每天有两种状态：买入或卖出
但是此时我们便有了5种状态
1.不操作
2.第一次买入，手持股票
3.第一次卖出，不持有股票
4.第二次买入，手持股票
5.第二次卖出，不持有股票
但是第一种不操作的情况为0，我们不予以讨论，没有递推关系式
那么便可以设计以下数组dp[i][4]
dp[i][0]=第i天第一次买入，手持股票
dp[i][1]=第i天第一次卖出，不持有股票
dp[i][2]=第i天第二次买入，手持股票
dp[i][3]=第i天第二次卖出，不持有股票
2.确定递推关系式
dp[i][0]=第i天第一次买入，手持股票，有可能是前一天就有是第一次买入的股票没有操作，或者是前一天没有股票今天买入，两种情况取最大值：
```
 dp[i][0]=max(dp[i-1][0],0-prise[i]);
```
dp[i][1]=第i天第一次卖出，不持有股票，有可能是前一天就是第一次卖出不持有股票不操作，也可能是前一天持有股票今天卖出

 dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prise[i]);

以下同理

    dp[i][2]=max(dp[i-1][2],dp[i-1][1]-prise[i]);

    dp[i][3]=max(dp[i-1][3],dp[i-1][2]+prise[i]);

3.确定初始值

 dp[0][0]=-prise[0];表示第一天买进

 dp[0][1]=0;表示第一天买进又卖出

 dp[0][2]=-prise[0];表示第一天买进卖出又买进

```
 dp[0][3]=0;
```
4.根据递推关系式与初始值求解

3.代码分享

int max(int x,int y)
{
    return (x>y?x:y);
}
int maxProfit(int* prices, int pricesSize){
    if(pricesSize<2)
    return 0;
    int dp[pricesSize][4];
    dp[0][0]=-prices[0];
    dp[0][1]=0;
    dp[0][2]=-prices[0];
    dp[0][3]=0;
    int i,j;
    for(i=1;i<pricesSize;i++)
    {
        dp[i][0]=max(dp[i-1][0],-prices[i]);
        dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[i]);
        dp[i][2]=max(dp[i-1][2],dp[i-1][1]-prices[i]);
        dp[i][3]=max(dp[i-1][3],dp[i-1][2]+prices[i]);
    }
    return(dp[i-1][3]);
}