动态规划思想案例刨析-Toy模板网

这篇具有很好参考价值的文章主要介绍了动态规划思想案例刨析。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

动态规划的思想

动态规划解决问题的核心思想是“重叠子问题”和“最优子结构”。

重叠子问题：在复杂问题中，往往存在许多重复的子问题。动态规划通过避免重复计算，将子问题的解保存起来，以便在需要时直接引用，从而提高效率。通过记忆化存储或者使用动态规划表来实现。

最优子结构：如果一个问题的最优解包含了其子问题的最优解，那么我们称这个问题具有最优子结构。动态规划利用最优子结构的性质，将问题划分为一系列规模较小的子问题，通过求解子问题的最优解来得到原问题的最优解。

动态规划的应用步骤

使用动态规划解决问题一般包括以下步骤：

定义状态：明确问题的状态，即问题的子问题是什么，以及如何表示子问题的状态。状态的选择通常与问题的特性相关。
确定状态转移方程：根据问题的最优子结构，确定子问题之间的关系，即如何通过子问题的最优解来求解原问题的最优解。这个关系可以用状态转移方程来表示。
确定初始条件和边界情况：确定初始状态和边界情况，即最简单的子问题的解。
计算顺序：确定计算子问题的顺序，通常是自底向上或者自顶向下的方式。
计算最优解：根据状态转移方程和初始条件，计算子问题的最优解，并逐步计算得到原问题的最优解。

动态规划的应用案例

动态规划可以应用于各种问题领域，如：

背包问题：0-1背包问题、完全背包问题等。
最短路径问题：迪杰斯特拉算法、弗洛伊德算法等。
编辑距离问题：计算两个字符串之间的最小编辑操作次数。
斐波那契数列：通过动态规划的方式计算斐波那契数列的第n项。
矩阵链乘法：计算矩阵相乘的最优顺序。

具体代码分析
1. 背包问题（Knapsack Problem）：

背包问题是一个经典的优化问题，可以分为01背包问题和完全背包问题。这里以01背包问题为例，即每个物品只能选择放入背包一次或不放入。

1,动态规划解决01背包问题的代码示例：

public class KnapsackProblem {
    public static int knapsack(int[] weights, int[] values, int capacity) {
        int n = weights.length;
        int[][] dp = new int[n + 1][capacity + 1];

        // 初始化第一行和第一列为0，表示没有物品或容量为0时的最大价值为0
        for (int i = 0; i <= n; i++) {
            dp[i][0] = 0;
        }
        for (int j = 0; j <= capacity; j++) {
            dp[0][j] = 0;
        }

        // 动态规划求解
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= capacity; j++) {
                if (weights[i - 1] <= j) {
                    // 当前物品的重量小于等于背包容量，可以选择放入或不放入背包
                    dp[i][j] = Math.max(values[i - 1] + dp[i - 1][j - weights[i - 1]], dp[i - 1][j]);
                } else {
                    // 当前物品的重量大于背包容量，不能放入背包
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        return dp[n][capacity];
    }

    public static void main(String[] args) {
        int[] weights = {2, 3, 4, 5};
        int[] values = {3, 4, 5, 6};
        int capacity = 8;
        int maxVal = knapsack(weights, values, capacity);
        System.out.println("背包能够装下的最大价值为：" + maxVal);
    }
}

代码解释：

weights数组存储物品的重量，values数组存储物品的价值，capacity表示背包的容量。
dp是一个二维数组，dp[i][j]表示前i个物品在背包容量为j时的最大价值。
动态规划的核心思想是通过填充dp数组来逐步计算最优解。
外部两层循环用于遍历每个物品和每个背包容量。
内部的条件判断根据当前物品的重量，决定是否放入背包以获得最大价值。
最终返回dp[n][capacity]，即前n个物品在背包容量为capacity时的最大价值。
完全背包问题是一个经典的动态规划问题，它可以描述为在给定背包容量和一组物品的情况下，选择物品放入背包，使得背包中物品的总价值最大化。与0-1背包问题不同的是，完全背包问题中每个物品可以选择无限次放入背包。

2,完全背包问题的动态规划求解方法：

假设有N个物品，它们的重量分别为w[1], w[2], …, w[N]，价值分别为v[1], v[2], …, v[N]，背包的容量为C。我们定义一个二维数组dp[N+1][C+1]，其中dp[i][j]表示在前i个物品中选择，且背包容量为j时的最大总价值。

初始化dp数组中的所有元素为0。然后我们从前往后遍历物品，对于每个物品i，从容量0到C依次计算dp[i][j]的值。

对于dp[i][j]的计算，有两种情况：

不选择当前物品i：dp[i][j] = dp[i-1][j]，即背包容量为j时，前i个物品的最大总价值与前i-1个物品的最大总价值相同。
选择当前物品i：dp[i][j] = dp[i][j-w[i]] + v[i]，即背包容量为j时，考虑物品i放入背包，此时总价值为dp[i][j-w[i]]（在当前物品i的基础上减去物品i的重量w[i]，背包容量减少），再加上物品i的价值v[i]。

综合以上两种情况，dp[i][j]的最大值即为dp[i-1][j]和dp[i][j-w[i]] + v[i]的较大值。

最终，dp[N][C]即为问题的解，表示在前N个物品中选择，且背包容量为C时的最大总价值。

以下是完全背包问题的代码示例（使用Java语言）：

public class Knapsack {
    public static int knapsack(int[] weights, int[] values, int capacity) {
        int n = weights.length;
        int[][] dp = new int[n + 1][capacity + 1];

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= capacity; j++) {
                if (weights[i - 1] <= j) {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - weights[i - 1]] + values[i - 1]);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        return dp[n][capacity];
    }

    public static void main(String[] args) {
        int[] weights = {2, 3, 4, 5};
        int[] values = {3, 4, 5, 6};
        int capacity = 8;

        int maxTotalValue = knapsack(weights, values, capacity);
        System.out.println("背包中物品的最大总价值为：" + maxTotalValue);
    }
}

这个示例代码中，weights数组和values数组分别表示物品的重量和价值，capacity表示背包的容量。最后输出的maxTotalValue即为背包中物品的最大总价值。

2. 打家劫舍问题（House Robber Problem）：

打家劫舍问题是一个经典的动态规划问题，可以形象地描述为在一条街上的房屋中选择一些房屋进行盗窃，但不能同时盗窃相邻的房屋。目标是盗窃到的金额最大。

以下是用动态规划解决打家劫舍问题的代码示例：

public class HouseRobber {
    public static int rob(int[] nums) {
        int n = nums.length;
        if (n == 0) {
            return 0;
        }
        if (n == 1) {
            return nums[0];
        }

        int[] dp = new int[n];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);

        for(int i = 2; i < n; i++) {
            dp[i] = Math.max(nums[i] + dp[i - 2], dp[i - 1]);
        }

        return dp[n - 1];
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 1};
        int maxAmount = rob(nums);
        System.out.println("能够盗窃到的最大金额为：" + maxAmount);
    }
}

代码解释：

nums数组存储每个房屋中的金额。
dp数组存储从第一个房屋到当前房屋的最大金额。
初始化dp[0]为第一个房屋的金额，dp[1]为第一个和第二个房屋中金额较大的一个。
从第三个房屋开始，每次选择盗窃当前房屋和前两个房屋中金额较大的一个，将结果存入dp[i]。
最终返回dp[n - 1]，即最后一个房屋的最大金额。

3. 最长递增子序列（Longest Increasing Subsequence）：

最长递增子序列问题是要找到给定序列中的最长递增子序列的长度。以下是用动态规划解决最长递增子序列问题的代码示例：

public class LongestIncreasingSubsequence {
    public static int lengthOfLIS(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        Arrays.fill(dp, 1);

        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
        }

        int maxLength = 0;
        for (int len : dp) {
            maxLength = Math.max(maxLength, len);
        }

        return maxLength;
    }

    public static void main(String[] args) {
        int[] nums = {10, 9, 2, 5, 3, 7, 101, 18};
        int maxLength = lengthOfLIS(nums);
        System.out.println("最长递增子序列的长度为：" + maxLength);
    }
}

代码解释：

nums数组存储给定的序列。
dp数组用于记录每个位置上的最长递增子序列长度，初始值都为1。
外部两层循环用于遍历每个位置，并比较当前位置与之前位置的大小关系。
如果当前位置的值大于之前位置的值，则更新当前位置上的最长递增子序列长度为之前位置中最大长度加1。
最终返回dp数组中的最大值，即为最长递增子序列的长度。

4. 矩阵连乘积问题（Matrix Chain Multiplication）：

矩阵连乘积问题是一个经典的动态规划问题，要求找到一种最优的矩阵相乘顺序，使得整个连乘的计算量最小。以下是用动态规划解决矩阵连乘积问题的代码示例：

public class MatrixChainMultiplication {
    public static int matrixChainOrder(int[] dimensions) {
        int n = dimensions.length - 1;
        int[][] dp = new int[n][n];

        for (int len = 2; len <= n; len++) {
            for (int i = 0; i < n - len + 1; i++) {
                int j = i + len - 1;
                dp[i][j] = Integer.MAX_VALUE;

                for (int k = i; k < j; k++) {
                    int cost = dp[i][k] + dp[k + 1][j] + dimensions[i] * dimensions[k + 1] * dimensions[j + 1];
                    if (cost < dp[i][j]) {
                        dp[i][j] = cost;
                    }
                }
            }
        }

        return dp[0][n - 1];
    }

    public static void main(String[] args) {
        int[] dimensions = {10, 30, 5, 60};
        int minCost = matrixChainOrder(dimensions);
        System.out.println("最小的矩阵连乘积计算量为：" + minCost);
    }
}

代码解释：

dimensions数组存储矩阵的维度信息，如[10, 30, 5, 60]表示有三个矩阵，维度分别为10x30、30x5和5x60。
dp数组用于记录每个子问题的最小计算量。
外部两层循环用于遍历子问题的长度，从2开始逐步增加。
内部的循环用于遍历每个子问题的起始位置和结束位置，并计算当前情况的最小计算量。
在内部循环中，通过尝试不同的划分点，计算出将两个子问题相乘的计算量，并选择最小的计算量作为当前子问题的最优解。
最终返回dp[0][n - 1]，即整个矩阵连乘的最小计算量。

总结

动态规划是一种将复杂问题化繁为简的求解方法。通过将问题划分为一系列子问题，并通过求解子问题的最优解来得到原问题的最优解。动态规划的核心思想是重叠子问题和最优子结构。通过定义状态、确定状态转移方程、确定初始条件和边界情况、计算顺序以及计算最优解这几个步骤，我们可以有效地应用动态规划解决各种问题。文章来源地址https://www.toymoban.com/news/detail-796387.html

到了这里，关于动态规划思想案例刨析的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！