【刷题总结】动态规划求解股票系列问题

已于 2023-04-27 10:19:21 修改
阅读量265 收藏
点赞数 1
分类专栏： 算法 文章标签： 动态规划 算法
于 2023-04-27 10:18:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56539960/article/details/130400356
版权

1. 特例讲解：解决力扣122题：买卖股票II 力扣

第 1 步：定义状态

        状态 dp[i][j] 定义如下：

        dp[i][j] 表示到下标为 i 的这一天，持股状态为 j 时，我们手上拥有的最大现金数。

注意：限定持股状态为 j 是为了方便推导状态转移方程，这样的做法满足 无后效性。

其中：

  • 第一维 i 表示下标为 i 的那一天（ 具有前缀性质，即考虑了之前天数的交易 ）；
  • 第二维 j 表示下标为 i 的那一天是持有股票，还是持有现金。这里 0 表示持有现金（cash），1 表示持有股票（stock）。

第 2 步：思考状态转移方程

  • 状态从持有现金（cash）开始，到最后一天我们关心的状态依然是持有现金（cash）；
  • 每一天状态可以转移，也可以不动。状态转移用下图表示：

说明：

  • 由于不限制交易次数，除了最后一天，每一天的状态可能不变化，也可能转移；
  • 写代码的时候，可以不用对最后一天单独处理，输出最后一天，状态为 0 的时候的值即可。

第 3 步：确定初始值

起始时：

  • 如果什么都不做，dp[0][0] = 0；
  • 如果持有股票，当前拥有的现金数是当天股价的相反数，即 dp[0][1] = -prices[i]；

第 4 步：确定输出值

        终止的时候，上面也分析了，输出 dp[len - 1][0]，因为一定有 dp[len - 1][0] > dp[len - 1][1]。

参考代码如下：

public class Solution {

    public int maxProfit(int[] prices) {
        int len = prices.length;
        if (len < 2) {
            return 0;
        }

        // cash：持有现金
        // hold：持有股票
        // 状态数组
        // 状态转移：cash → hold → cash → hold → cash → hold → cash
        int[] cash = new int[len];
        int[] hold = new int[len];

        cash[0] = 0;
        hold[0] = -prices[0];

        for (int i = 1; i < len; i++) {
            // 这两行调换顺序也是可以的
            cash[i] = Math.max(cash[i - 1], hold[i - 1] + prices[i]);
            hold[i] = Math.max(hold[i - 1], cash[i - 1] - prices[i]);
        }
        return cash[len - 1];
    }
}

考虑优化空间，采用滚动变量替换数组（“滚动数组”技巧。）

public class Solution {

    public int maxProfit(int[] prices) {
        int len = prices.length;
        if (len < 2) {
            return 0;
        }

        // cash：持有现金
        // hold：持有股票
        // 状态转移：cash → hold → cash → hold → cash → hold → cash

        int cash = 0;
        int hold = -prices[0];

        int preCash = cash;
        int preHold = hold;
        for (int i = 1; i < len; i++) {
            cash = Math.max(preCash, preHold + prices[i]);
            hold = Math.max(preHold, preCash - prices[i]);

            preCash = cash;
            preHold = hold;
        }
        return cash;
    }
}

2. 动态规划求解股票系列通解

先牢记，解题关键是 允许的最大交易次数 k 。

具体转自：力扣

符号说明：

  • n ：表示股票价格数组的长度；
  • i： 表示第 i 天（i 的取值范围是 0 到 n - 1）；
  • k： 表示允许的最大交易次数；
  • T[i][k]： 表示在第 i 天结束时，最多进行 k 次交易的情况下可以获得的最大收益。

基准条件：

        T[-1][k] = T[i][0] = 0，表示没有进行股票交易时没有收益（注意第一天对应 i = 0，因此 i = -1 表示没有股票交易）。

求解状态转移方程：

        第i天可能的操作，共有三种可能：买入、卖出、休息。

        题目中存在限制条件，规定不能同时进行多次交易，因此如果决定在第 i 天买入，在买入之前必须持有 0 份股票，如果决定在第 i 天卖出，在卖出之前必须恰好持有 1 份股票。

        持有股票的数量是隐藏因素，该因素影响第 i 天可以进行的操作，进而影响最大收益。

因此可对T[i][k] 的定义划分为两项：

    • T[i][k][0] ：在第i天结束时，最多进行k次交易，且在进行操作后持有0份股票的情况下，可获得的最大收益。
    • T[i][k][1] ：在第i天结束时，最多进行k次交易，且在进行操作后持有1份股票的情况下，可获得的最大收益。

        使用新的状态表示之后，可以得到基准情况和状态转移方程。

基准情况：

T[-1][k][0] = 0, T[-1][k][1] = -Infinity
T[i][0][0] = 0, T[i][0][1] = -Infinity

        T[-1][k][1] = T[i][0][1] = -Infinity ：在没有进行股票交易时不允许持有股票。

状态转移方程：

T[i][k][0] = max(T[i - 1][k][0], T[i - 1][k][1] + prices[i])
T[i][k][1] = max(T[i - 1][k][1], T[i - 1][k - 1][0] - prices[i])

状态转移方程解析：

        对于 T[i][k][0] ：第 i 天进行的操作只能是休息或卖出，因为在第 i 天结束时持有的股票数量是 0。

        T[i - 1][k][0] 是休息操作可得的最大收益，

        T[i - 1][k][1] + prices[i] 是卖出操作可得的最大收益。

        注意到允许的最大交易次数是不变的，因为每次交易包含两次成对的操作，买入和卖出。只有买入操作会改变允许的最大交易次数。

        对于T[i][k][1] ： 第 i 天进行的操作只能是休息或买入，因为在第 i 天结束时持有的股票数量是 1。

        T[i - 1][k][1] 是休息操作可得的最大收益，

        T[i - 1][k - 1][0] - prices[i] 是买入操作可以得到的最大收益。

        注意到允许的最大交易次数减少了一次，因为每次买入操作会使用一次交易。

        为了得到最后一天结束时的最大收益，可以遍历股票价格数组，根据状态转移方程计算 T[i][k][0] 和 T[i][k][1] 的值。最终答案是 T[n - 1][k][0]，因为结束时持有 0 份股票的收益一定大于持有 1 份股票的收益。

应用于特殊情况：

情况一：k = 1

        情况一对应的题目是「121. 买卖股票的最佳时机」

        对于情况一，每天有两个未知变量：T[i][1][0] 和 T[i][1][1]，状态转移方程如下：

T[i][1][0] = max(T[i - 1][1][0], T[i - 1][1][1] + prices[i])
T[i][1][1] = max(T[i - 1][1][1], T[i - 1][0][0] - prices[i]) = max(T[i - 1][1][1], -prices[i])

        第二个状态转移方程利用了 T[i][0][0] = 0。

        根据上述状态转移方程，可以写出时间复杂度为 O(n) 和空间复杂度为 O(n) 的解法。

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int length = prices.length;
        int[][] dp = new int[length][2];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < length; 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], -prices[i]);
        }
        return dp[length - 1][0];
    }
}

优化空间复杂度为O(1)：因为第i天的最大收益只和第i-1天的最大收益有关，故采用滚动变量替代数组

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int profit0 = 0, profit1 = -prices[0];
        int length = prices.length;
        for (int i = 1; i < length; i++) {
            profit0 = Math.max(profit0, profit1 + prices[i]);
            profit1 = Math.max(profit1, -prices[i]);
        }
        return profit0;
    }
}

情况二：k 为正无穷

        情况二对应的题目是「122. 买卖股票的最佳时机 II」。

        如果 k 为正无穷，则 k 和 k - 1 可以看成是相同的，

        因此： T[i - 1][k - 1][0] = T[i - 1][k][0] 和 T[i - 1][k - 1][1] = T[i - 1][k][1]。

        每天仍有两个未知变量：T[i][k][0] 和 T[i][k][1]，其中 k 为正无穷，状态转移方程如下：

T[i][k][0] = max(T[i - 1][k][0], T[i - 1][k][1] + prices[i])
T[i][k][1] = max(T[i - 1][k][1], T[i - 1][k - 1][0] - prices[i]) = max(T[i - 1][k][1], T[i - 1][k][0] - prices[i])

        第二个状态转移方程利用了 T[i - 1][k - 1][0] = T[i - 1][k][0]。

        根据上述状态转移方程，可以写出时间复杂度为 O(n) 和空间复杂度为 O(n) 的解法。

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int length = prices.length;
        int[][] dp = new int[length][2];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < length; 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[length - 1][0];
    }
}

优化空间复杂度为O(1):

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int profit0 = 0, profit1 = -prices[0];
        int length = prices.length;
        for (int i = 1; i < length; i++) {
            int newProfit0 = Math.max(profit0, profit1 + prices[i]);
            int newProfit1 = Math.max(profit1, profit0 - prices[i]);
            profit0 = newProfit0;
            profit1 = newProfit1;
        }
        return profit0;
    }
}

情况三：k = 2

        情况三对应的题目是「123. 买卖股票的最佳时机 III」。

        情况三和情况一相似，区别之处是，对于情况三，每天有四个未知变量：T[i][1][0]、T[i][1][1]、T[i][2][0]、T[i][2][1]，状态转移方程如下：

T[i][2][0] = max(T[i - 1][2][0], T[i - 1][2][1] + prices[i])
T[i][2][1] = max(T[i - 1][2][1], T[i - 1][1][0] - prices[i])
T[i][1][0] = max(T[i - 1][1][0], T[i - 1][1][1] + prices[i])
T[i][1][1] = max(T[i - 1][1][1], T[i - 1][0][0] - prices[i]) = max(T[i - 1][1][1], -prices[i])

        第四个状态转移方程利用了 T[i][0][0] = 0。

        根据上述状态转移方程,可写出时间复杂度为O(n) 和空间复杂度为 O(n) 的解法。

        此处只列出空间复杂度为O(1) 的解法。

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int profitOne0 = 0, profitOne1 = -prices[0], profitTwo0 = 0, profitTwo1 = -prices[0];
        int length = prices.length;
        for (int i = 1; i < length; i++) {
            profitTwo0 = Math.max(profitTwo0, profitTwo1 + prices[i]);
            profitTwo1 = Math.max(profitTwo1, profitOne0 - prices[i]);
            profitOne0 = Math.max(profitOne0, profitOne1 + prices[i]);
            profitOne1 = Math.max(profitOne1, -prices[i]);
        }
        return profitTwo0;
    }
}

情况四：k 为任意值

        情况四对应的题目是「188. 买卖股票的最佳时机 IV」。

        情况四是最通用的情况，对于每一天需要使用不同的 k 值更新所有的最大收益，对应持有 0 份股票或 1 份股票。如果 k 超过一个临界值，最大收益就不再取决于允许的最大交易次数，而是取决于股票价格数组的长度，因此可以进行优化。那么这个临界值是什么呢？

        一个有收益的交易至少需要两天（在前一天买入，在后一天卖出，前提是买入价格低于卖出价格）。如果股票价格数组的长度为 n，则有收益的交易的数量最多为 n / 2（整数除法）。因此 k 的临界值是 n / 2。如果给定的 k 不小于临界值，即 k >= n / 2，则可以将 k 扩展为正无穷，此时问题等价于情况二。

        根据状态转移方程，可以写出时间复杂度为 O(nk) 和空间复杂度为 O(nk) 的解法。

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

    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int length = prices.length;
        int[][] dp = new int[length][2];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < length; 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[length - 1][0];
    }
}

空间复杂度可以降到O(k)：

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

    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int profit0 = 0, profit1 = -prices[0];
        int length = prices.length;
        for (int i = 1; i < length; i++) {
            int newProfit0 = Math.max(profit0, profit1 + prices[i]);
            int newProfit1 = Math.max(profit1, profit0 - prices[i]);
            profit0 = newProfit0;
            profit1 = newProfit1;
        }
        return profit0;
    }
}

        如果不根据 k 的值进行优化，在 k 的值很大的时候会超出时间限制。

        对交易次数的循环使用反向循环是为了避免使用临时变量。

情况五：k 为正无穷但有冷却时间

        情况五对应的题目是「309. 最佳买卖股票时机含冷冻期」。

        由于具有相同的 k 值，因此情况五和情况二非常相似，不同之处在于情况五有「冷却时间」的限制，因此需要对状态转移方程进行一些修改。

        在有「冷却时间」的情况下，如果在第 i - 1 天卖出了股票，就不能在第 i 天买入股票。因此，如果要在第 i 天买入股票，第二个状态转移方程中就不能使用 T[i - 1][k][0]，而应该使用 T[i - 2][k][0]。

T[i][k][0] = max(T[i - 1][k][0], T[i - 1][k][1] + prices[i])
T[i][k][1] = max(T[i - 1][k][1], T[i - 2][k][0] - prices[i])

列出空间复杂度 O(1) 的解法：

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int prevProfit0 = 0, profit0 = 0, profit1 = -prices[0];
        int length = prices.length;
        for (int i = 1; i < length; i++) {
            int nextProfit0 = Math.max(profit0, profit1 + prices[i]);
            int nextProfit1 = Math.max(profit1, prevProfit0 - prices[i]);
            prevProfit0 = profit0;
            profit0 = nextProfit0;
            profit1 = nextProfit1;
        }
        return profit0;
    }
}

情况六：k 为正无穷但有手续费

        情况六对应的题目是「714. 买卖股票的最佳时机含手续费」。

        由于具有相同的 k 值，因此情况六和情况二非常相似，不同之处在于情况六有「手续费」，因此需要对状态转移方程进行一些修改。

        可选择在买入时扣除手续费或卖出时扣除手续费，手续费只需要扣除一次即可。

买入时扣除：

T[i][k][0] = max(T[i - 1][k][0], T[i - 1][k][1] + prices[i])
T[i][k][1] = max(T[i - 1][k][1], T[i - 1][k][0] - prices[i] - fee)

卖出时扣除：

T[i][k][0] = max(T[i - 1][k][0], T[i - 1][k][1] + prices[i] - fee)
T[i][k][1] = max(T[i - 1][k][1], T[i - 1][k][0] - prices[i])

列出空间复杂度为 O(1) 的解法：

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int profit0 = 0, profit1 = -prices[0] - fee;
        int length = prices.length;
        for (int i = 1; i < length; i++) {
            int newProfit0 = Math.max(profit0, profit1 + prices[i]);
            int newProfit1 = Math.max(profit1, profit0 - prices[i] - fee);
            profit0 = newProfit0;
            profit1 = newProfit1;
        }
        return profit0;
    }
}

3. 总结

        总而言之，股票问题最通用的情况由三个特征决定：当前的天数 i、允许的最大交易次数 k 、每天结束时持有的股票数。

来碗烧骨粥
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
动态规划系列：5.股票问题
qq_42935076的博客
02-28 685
leecode动态规划-股票问题汇总
力扣方法总结-----动态规划-----买卖股票的最佳时机系列题目
打工人。。
07-07 313
将每一天的状态分为dp[i][0]，dp[i][1]，dp[i][2]，dp[i][3]，dp[i][4]五种，其中dp[i][0]代表第i天什么不做时，手里的最大金钱。dp[i][1]代表第i天不持有股票（刚好代表第i天卖出，第i+1天为冷冻期），dp[i][2]代表第i天不持有股票（其中第i天一定是上一个冷冻期之后的天数），dp[i][3]代表第i天为冷冻期。将每一天的状态分为dp[i][0]和dp[i][1]两种，其中dp[i][0]代表第i天持有股票时，手里的最大金钱。所以在定义状态时要有所改变。
动态规划- 股票问题专题（详解+多例子+源码）
aseraphe的博客
04-30 1025
买股票的最佳时机-动态规划
力扣LeetCode：121. 买卖股票的最佳时机（动态规划）
m0_74242327的博客
08-07 203
在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回。设计一个算法来计算你所能获取的最大利润。在这种情况下, 没有交易完成, 所以最大利润为 0。买入这只股票，并选择在。
动态规划-投资问题
qq_63525443的博客
10-23 781
个项目如何最大效益投资之后，再决定如何投第。:将x元投入第i个项目的效益。的意思是：投给项目i的钱数。，也就是给第3个项目投3万元。，第4个项目投1万元。
动态规划----股票买卖问题（详解）
最新发布
2302_79862386的博客
05-12 1909
动态规划买卖股票的最佳时机是一个经典的算法问题。该问题的目标是在给定的股票价格数组中，找到最大的利润，即最佳的买入和卖出时间，使得买入时间早于卖出时间。
动态规划求解最长公共子序列问题
10-14
动态规划求解最长公共子序列问题 动态规划求解最长公共子序列问题 动态规划求解最长公共子序列问题 动态规划求解最长公共子序列问题
Python背包问题动态规划求解（一维和二维数组）.zip
01-21
Python背包问题动态规划求解（一维和二维数组）.zip
动态规划求解找零问题和背包问题C++代码
01-21
01背包问题动态规划，动态规划求解找零问题和背包问题C++代码
关于动态规划最短路径求解的matlab学习例子
02-01
关于动态规划最短路径求解的matlab学习例子
Java动态规划求解最长公共子序列问题.zip
11-16
最长公共子序列问题 Java动态规划求解最长公共子序列问题.zip
用动态规划方法求解投资问题
11-28
网络上都没有免费的哦，我是好不容易弄到的
动态规划 投资问题 Java代码实现
01-25
关于动态规划投资问题的Java代码实现，帮助了解具体算法的实现过程
一个方法团灭 6 道股票问题（动态规划）
键小盘的博客
06-27 2151
很多读者抱怨股票系列问题奇技淫巧太多，如果面试真的遇到这类问题，基本不会想到那些巧妙的办法，怎么办？所以本文拒绝奇技淫巧，而是稳扎稳打，只用一种通用方法解决所用问题，以不变应万变。 这篇文章用状态机的技巧来解决，可以全部提交通过。不要觉得这个名词高大上，文学词汇而已，实际上就是 DP table，看一眼就明白了。 先随便抽出一道题，看看别人的解法： int maxProfit(vector...
这种动态规划你见过吗——状态机动态规划之股票问题(中)
qq_45537774的博客
07-27 212
在本篇文章当中主要分析了另外两道题，分析这两道问题的状态机转化过程，深入学习状态机动态规划！
[LeetCode]动态规划中股票问题的通用解法
Math & Code
09-14 1939
动态规划中股票问题的通用解法 有一类动态规划的问题是给定一个股票价格序列，然后计算买卖股票所能获得的最大收益，这类问题通常有很多变种，例如只允许交易一次，允许交易多次或者增收交易税等。即问题的最大收益通常由交易的时间和允许的最大交易次数（每次交易指一次买与一次卖的一个组合）决定的。 可以用T[i][k]表示在第i天结束的时候最多经过k次交易所能获得的最大收益，另外在第i天结束的时候可以有两种状...
动态规划之股票交易问题
weixin_43276913的博客
11-19 500
动态规划_股票问题详解 动态规划之股票的买卖_简书 Table of Contents Best Time to Buy and Sell Stock I Best Time to Buy and Sell Stock II Best Time to Buy and Sell Stock III Best Time to Buy and Sell Stock IV Best Time...
【动态规划】股票买卖问题
一只禾的博客
02-12 707
只允许买卖一次：121. 买卖股票的最佳时机 - 力扣（LeetCode） (leetcode-cn.com) 允许买卖两次：123. 买卖股票的最佳时机 III - 力扣（LeetCode） (leetcode-cn.com) 允许买卖K次：188. 买卖股票的最佳时机 IV - 力扣（LeetCode） (leetcode-cn.com) 允许买卖多次，不限：122. 买卖股票的最佳时机 II - 力扣（LeetCode） (leetcode-cn.com) 考虑买卖含有手续费：714. 买卖股
动态规划系列 之 股票相关问题 (C语言刷leetcode)
Eureka1024的博客
10-15 1031
2020-10-15 “知识的诅咒”：一旦我们知道某样东西，我们就会发现很难想象不知道它的时候会是什么样子。 一、概述 leetcode中的股票相关的题目如下： 打开看很容易就知道是求最大收益，由于是求最值，很容易就想到要使用动态规划。 其实动态规划就是使用了穷举，但是因为这类问题存在「重叠⼦问题」，可以使用DP table来优 化穷举过程，记录过计算的结果，避免不必要的计算。 动态规划三要素 重叠⼦问题（如果暴力解决，存在大量运算，可以使用备忘录（DP table）来解决） 最优⼦结构 要符.
动态规划求解约束优化问题
09-21
动态规划是一种用于求解优化问题的算法。它通过将一个大问题分解为一系列子问题，并利用子问题的最优解来求解整体问题的最优解。在求解约束优化问题时，可以使用动态规划算法进行求解。 具体来说，动态规划算法可以按照以下步骤进行求解约束优化问题： 1. 定义状态：将问题划分为若干个子问题，并定义状态变量，表示子问题的解或状态。 2. 确定状态转移方程：根据子问题之间的关系，确定状态转移方程，表示子问题之间的转移和递推关系。 3. 初始化边界条件：确定边界条件，即最小规模的子问题的解。 4. 递推求解：根据状态转移方程，从边界条件出发，逐步求解出更大规模的子问题的解，直到求解出整个问题的最优解。 在动态规划求解约束优化问题时，需要注意以下几点： 1. 状态的定义：需要根据问题的特点，合理选择状态变量，并确保状态之间的转移关系满足问题的约束条件。 2. 状态转移方程的确定：需要分析子问题之间的关系，确定状态之间的转移方程，确保转移过程中不违反约束条件。 3. 边界条件的初始化：需要找到最小规模的子问题，并确定其解或边界条件，作为递推的起点。 4. 求解过程的优化：可以通过剪枝、记忆化搜索等方法对递推过程进行优化，提高算法的效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值