LeetCode - Best Time to Buy and Sell Stock IV

Best Time to Buy and Sell Stock IV

2015.4.17 05:27

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).

Solution:

　　The "Best Time to Buy and Sell Stock" series has been appearing in several version. Apparently this one is about dynamic programming.

　　At first I was a bit confused about the definition of "transaction" in the problem desription.

　　It was one "buy" or one "sell" that is defined as a "transaction", not one buy and one sell.

　　Thus here comes the typical two-demensional DP. Please see the code below, notice that the key idea lies in the local optimal and global optimal.

　　I haven't understood the algorithm well enough, though. Yet to think about it.

　　One thing is for sure: when k is greater than n, this problem is simplified to a greedy version.

Accepted code:

// Yet to grasp the mechanism here... DP wasn't easy.
#include <algorithm>
#include <vector>
using namespace std;

class Solution {
public:
    int maxProfit(int k, vector<int> &prices) {
        int n = prices.size();
        
        if (k >= n) {
            return easyMaxProfit(prices);
        }
        
        int i, j;
        vector<int> local, global;
        
        local.resize(n + 1, 0);
        global.resize(n + 1, 0);
        int diff;
        for (i = 1; i < n; ++i) {
            diff = prices[i] - prices[i - 1];
            for (j = k; j >= 1; --j) {
                local[j] = max(global[j - 1] + max(diff, 0), local[j] + diff);
                global[j] = max(global[j], local[j]);
            }
        }
        return global[k];
    }
private:
    int easyMaxProfit(vector<int> &prices) {
        int res;
        int i, len = prices.size();
        
        res = 0;
        for(i = 0; i < len - 1; ++i){
            if(prices[i] < prices[i + 1]){
                res += prices[i + 1] - prices[i];
            }
        }
        
        return res;
    }
};