[牛客网-Leetcode] #数组 #dp 简单 best-time-to-buy-and-sell-stock-ii

最佳买卖股票时机ii best-time-to-buy-and-sell-stock-ii

题目描述

假设你有一个数组，其中第i个元素表示某只股票在第i天的价格。
设计一个算法来寻找最大的利润。你可以完成任意数量的交易(例如，多次购买和出售股票的一股)。但是，你不能同时进行多个交易(即，你必须在再次购买之前卖出之前买的股票)。

Say you have an array for which the ith element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

示例

示例1
输入

[1,4,2]

输出

3

示例2
输入

[2,1,4]

输出

3

解题思路

参考labuladong的算法小抄 团灭Leetcode股票买卖问题

• 状态：天数、已进行的交易次数、持有状态；选择：买buy、卖sell、不操作rest
• 状态转移图
• 状态转移方程

dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
              max(   选择 rest  ,             选择 sell      )

解释：今天我没有持有股票，有两种可能：
要么是我昨天就没有持有，然后今天选择 rest，所以我今天还是没有持有；
要么是我昨天持有股票，但是今天我 sell 了，所以我今天没有持有股票了。

dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
              max(   选择 rest  ,           选择 buy         )

解释：今天我持有着股票，有两种可能：
要么我昨天就持有着股票，然后今天选择 rest，所以我今天还持有着股票；
要么我昨天本没有持有，但今天我选择 buy，所以今天我就持有股票了。

• base case

dp[-1][k][0] = 0
解释：因为 i 是从 0 开始的，所以 i = -1 意味着还没有开始，这时候的利润当然是 0 。
dp[-1][k][1] = -infinity
解释：还没开始的时候，是不可能持有股票的，用负无穷表示这种不可能。
dp[i][0][0] = 0
解释：因为 k 是从 1 开始的，所以 k = 0 意味着根本不允许交易，这时候利润当然是 0 。
dp[i][0][1] = -infinity
解释：不允许交易的情况下，是不可能持有股票的，用负无穷表示这种不可能。

---

• 具体到此题，对应的是k = inf的情况

由于k为正无穷，所以不需要k这个状态了
1. 状态：0 <= i < n
2. 状态转移方程：
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])
3. base case:
根据dp[-1][0] = 0, dp[-1][1] = INT_MIN，可以得出：
dp[0][0] = max(dp[-1][0], dp[-1][1] + prices[0]) = 0
dp[0][1] = max(dp[-1][1], dp[-1][0] - prices[0]) = - prices[0]

• 首先写出dp数组的代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        //要注意特殊情况，否则prices[0]和prices[1]越界
        if(n <= 1) return 0;
        vector<vector<int>> dp(n, vector<int>(2));
        dp[0][0] = 0;
        dp[0][1] = - prices[0];
        for(int i = 1; i < n; 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[n - 1][0];
    }
};

• 由于新状态只与前一个状态有关，因此写出变量存储相邻状态的代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        if(n <= 1) return 0;
        //dp[0][0] = 0; dp[0][1] = - prices[0];
        int dp_i_0(0), dp_i_1(- prices[0]);
        
        for(int i = 1; i < n; i ++) {
            int temp = dp_i_0;
            //dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp_i_0 = max(dp_i_0, dp_i_1 + prices[i]);
            //dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
            //由于dp_i_0在上一条方程中被改变了，所以要用temp保存改变前的值
            dp_i_1 = max(dp_i_1, temp - prices[i]);
        }
        return dp_i_0;
    }
};