给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
示例 1：
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 1：
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
// 第i天 dp[i][0]持有股票时最大现金 dp[i][1]不持有股票时最大现金
// dp[i][0] dp[i-1][0]
// 0 - prices[i]
// dp[i][1] dp[i-1][1]
// dp[i-1][0] + prices[i]>>思考和分析
>>动规五部曲
1.确定dp数组（dp table）以及下标的含义
- dp[i][0] 表示第 i 天持有股票所得最多现金，持有股票之后哪来现金呢？这是因为一开始现金是0，那么加入第 i 天买入股票现金就是 -prices[i]，这是一个负数
- dp[i][1] 表示第 i 天不持有股票所得最多现金
"持有" : 不代表就是当天"买入"！可能昨天就买入了，今天保持有的状态
2.确定递推公式
① 若第 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 天卖出股票，按照今天股票价格卖出后所得现金就是现在所得，即：
- dp[i - 1][0] + prices[i]
dp[i][1]应该选所得现金最大的，dp[i][1] = max(dp[i - 1][1],dp[i - 1][0] + prices[i]);
3.dp数组初始化
由递推公式
- 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[0][0] 和 dp[0][1] 推导出来
- dp[0][0] -= prices[0];
- dp[0][1] = 0;
4.确定遍历顺序
从递推公式可以看出 dp[i] 都是由 dp[i - 1] 推导出来的，那么一定是 从前向后 遍历
5.举例推导dp数组
class Solution {
public:
// 动态规划 时间复杂度；O(n) 空间复杂度：O(n)
int maxProfit(vector<int>& prices) {
int len = prices.size();
if(len == 0) return 0;
vector<vector<int>> dp(len,vector<int>(2));
dp[0][0] = -prices[0];
dp[0][1] = 0;
for(int i = 1;i < len; 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]);
}
return dp[len - 1][1];
}
};- 时间复杂度：O(n)
- 空间复杂度：O(n)
>>优化空间复杂度
我们分析递推公式，可以看出dp[i] 只是依赖于 dp[i - 1] 的状态
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状态 和 前一天的 dp状态就可以了，可以使用滚动数组来节省空间
class Solution {
public:
int maxProfit(vector<int>& prices) {
int len = prices.size();
vector<vector<int>> dp(2, vector<int>(2)); // 注意这里只开辟了一个2 * 2大小的二维数组
dp[0][0] -= prices[0];
dp[0][1] = 0;
for (int i = 1; i < len; i++) {
dp[i % 2][0] = max(dp[(i - 1) % 2][0], -prices[i]);
dp[i % 2][1] = max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);
}
return dp[(len - 1) % 2][1];
}
};- 时间复杂度：O(n)
- 空间复杂度：O(1)
>>贪心算法思路
由于股票只买卖一次，因此贪心的思路就是找到最左最小值，最右最大值，得到的差值就是最大利润
class Solution {
public:
int maxProfit(vector<int>& prices) {
int low = INT_MAX;
int result = 0;
for (int i = 0; i < prices.size(); i++) {
low = min(low, prices[i]); // 取最左最小价格
result = max(result, prices[i] - low); // 直接取最大区间利润
}
return result;
}
};- 时间复杂度：O(n)
- 空间复杂度：O(1)
参考和推荐文章、视频
动态规划之 LeetCode：121.买卖股票的最佳时机1_哔哩哔哩_bilibili
来自代码随想录的课堂截图：
