LeetCode 股票买卖问题

LeetCode 股票买卖问题

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

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

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

示例 1:

输入: [2,4,1], k = 2
输出: 2
解释: 在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。

示例 2:

输入: [3,2,6,5,0,3], k = 2
输出: 7
解释: 在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
     随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。

开始先不进行该题的解答，我们先分析整个框架，拿这道题来举例，最后解决leetcode上所有的股票买卖问题

⼀、 穷举框架

我们不⽤递归思想进⾏穷举， ⽽是利⽤「状态」 进⾏穷举。 我们具体到每⼀天， 看看总共有⼏种可能的「状态」 ， 再找出每个「状态」 对应的「选择」 。 我们要穷举所有「状态」 ， 穷举的⽬的是根据对应的「选择」 更新状态。 听起来抽象， 你只要记住「状态」 和「选择」 两个词就⾏， 下⾯实操⼀下就很容易明⽩了。

for 状态1 in 状态1的所有取值：
	for 状态2 in 状态2的所有取值：
		for ...
			dp[状态1][状态2][...] = 择优(选择1， 选择2...)

⽐如某个股票个问题， 每天都有三种「选择」 ： 买⼊、 卖出、 ⽆操作， 我们⽤
buy, sell, rest 表⽰这三种选择。 但问题是， 并不是每天都可以任意选择这三
种选择的， 因为 sell 必须在 buy 之后， buy 必须在 sell 之后。 那么 rest 操作
还应该分两种状态， ⼀种是 buy 之后的 rest（持有了股票） ， ⼀种是 sell 之
后的 rest（没有持有股票） 。 ⽽且别忘了， 我们还有交易次数 k 的限制， 就
是说你 buy 还只能在 k > 0 的前提下操作。

很复杂对吧， 不要怕， 我们现在的⽬的只是穷举， 你有再多的状态， ⽼夫要做的就是⼀把梭全部列举出来。 这个问题的「状态」 有三个， 第⼀个是天数， 第⼆个是允许交易的最⼤次数， 第三个是当前的持有状态（即之前说的rest 的状态， 我们不妨⽤ 1 表⽰持有， 0 表⽰没有持有） 。 然后我们⽤⼀个三维数组就可以装下这⼏种状态的全部组合：

dp[i][k][0 or 1]
0 <= i <= n-1, 1 <= k <= K
n 为天数， ⼤ K 为最多交易数
此问题共 n × K × 2 种状态， 全部穷举就能搞定。
for 0 <= i < n:
	for 1 <= k <= K:
		for s in {0, 1}:
			dp[i][k][s] = max(buy, sell, rest)

简单解释一下每⼀个状态的含义， ⽐如说 dp[3][2][1]的含义就是： 今天是第三天， 我现在⼿上持有着股票， ⾄今最多进⾏ 2 次交易。 再⽐如 dp[2][3][0] 的含义： 今天是第⼆天， 我现在⼿上没有持有股票， ⾄今最多进⾏ 3 次交易。 很容易理解， 对吧？

我们想求的最终答案是 dp[n - 1][K][0]， 即最后⼀天， 最多允许 K 次交易，最多获得多少利润。 读者可能问为什么不是 dp[n - 1][K][1]？ 因为 [1] 代表⼿上还持有股票， [0] 表⽰⼿上的股票已经卖出去了， 很显然后者得到的利润⼀定⼤于前者

⼆、 状态转移框架

现在， 我们完成了「状态」 的穷举， 我们开始思考每种「状态」 有哪些「选
择」 ， 应该如何更新「状态」 。 只看「持有状态」 ， 可以画个状态转移图

通过这个图可以很清楚地看到， 每种状态（0 和 1） 是如何转移⽽来的。 根
据这个图， 我们来写⼀下状态转移⽅程：

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， 所以今天我就持有股票了。

这个解释应该很清楚了， 如果 buy， 就要从利润中减去 prices[i]， 如果 sell，
就要给利润增加 prices[i]。 今天的最⼤利润就是这两种可能选择中较⼤的那
个。 ⽽且注意 k 的限制， 我们在选择 buy 的时候， 把 k 减⼩了 1， 很好理解
吧， 当然你也可以在 sell 的时候减 1， ⼀样的。

现在， 我们已经完成了动态规划中最困难的⼀步： 状态转移⽅程。 如果之前
的内容你都可以理解， 那么你已经可以秒杀所有问题了， 只要套这个框架就
⾏了。 不过还差最后⼀点点， 就是定义 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
解释： 不允许交易的情况下， 是不可能持有股票的， ⽤负⽆穷表⽰这种不可能。

把上⾯的状态转移⽅程总结⼀下：

base case：
dp[-1][k][0] = dp[i][0][0] = 0
dp[-1][k][1] = dp[i][0][1] = -infinity

状态转移⽅程：
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])

读者可能会问， 这个数组索引是 -1 怎么编程表⽰出来呢， 负⽆穷怎么表⽰
呢？ 这都是细节问题， 有很多⽅法实现

三、解题

第一题：K = 1

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

如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。

注意你不能在买入股票前卖出股票。

示例 1:

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

示例 2:

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

直接套状态转移⽅程， 根据 base case， 可以做⼀些化简：

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

解释： k = 0 的 base case， 所以 dp[i-1][0][0] = 0。
现在发现 k 都是 1， 不会改变， 即 k 对状态转移已经没有影响了。
可以进⾏进⼀步化简去掉所有 k：

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

完整代码：

int n = prices.length;
int[][] dp = new int[n][2];
for (int i = 0; i < n; i++) {
	dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + prices[i]);
	dp[i][1] = Math.max(dp[i-1][1], -prices[i]);
} 
return dp[n - 1][0];

显然 i = 0 时 dp[i-1] 是不合法的。 这是因为我们没有对 i 的 base case 进⾏处
理。 可以这样处理：

for (int i = 0; i < n; i++) {
	if (i - 1 == -1) {
		dp[i][0] = 0;
		// 解释：
		// dp[i][0]
		// = max(dp[-1][0], dp[-1][1] + prices[i])
		// = max(0, -infinity + prices[i]) = 0
		dp[i][1] = -prices[i];
		//解释：
		// dp[i][1]
		// = max(dp[-1][1], dp[-1][0] - prices[i])
		// = max(-infinity, 0 - prices[i])
		// = -prices[i]
		continue;
	} 
	dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + prices[i]);
	dp[i][1] = Math.max(dp[i-1][1], -prices[i]);
	} 
return dp[n - 1][0];

C++代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {

        if(prices.empty())
        {
            return 0;
        }

        //定义一个二维数组，根据博客当中的讲解，dp[i][j]就代表第i天在j状态下的最大利润
        vector<vector<int>> dp(prices.size(),vector<int>(2,0));

        //循环遍历
        for(int i = 0;i < prices.size();i++)
        {
            if(i - 1 < 0)
            {
                //-infinity用来标记不可能存在的情况，代表负无穷
                dp[i][0] = 0;
                // 解释：
                //dp[i][0]
                // = max(dp[-1][0], dp[-1][1] + prices[i])
                // = max(0, -infinity + prices[i]) = 0

                dp[i][1] = -prices[i];
                //解释：
                // dp[i][1]
                // = max(dp[-1][1], dp[-1][0] - prices[i])
                // = max(-infinity, 0 - prices[i])
                // = -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],- prices[i]);
        }
        //注意最后返回的是dp[prices.size() - 1][0]，而不是dp[prices.size() - 1][1]
        //因为后者还持有没有卖出去，其利润肯定比前者小
        return dp[prices.size() - 1][0];
    }
};

第⼀题就解决了， 但是这样处理 base case 很⿇烦， ⽽且注意⼀下状态转移
⽅程， 新状态只和相邻的⼀个状态有关， 其实不⽤整个 dp 数组， 只需要⼀
个变量储存相邻的那个状态就⾜够了， 这样可以把空间复杂度降到 O(1):

// k == 1
int maxProfit_k_1(int[] prices) {
	int n = prices.length;
	// base case: dp[-1][0] = 0, dp[-1][1] = -infinity
	int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
	for (int i = 0; i < n; i++) {
		// dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
		dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
		// dp[i][1] = max(dp[i-1][1], -prices[i])
		dp_i_1 = Math.max(dp_i_1, -prices[i]);
	} 
	return dp_i_0;
}

第⼆题， k = +infinity

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

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

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

示例 1:

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

示例 2:

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

示例 3:

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

如果 k 为正⽆穷， 那么就可以认为 k 和 k - 1 是⼀样的。 可以这样改写框
架：

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])
= max(dp[i-1][k][1], dp[i-1][k][0] - prices[i])//注意

//我们发现数组中的 k 已经不会改变了， 也就是说不需要记录 k 这个状态了：
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])

完整代码：

int maxProfit_k_inf(int[] prices) {
	int n = prices.length;
	int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
	for (int i = 0; i < n; i++) {
		int temp = dp_i_0;
		dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
		dp_i_1 = Math.max(dp_i_1, temp - prices[i]);
	}
return dp_i_0;
}

C++代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.empty())
        {
            return 0;
        }
        // 博客中有详细解释，就不注释了
        int dp_i_0 = 0;
        int dp_i_1 = INT_MIN;
        for(int i = 0;i < prices.size();i++)
        {
            dp_i_0 = max(dp_i_0 , dp_i_1 + prices[i]);
            dp_i_1 = max(dp_i_1,dp_i_0 - prices[i]);
        }

        return dp_i_0;
    }
};

第三题， k = +infinity with cooldown

给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。​

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
示例:

输入: [1,2,3,0,2]
输出: 3 
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

每次 sell 之后要等⼀天才能继续交易。 只要把这个特点融⼊上⼀题的状态转
移⽅程即可：

dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
dp[i][1] = max(dp[i-1][1], dp[i-2][0] - prices[i])
解释： 第 i 天选择 buy 的时候， 要从 i-2 的状态转移， ⽽不是 i-1 。

完整代码：

int maxProfit_with_cool(int[] prices) {
	int n = prices.length;
	int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
	int dp_pre_0 = 0; // 代表 dp[i-2][0]
	for (int i = 0; i < n; i++) {
		int temp = dp_i_0;
		dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
		dp_i_1 = Math.max(dp_i_1, dp_pre_0 - prices[i]);
		dp_pre_0 = temp;
	} 
	return dp_i_0;
}

C++代码：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
    int n = prices.size();
    if(n == 0)
    {
        return 0;
    }
    int dp_i_0 = 0;
    int dp_i_1 = INT_MIN;
    int dp_pre_0 = 0; // 代表 dp[i-2][0]
    for (int i = 0; i < n; i++) 
    {
        int temp = dp_i_0;
        dp_i_0 = max(dp_i_0, dp_i_1 + prices[i]);
        dp_i_1 = max(dp_i_1, dp_pre_0 - prices[i]);
        dp_pre_0 = temp;
    } 
    return dp_i_0;
    }
};

第四题， k = +infinity with fee

给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每次交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

示例 1:

输入: prices = [1, 3, 2, 8, 4, 9], fee = 2
输出: 8
解释: 能够达到的最大利润:  
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8.

每次交易要⽀付⼿续费， 只要把⼿续费从利润中减去即可。 改写⽅程：

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] - fee)
解释： 相当于买⼊股票的价格升⾼了。
在第⼀个式⼦⾥减也是⼀样的， 相当于卖出股票的价格减⼩了。

完整代码：

int maxProfit_with_fee(int[] prices, int fee) {
	int n = prices.length;
	int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
	for (int i = 0; i < n; i++) {
		int temp = dp_i_0;
		dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
		dp_i_1 = Math.max(dp_i_1, temp - prices[i] - fee);
	} 
return dp_i_0;
}

C++代码：

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n = prices.size();
        if(n == 0)
        {
            return 0;
        }
	    int dp_i_0 = 0, dp_i_1 = INT_MIN;
	    for (int i = 0; i < n; i++) 
        {
		    int temp = dp_i_0;//需要用一个临时变量来保存dp_i_0的值，因为在计算第i天的时候，dp_i_0
            //已经发生改变
		    dp_i_0 = max(dp_i_0, dp_i_1 + prices[i]);
		    dp_i_1 = max(dp_i_1, temp - prices[i] - fee);
	    } 
    return dp_i_0;
    }
};

第五题， k = 2

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

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

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

示例 1:

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

示例 2:

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

示例 3:

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

k = 2 和前⾯题⽬的情况稍微不同， 因为上⾯的情况都和 k 的关系不太⼤。要么 k 是正⽆穷， 状态转移和 k 没关系了； 要么 k = 1， 跟 k = 0 这个 base case 挨得近， 最后也没有存在感。

这道题 k = 2 和后⾯要讲的 k 是任意正整数的情况中， 对 k 的处理就凸显出来了。 我们直接写代码， 边写边分析原因。

原始的动态转移⽅程， 没有可化简的地⽅
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])

按照之前的代码， 我们可能想当然这样写代码（错误的） ：

int k = 2;
int[][][] dp = new int[n][k + 1][2];
for (int i = 0; i < n; i++)
	if (i - 1 == -1) 
	{ /* 处理⼀下 base case*/ }
	
	dp[i][k][0] = Math.max(dp[i-1][k][0], dp[i-1][k][1] + prices[i]);
	dp[i][k][1] = Math.max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i]
	);
} 
return dp[n - 1][k][0];

为什么错误？ 我这不是照着状态转移⽅程写的吗？

这道题由于没有消掉 k 的影响， 所以必须要对 k 进⾏穷举：

int max_k = 2;
int[][][] dp = new int[n][max_k + 1][2];
	for (int i = 0; i < n; i++) {
		for (int k = max_k; k >= 1; k--) {
			if (i - 1 == -1) { /*处理 base case */ }
			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]);
		}
	} 
	// 穷举了 n × max_k × 2 个状态， 正确。
return dp[n - 1][max_k][0];

C++代码：

class Solution {
public:
    int maxProfit(vector<int>& prices) {

        if(prices.empty())
        {
            return 0;
        }

        int max_k = 2;
        
        vector<vector<vector<int>>> dp(prices.size(),
                                        vector<vector<int>>(max_k + 1,
                                        vector<int>(2,0)));

        //循环遍历
        for(int i = 0;i < prices.size();i++)
        {
            for(int k = max_k;k >= 1;k--)
            {
                if(i - 1 < 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[prices.size() - 1][max_k][0];
    }
};

第六题， k = any integer

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

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

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

示例 1:

输入: [2,4,1], k = 2
输出: 2
解释: 在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。

示例 2:

输入: [3,2,6,5,0,3], k = 2
输出: 7
解释: 在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
     随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。

有了上⼀题 k = 2 的铺垫， 这题应该和上⼀题的第⼀个解法没啥区别。 但是出现了⼀个超内存的错误， 原来是传⼊的 k 值会⾮常⼤， dp 数组太⼤了。现在想想， 交易次数 k 最多有多⼤呢？⼀次交易由买⼊和卖出构成， ⾄少需要两天。 所以说有效的限制 k 应该不超过 n/2， 如果超过， 就没有约束作⽤了， 相当于 k = +infinity。 这种情况是之前解决过的

int maxProfit_k_any(int max_k, int[] prices) {
	int n = prices.length;
	if (max_k > n / 2)
		return maxProfit_k_inf(prices);
	int[][][] dp = new int[n][max_k + 1][2];
	for (int i = 0; i < n; i++)
		for (int k = max_k; k >= 1; k--) {
			if (i - 1 == -1) { /* 处理 base case */ }
			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];
}

C++代码（为了不重复换个写法）

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if (prices.size() < 2 || k < 1) 
            return 0;

        int N = prices.size();

        if (k >= N / 2) 
        {
            int res = 0;
            for (int i = 1; i < N; ++i) 
            {
                if (prices[i] > prices[i - 1]) 
                {
                    res += prices[i] - prices[i - 1];
                }
            }
            return res;
        }
        vector<vector<int> > dp(k + 1, vector<int>{0, INT_MIN});
        for (int i = 0; i < N; ++i) 
        {
            for (int j = k; j > 0; --j) 
            {
                dp[j][0] = max(dp[j][0], dp[j][1] + prices[i]);
                dp[j][1] = max(dp[j][1], dp[j - 1][0] - prices[i]);
            }
        }
        return dp[k][0];
    }
};

四、 最后总结

本⽂给⼤家讲了如何通过状态转移的⽅法解决复杂的问题， ⽤⼀个状态转移⽅程秒杀了 6 道股票买卖问题， 现在想想， 其实也不算难对吧？ 这已经属于动态规划问题中较困难的了。

关键就在于列举出所有可能的「状态」 ， 然后想想怎么穷举更新这些「状
态」 。 ⼀般⽤⼀个多维 dp 数组储存这些状态， 从 base case 开始向后推进，
推进到最后的状态， 就是我们想要的答案。 想想这个过程， 你是不是有点理
解「动态规划」 这个名词的意义了呢？

具体到股票买卖问题， 我们发现了三个状态， 使⽤了⼀个三维数组， ⽆⾮还是穷举 + 更新， 不过我们可以说的⾼⼤上⼀点， 这叫「三维 DP」 ， 怕不怕？