188. Best Time to Buy and Sell Stock IV

最新推荐文章于 2025-03-06 00:40:51 发布

原创最新推荐文章于 2025-03-06 00:40:51 发布 · 227 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了一种使用动态规划解决股票买卖问题的方法，旨在通过有限次交易获取最大利润。讨论了不同交易次数下的状态转移方程，并给出了两种优化方案来降低时间复杂度。

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

Using DP

int[][] dp =new int[k + 1][prices.length];

dp[i][j]表示前J天进行I次交易的利润。最后的答案应该是dp[k][prices.length - 1]

初始化：只有一天时无论是否交易均无利润 dp[i][0] = 0

0次交易无论多少天均无利润 dp[0][j] = 0；

状态转移 dp[i][j]

1.假如不交易，为前一天的利润，利润为dp[i][j-1]；

2. 假如卖出，假设是在第M天买入的

利润为prices[i] - prices[m] + dp[i - 1][m] m from (0,j-1)

取一和二中较大的利润

Code：

public class Solution {
    public int maxProfit(int k, int[] prices) {
        int[][] dp = new int[k + 1][prices.length];
        //dp[i][j] = dp[i][j - 1] 
        //            (price[j] - price[m]) + dp[i - 1][m];
        
        for(int i = 1 ; i <= k; i++){
            for(int j = 1 ; j < prices.length; j++){
                dp[i][j] = dp[i][j-1];
                for(int m = 0; m < j; m++){
                    dp[i][j] = Math.max(dp[i][j],prices[j] - prices[m] + dp[i - 1][m]);
                }
            }
        }
        return dp[k][prices.length - 1];
    }
}

时间复杂度 O(k * n * n) k为交易次数，n为天数

进行优化

状态转移 dp[i][j]

1.假如不交易，为前一天的利润，利润为dp[i][j-1]；

2. 假如卖出，假设是在第M天买入的

利润为prices[i] - prices[m] + dp[i - 1][m] m from (0,j-1)

在上述2中不需要回溯遍历m 只需记录- prices[m] + dp[i - 1][m] 中的最大值并更新即可

code：

 public int maxProfit(int k, int[] prices) {
        //k = Math.min(k,prices.length/2 +1);
        if(k == 0 || prices.length <= 1) return 0;
        
        //dp[i][j] = dp[i][j - 1] 
        //            price[j] - price[m] + dp[i - 1][m];
        //            price[j] + maxDiff
        //            maxDiff = Math.max(maxDiff,dp[i - 1][j] - prices[j])
        int n = prices.length;
	int[][] dp = new int[k + 1][prices.length];
        for(int i = 1 ; i <= k; i++){
            int maxDiff = dp[i - 1][0] - prices[0];
            for(int j = 1 ; j < n; j++){
                dp[i][j] = Math.max(dp[i][j-1], prices[j] + maxDiff);
                maxDiff = Math.max(maxDiff,dp[i - 1][j] - prices[j]);
            }
        }
        return dp[k][prices.length - 1];
    }

为了避免K过大，进行优化，K最多只能是天数的一半，若是K超过了天数的一半可以用

线性的方法求出最大利润，加入如下代码

if (k >=  n/2) {
    		int maxPro = 0;
    		for (int i = 1; i < n; i++) {
    			if (prices[i] > prices[i-1])
    				maxPro += prices[i] - prices[i-1];
    		}
    		return maxPro;
    	}

可以继续对空间进行优化，k 可以减小为 2