【leetcode】Best Time to Buy and Sell Stock IV

最新推荐文章于 2024-01-20 11:33:56 发布

原创最新推荐文章于 2024-01-20 11:33:56 发布 · 354 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode 专栏收录该内容

222 篇文章

订阅专栏

本文介绍了一种算法，用于解决给定股票价格数组中如何通过最多k次交易获得最大利润的问题。提供了三种不同的实现思路，包括状态转移方程的推导及优化方案。

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

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.

nouse[i][j]表示在i天不交易，且最多交易j次的情况下的最大获利；use[i][j]表示在i天交易，且最多交易j次的最大获利。

i对应diffs的i-1。

那么：

nouse[i][j] = max(nouse[i-1][j], use[i-1][j]);
use[i][j] = max(use[i-1][j], nouse[i-1][j-1])+diffs[i-1];

代码：

class Solution {
public:
	int maxProfit(int k, vector<int> prices) {
		vector<int> diffs;
		int profit = maxProfitNoLimits(prices, diffs);
		if(k+1 >= prices.size()) {
			return profit;
		}
		int n = prices.size();
		// for i-1
		vector<vector<int>> nouse(n, vector<int>(k+1, 0)), use(n, vector<int>(k+1, 0));

		for(int i=1; i<n; ++i) {
			for(int j=1; j<=k; ++j) {
				nouse[i][j] = max(nouse[i-1][j], use[i-1][j]);
				use[i][j] = max(use[i-1][j], nouse[i-1][j-1])+diffs[i-1];
			}
		}

		return max(use[n-1][k], nouse[n-1][k]);	
	}
    
	int maxProfitNoLimits(vector<int> &prices, vector<int>& diffs) {
        int p = 0;
        for(int i=1; i<prices.size(); ++i) {
			int diff = prices[i]-prices[i-1];
            p += (diff>0)*diff;
			diffs.push_back(diff);
        }
        return p;
    }
};

public class Solution {
int maxProfit(int k, int[] prices) {
		int n = prices.length;
		int[] diffs = new int[n]; // diffs[i] : prices[i]-prices[i-1]
		int profit = maxProfitNoLimits(prices, diffs);
		if (k + 1 >= prices.length) {
			return profit;
		}
		// for i-1
		int[][] nouse = new int[n][k + 1];
		int[][] use = new int[n][k + 1];

		for (int i = 1; i < n; ++i) {
			for (int j = 1; j <= k; ++j) {
				nouse[i][j] = Math.max(nouse[i - 1][j], use[i - 1][j]);
				use[i][j] = Math.max(use[i - 1][j], nouse[i - 1][j - 1]) + diffs[i];
			}
		}

		return Math.max(use[n - 1][k], nouse[n - 1][k]);
	}

	int maxProfitNoLimits(int[] prices, int[] diffs) {
		int p = 0;
		for (int i = 1; i < prices.length; ++i) {
			int diff = prices[i] - prices[i - 1];
			if (diff > 0) {
				p += diff;
			}
			diffs[i] = diff;
		}
		return p;
	}
}

思路2：

很多人采用local和global两个数组表示状态转移。

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

		int *global = new int[k+1];
        int *local = new int[k+1];
        
        for(int i=0; i<=k; ++i) {
            global[i] = local[i] = 0;
        }
        
        for(int i = 0; i < prices.size()-1; ++i) {
            int diff = prices[i+1] - prices[i];
            for(int j = k; j >= 1; --j) {
                local[j] = max(global[j-1] + max(diff, 0), local[j] + diff);
                global[j] = max(global[j], local[j]);
            }
        }
        
        int profit = global[k];
		delete[] global;
		delete[] local;
        return profit;
    }
    
    int maxProfitNoLimits(vector<int> &prices) {
        int p = 0;
        for(int i=1; i<prices.size(); ++i) {
            p += (prices[i]>prices[i-1])*(prices[i]-prices[i-1]);
        }
        return p;
    }
};

思路3：

对思路1改进，降低空间复杂度。

class Solution {
public:
	int maxProfit(int k, vector<int> prices) {
		vector<int> diffs;
		int profit = maxProfitNoLimits(prices, diffs);
		if(k+1 >= prices.size()) {
			return profit;
		}
		int n = prices.size();
		vector<int> nouse(k+1, 0), use(k+1, 0);

		for(int i=1; i<n; ++i) {
			for(int j=1; j<=k; ++j) {
				int ui1j = use[j], nui1j = nouse[j], nui1j1 = nouse[j-1];
				use[j] = max(ui1j, nui1j1)+diffs[i-1];
				nouse[j] = max(ui1j, nui1j);
			}
		}
		return max(use[k], nouse[k]);
	}
    
	int maxProfitNoLimits(vector<int> &prices, vector<int>& diffs) {
        int p = 0;
        for(int i=1; i<prices.size(); ++i) {
			int diff = prices[i]-prices[i-1];
            p += (diff>0)*diff;
			diffs.push_back(diff);
        }
        return p;
    }
};