[leetcode]188. Best Time to Buy and Sell Stock IV

链接：https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/description/

 

 

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 at most k transactions.

Note:
You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

Example 1:

Input: [2,4,1], k = 2
Output: 2
Explanation: Buy on day 1 (price = 2) and sell on day 2 (price = 4), profit = 4-2 = 2.

Example 2:

Input: [3,2,6,5,0,3], k = 2
Output: 7
Explanation: Buy on day 2 (price = 2) and sell on day 3 (price = 6), profit = 6-2 = 4.
             Then buy on day 5 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.

思路1：

这道题是 Best Time to Buy and Sell Stock III的扩展， Best Time to Buy and Sell Stock III最多是2次交易，这里最多是k次交易。
我们还是使用“局部最优和全局最优解法”。我们维护两种量，一个是当前到达第i天可以最多进行j次交易，最好的利润是多少（global[i][j]）；另一个是当前到达第i天可以最多进行j次交易，并且最后一次交易在当天时最好的利润是多少（local[i][j]）。下面我们来看递推式，全局变量的维护，递推式是
                       global[i][j] = max(local[i][j]，global[i - 1][j])，
也就是取当前局部最好的（local[i][j]），和过往全局最好的那个（global[i-1][j]）。因为最后一次交易如果包含当前天一定在局部最好的里面，否则一定在过往全局最优的里面。对于局部变量的维护，递推式是
                      local[i][j] = max(global[i - 1][j - 1] + max(diff，0)，local[i - 1][j] + diff)，
也就是看两个量，第一个是全局到i-1天进行j-1次交易，然后加上今天的交易，如果今天是赚钱的话（也就是前面只要j-1次交易，最后一次交易取当前天），第二个量则是取local第i-1天j次交易，然后加上今天的差值（这里因为local[i-1][j]比如包含第i-1天卖出的交易，所以现在变成第i天卖出，并不会增加交易次数，而且这里无论diff是不是大于0都一定要加上，因为否则就不满足local[i][j]必须在最后一天卖出的条件了）。
上面的算法中对于天数需要一次扫描，而每次要对交易次数进行递推式求解，所以时间复杂度是O(n*k)

 

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

		int n = prices.size();
		vector<vector<int>> global(n, vector<int>(k + 1, 0));
		vector<vector<int>> local(n, vector<int>(k + 1, 0));

		for(int i = 1; i < prices.size(); i++) {
			int diff = prices[i] - prices[i - 1];
			for(int j = 1; j <= k; j++) {
				local[i][j] = max(global[i - 1][j - 1] + max(diff, 0), local[i - 1][j] + diff);
				global[i][j] = max(local[i][j], global[i - 1][j]);
			}
		}
		return global[n - 1][k];  
    }
};

 

 

思路2：

 

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        int size=prices.size();
        if(k==0 || size==0) return 0;
        
        if(k>(size/2) && size>=2)
            k=size/2;
        
        vector<int> hold(k,INT32_MIN);
        vector<int> sold(k,0);
        for(int price : prices) {
            for(int j=0; j<k; j++) {
                hold[j] = max(hold[j], sold[j-1]-price); // hold->hold, sold->hold
                sold[j] = max(sold[j], hold[j]+price); // sold->sold, hold->sold
            }
        }
        return sold[k-1];
    }
};