DAY 53 动态规划

动态规划——股票

要点：用三维dp做推导，注意递推公式和初始化

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

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

题目描述

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

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

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

思路

状态：
1.天数
2.交易次数
3.持有状态
选择：
1.buy
2.sell
3.rest
递推公式：
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]);
初始化：
if (i == 0)
{
dp[i][k][0] = 0;
dp[i][k][1] = -prices[i];
continue;
}

代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int max_k = 2;
        vector<vector<vector<int>>> dp(n, vector<vector<int>>(max_k + 1,vector<int>(2)));
        for (int i = 0; i < n; i++)
        {
            for (int k = 1; k <= max_k; k--)
            {
                if (i == 0)
                {
                    dp[i][k][0] = 0;
                    dp[i][k][1] = -prices[i];
                    continue;
                }
                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]);
            }
        }
        return dp[n-1][max_k][0];
    }
};

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

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

题目描述

给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格，和一个整型 k 。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。

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

思路

分析
1.一次交易，买入卖出，需要两天，若给定的交易次数大于n/2，则相当于不限定最大交易次数，此时三维数组会过大，单独处理，使用二维数组即可
2.交易次数<=n/2，按照三维dp推导即可
状态：
1.天数
2.交易次数
3.持有状态
选择：
1.buy
2.sell
3.rest
递推公式：
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]);
初始化：
if (i == 0)
{
dp[i][k][0] = 0;
dp[i][k][1] = -prices[i];
continue;
}

代码

class Solution {
public:
    int maxProfit(vector<int>& prices)
    {
        int n = prices.size();
        vector<vector<int>> dp(n,vector<int>(2));
        for (int i = 0; i < n; i++)
        {
            if (i == 0)
            {
                dp[i][0] = 0;
                dp[i][1] = - prices[i];
                continue;
            }
            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];
    }

    int maxProfit(int k, vector<int>& prices) {
        int n = prices.size();
        //注意 k > n/2 的逻辑即可，此时若用三维dp，存在数组过大的问题，故用二维处理
        if (k > n/2)
        {
            return maxProfit(prices);
        }
        vector<vector<vector<int>>> dp(n,vector<vector<int>>(k+1,vector<int>(2)));
        for (int i = 0; i < n; i++)
        {
            for (int j = 1; j <= k; j++)
            {
                if (i == 0)
                {
                    dp[i][j][0] = 0;
                    dp[i][j][1] = -prices[i];
                    continue;
                }
                dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1] + prices[i]);
                dp[i][j][1] = max(dp[i-1][j][1], dp[i - 1][j - 1][0] - prices[i]);
            }
        }
        return dp[n-1][k][0];
    }
};