LeetCode Best Time to Buy and Sell Stock III && Best Time to Buy and Sell Stock IV

LeetCode这个买股票题，个人认为是出的比较好的，一共四个问题，其中3和4都是hard，在我看来，4的难度比3还是难了不少，因为他涉及到了dp的优化

这里就稍微再提一下第一问和第二问，第一问已经有了一个dp的思想，答案是max(prices[i]-min(prices[j]))其中，j从0取到i-1，乍一看需要O(n*n)的复杂度，但是通过用一个数保存前i个price中最小的那个price就可以降复杂度到O(n)。第二问可以买卖无限次，那么通过贪心解决，只要看到相邻的两次价格，后者比前者高，那么就加上这个利润。第二问的代码等下第四问也会涉及。

到了第三问，最多可以交易2次，我曾经做过一道最大2段子序列和的题目，就是给定一串数，让你找到2段连续的数(其实1段也可以看做2段)，使这两段连续数的和最大，这题有O(n)的做法，就是枚举中间的界。由此我想到第三问的做法，其实和第一问很像，就是对于任意前i个数，我能得到最大利润(按照第一问的做法即可)，对于任意后n-i个数，我通过倒着计算，也能得到最大利润(类似第一问的做法)，然后我枚举这个i，取一个max，就是答案，复杂度就是O(n)，代码如下：

class Solution {
public:
    int maxProfit(vector<int> &prices) 
	{
       
        int n=prices.size();
        if(n==0)
            return 0;
        int min,max;
        vector<int>dp1;
        vector<int>dp2;
		int i,j;
        for(i=0;i<n;i++)
        {
        	dp1.push_back(0);
        	dp2.push_back(0);
        }
        min=prices[0];
        max=prices[n-1];
        dp1[0]=0;
        dp2[0]=0;
        for(i=1;i<n;i++)
        {
        	if(prices[i]<min)
        		min=prices[i];
        	
			dp1[i]=prices[i]-min;
			if(dp1[i]<dp1[i-1])
				dp1[i]=dp1[i-1];
        }
        for(i=n-2;i>=0;i--)
       	{
       		if(prices[i]>max)
        		max=prices[i];
 			dp2[n-i-1]=max-prices[i];
 			if(dp2[n-i-1]<dp2[n-i-2])
 				dp2[n-i-1]=dp2[n-i-2];
       	}
       	int ans=0;
       	for(i=0;i<n;i++)
       	{
			if(ans<dp1[i]+dp2[n-i-1])	
				ans=dp1[i]+dp2[n-i-1];
       	}
     	return ans;
    }	
        
};

min和max分别表示前i个数中的最小price和后i个数中的最大prices，dp1[i]表示前i个prices能获得的最大利润，dp2[i]表示后i个prices能获得的最大利润，答案就是max(dp1[i]+dp2[n-i-1]);

最难的第四问，第四问的状态转移方程还是好写的，dp[t][i]表示前i个价格最多使用t次获得的最大利润，有：

dp[t][i]=max(dp[t-1][j]+prices[i-1]-prices[j])

这里注意一点，dp的i从1开始取，但是i=0也是一个初始状态，而prices从0开始取，所以原本的prices[i]-prices[j+1]变成了prices[i-1]-prices[j],显然最后的答案是dp[k][n],我们要计算出dp这个数组最起码需要O(n*k)的时间复杂度，但是每次计算dp[t][i]我还需要枚举j，取得最大dp[t-1][j]+prices[i-1]-prices[j],所以我最初的做法是O(n*n*k),超时。

下面我把方程换一种写法：

dp[t][i]=max(dp[t-1][j]-prices[j])+prices[i-1];

每次计算dp[t][i],我需要得到max(dp[t-1][j]-prices[j])(j=0,1,2...i-1)那假如在枚举i的时候我知道了max(dp[t-1][j]-prices[j])(j=0,1,2...i-2)的值，那么我只要和dp[t-1][j-1]-prices[j-1]来个比较，取较大值就可以得到

max(dp[t-1][j]-prices[j])(j=0,1,2...i-1)，这启发我们用一个数存下这个式子，然后随着i每次更新即可。

另外再提一点的是，不要漏下状态，计算dp[t][i]的时候，他至少能等于dp[t][i-1]，而我们的状态转移方程，是不会由这个状态转移过来的，因为一次交易需要选择两次价格。

最后利用滚动数组，可以将空间优化成O(n)，关于滚动数组，这里就不多说了。

下面是代码：

int dp[2][10001];
class Solution {
public:
	int maxProfit(int k, vector<int> &prices) {
		int n = prices.size();
		if(n==0)
		    return 0;
		if (k > n / 2)
		{
			int sum = 0;
			for (int i = 1; i < n; i++){
				if (prices[i] > prices[i - 1]){
					sum += prices[i] - prices[i - 1];
				}
			}
			return sum;
		}
		memset(dp, 0, sizeof(dp));
		for (int t = 1; t <= k; t++){
			int tmp = dp[(t-1)%2][0]-prices[0];
			dp[t%2][0] = 0;
			dp[t%2][1] = 0;
			for (int i = 2; i <= n; i++){
				dp[t%2][i] = dp[t%2][i - 1];
				if (dp[t%2][i] < tmp + prices[i-1])
					dp[t%2][i] = tmp + prices[i-1];
				if (tmp < dp[(t - 1)%2][i-1] - prices[i-1 ])
					tmp = dp[(t - 1)%2][i-1] - prices[i-1 ];
			}
		}
		return dp[k%2][n];
	}
};

测试数据里应该有k很大的数据，针对这样的情况，就是用问题2的代码快速解决它。