动态规划：股票买卖问题

一、leetcode 123 买卖股票的最佳时机 Ⅲ

1.1、题目

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

1.2、分析

1.2.1、分析图

1.2.2、状态转移方程

     表示前天（第天）结束后，处在阶段的最大获利

阶段一、三、五

     

     表示昨天没有持有

     表示昨天持有，今天卖

阶段 二、四

     

表示昨天持有，并继续持有并获利

表示昨天没有持有，今天买入

表示昨天持有上一次的股票，今天卖出，并买入

1.3、代码实现

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        if (n == 0) {
            return 0;
        }

        vector<vector<int>> f(n+1, vector<int>(6, 0));
        f[0][1] = 0;
        f[0][2] = f[0][3] = f[0][4] = f[0][5] = INT_MIN;

        for (int i = 1; i <= n; i++) {
            // 1 3 5
            for (int j = 1; j <= 5 ; j+=2) {
                f[i][j] = f[i-1][j];
                if (i > 1 && j > 1 && f[i-1][j-1] != INT_MIN) {
                    f[i][j] = max(f[i][j], f[i-1][j-1] + prices[i-1]-prices[i-2]);
                }               
            }
            // 2 4
            for (int j = 2; j <= 4 ; j+=2) {
                f[i][j] = f[i-1][j-1];
                if (i > 1 && f[i-1][j] != INT_MIN) {
                    f[i][j] = max(f[i][j], f[i-1][j] + prices[i-1]-prices[i-2]);
                }
                if (j > 2 && i > 1 && f[i-1][j-2] != INT_MIN) {
                    f[i][j] = max(f[i][j], f[i-1][j-2] + prices[i-1]-prices[i-2]);
                }
            }

        }

        return max(max(f[n][1], f[n][3]), f[n][5]);
    }
};

 

二、leetcode 188 买卖股票的最佳时机 Ⅳ

2.1、题目

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

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

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

2.2、分析

2.2.1、分析图

2.2.2、状态转移方程

     表示前天（第天）结束后，处在阶段的最大获利

阶段一、三、五、2K+1-----手中无股票状态

     

     表示昨天没有持有

     表示昨天持有，今天卖

阶段 二、四、2k-----手中有股票状态

     

表示昨天持有，并继续持有并获利

表示昨天没有持有，今天买入

表示昨天持有上一次的股票，今天卖出，并买入

2.3、代码实现

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        int n = prices.size();
        if (n == 0) {
            return 0;
        }

        if (k > n) {
            int res = 0;
            for (int i =0; i < n; ++i) {
                res += max(prices[i+1]-prices[i], 0);
                return res;
            }
        }

        vector<vector<int>> f(n+1, vector<int>(2*k+2, 0));
        f[0][1] = 0;
        for (int i = 2; i <= 2*k+1; ++i) {
            f[0][i] = INT_MIN;
        }

        for (int i = 1; i <= n; i++) {
            // 1 3 5 ... 2k+1
            for (int j = 1; j <= 2*k+1 ; j+=2) {
                f[i][j] = f[i-1][j];
                if (i > 1 && j > 1 && f[i-1][j-1] != INT_MIN) {
                    f[i][j] = max(f[i][j], f[i-1][j-1] + prices[i-1]-prices[i-2]);
                }               
            }
            // 2 4 ... 2k
            for (int j = 2; j <= 2*k+1 ; j+=2) {
                f[i][j] = f[i-1][j-1];
                if (i > 1 && f[i-1][j] != INT_MIN) {
                    f[i][j] = max(f[i][j], f[i-1][j] + prices[i-1]-prices[i-2]);
                }
                if (j > 2 && i > 1 && f[i-1][j-2] != INT_MIN) {
                    f[i][j] = max(f[i][j], f[i-1][j-2] + prices[i-1]-prices[i-2]);
                }
            }

        }

        int res = INT_MIN;
        for (int j = 1; j <= 2*k+1 ; j+=2) {
            res = max(res, f[n][j]);
        }

        return res;
    }
};

---