动态规划之股票问题

最新推荐文章于 2024-10-10 22:59:02 发布

关于废人张

最新推荐文章于 2024-10-10 22:59:02 发布

阅读量33

点赞数

文章标签：动态规划算法

本文链接：https://blog.csdn.net/m0_51569915/article/details/134872039

版权

文章讨论了如何通过动态规划算法解决股票买卖问题，包括计算在考虑手续费和冷冻期的情况下，找到获取最大利润的买卖时机。提供了多个版本的解决方案，针对不同情况如单次买卖、多次买卖及包含手续费等因素进行优化。

摘要由CSDN通过智能技术生成

股票问题

文章目录

股票问题

1、121. 买卖股票的最佳时机

class Solution {
    public int maxProfit(int[] prices) {
        int ans = 0,n = prices.length,temp = 0;
        for (int i = 1 ; i < n ; i ++) {
            temp = Math.max(prices[i] - prices[i - 1] + temp,0);
            ans = Math.max(ans,temp);
        }
        return ans;
    }
}

2、122. 买卖股票的最佳时机 II

class Solution {
    /**
    动态规划,当天状态有两种:一买入，二，卖出
     */
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n][2];
        dp[0][0] = - prices[0];//0标识买入
        dp[0][1] = 0;//卖出
        for (int i = 1 ; i < n ; i ++) {
            dp[i][0] = Math.max(dp[i - 1][0],dp[i - 1][1] - prices[i]);//必须从卖出状态过来
            dp[i][1] = Math.max(dp[i - 1][1],dp[i - 1][0] + prices[i]);//卖出状态，可以是从之前的买入状态或者卖出状态而来
        }
        return dp[n - 1][1];//最后一个的卖出状态即时最优
    }
}

3、123. 买卖股票的最佳时机 III

class Solution {
    /**
    判断每一天的状态有哪些?
    //0.未曾持股 1.第一次持股 2.第一次卖出 3.第二次持股 4.第二次卖出 
    判断转移:
    0只能转移到1，1只能转移到2,2只能转移到3,
     */
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n][4];
        dp[0][0] = -prices[0];
        dp[0][2] = -prices[0];
        for (int i = 1 ;i < n ; i ++) {
            dp[i][0] = Math.max( - prices[i],dp[i - 1][0]);//第一次买股
            dp[i][1] = Math.max(dp[i - 1][0] + prices[i],dp[i - 1][1]);//第一次卖股
            dp[i][2] = Math.max(dp[i - 1][1] - prices[i],dp[i - 1][2]);//第二次买股
            dp[i][3] = Math.max(dp[i - 1][2] + prices[i],dp[i - 1][3]);//第二次卖股
        }
        return dp[n - 1][3];
    }
}

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[] dp = new int[4];
        dp[0] = -prices[0];
        dp[2] = -prices[0];
        for (int i = 1 ;i < n ; i ++) {
            int dn = 0,d0 = dp[0],d1 = dp[1],d2 = dp[2];
            dp[0] = Math.max(dn - prices[i],dp[0]);//第一次买股
            dp[1] = Math.max(d0 + prices[i],dp[1]);//第一次卖股
            dp[2] = Math.max(d1 - prices[i],dp[2]);//第二次买股
            dp[3] = Math.max(d2 + prices[i],dp[3]);//第二次卖股
        }
        return dp[3];
    }
}

4、188. 买卖股票的最佳时机 IV

这题与上面的空间优化版类似，将k改为2，就是上题解法

class Solution {
    public int maxProfit(int k,int[] prices) {
        int n = prices.length;
        int[] dp = new int[2 * k + 1];//存在2k + 1种状态
        for (int i = 0 ; i < k ; i ++) dp[2 * i + 1] = -prices[0];
        for (int i = 1 ;i < n ; i ++) {
            //备份dp数组
            int[] td = new int[2 * k + 1];
            for (int j = 1 ; j <= 2 * k ; j ++) td[j] = dp[j];
            for (int j = 1 ; j <= 2 * k ; j ++) {
                if (j % 2 == 1) dp[j] = Math.max(td[j - 1] - prices[i],td[j]);
                else dp[j] = Math.max(td[j - 1] + prices[i],td[j]);
            }
        }
        return dp[2 * k];
    }
}

5、309. 最佳买卖股票时机含冷冻期

class Solution {
    public int maxProfit(int[] prices) {
        if (prices.length == 0) return 0;
        int n = prices.length;
        // f[i][0]: 手上持有股票的最大收益
        // f[i][1]: 手上不持有股票，并且处于冷冻期中的累计最大收益
        // f[i][2]: 手上不持有股票，并且不在冷冻期中的累计最大收益
        int[][] dp = new int[n][3];
        dp[0][0] = -prices[0];
        for (int i = 1; i < n; i ++) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][2] - prices[i]);
            dp[i][1] = dp[i - 1][0] + prices[i];
            dp[i][2] = Math.max(dp[i - 1][1], dp[i - 1][2]);
        }
        return Math.max(dp[n - 1][1], dp[n - 1][2]);
    }
}

6、714. 买卖股票的最佳时机含手续费

class Solution {
    /**
    动态规划,当天状态有两种:一买入，二，卖出
     */
    public int maxProfit(int[] prices,int fee) {
        int n = prices.length;
        int[][] dp = new int[n][2];
        dp[0][0] = - prices[0];//0标识买入
        dp[0][1] = 0;//卖出
        for (int i = 1 ; i < n ; i ++) {
            dp[i][0] = Math.max(dp[i - 1][0],dp[i - 1][1] - prices[i]);//必须从卖出状态过来
            dp[i][1] = Math.max(dp[i - 1][1],dp[i - 1][0] + prices[i] - fee);//卖出状态，可以是从之前的买入状态或者卖出状态而来
        }
        return dp[n - 1][1];//最后一个的卖出状态即时最优
    }
}

class Solution {
    /**
    动态规划,当天状态有两种:一买入，二，卖出
     */
    public int maxProfit(int[] prices,int fee) {
        int n = prices.length;
        int[][] dp = new int[n][2];
        dp[0][0] = - prices[0] - fee;//0标识买入
        dp[0][1] = 0;//卖出
        for (int i = 1 ; i < n ; i ++) {
            dp[i][0] = Math.max(dp[i - 1][0],dp[i - 1][1] - prices[i] - fee);//必须从卖出状态过来
            dp[i][1] = Math.max(dp[i - 1][1],dp[i - 1][0] + prices[i]);//卖出状态，可以是从之前的买入状态或者卖出状态而来
        }
        return dp[n - 1][1];//最后一个的卖出状态即时最优
    }
}