C++-算法-动态规划_c++动态规划算法-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_73139914/article/details/143085695

动态规划（Dynamic Programming，简称 DP）是一种解决复杂问题的方法，它通过将问题分解为较小的子问题来简化处理。这种方法特别适用于那些可以被分解为重叠子问题和具有最优子结构性质的问题。本文将深入探讨动态规划的概念、基本方法以及在 C++ 中如何实现动态规划算法。

一、动态规划的基础概念

在讨论动态规划之前，了解两个重要的术语是必要的：

重叠子问题：当一个问题可以被分解成重复求解同一子问题时，这个问题就被称为有重叠子问题。例如，计算 Fibonacci 数列的第 n 项就是一个典型的重叠子问题。
最优子结构：最优子结构性质意味着一个问题的最优解可以通过其子问题的最优解来构造。比如，在背包问题中，如果你知道了不同重量和价值物品的组合的最优解，就可以得出某个重量限制下背包的最优解。

二、动态规划的基本步骤

在应用动态规划时，通常可以遵循以下几个步骤：

定义状态：明确状态是什么，通常是一种能够描述当前状态的信息。
状态转移方程：建立状态之间的关系，即如何通过已知状态来推导出其他状态。
初始化：根据问题的特定条件初始化状态值。
计算顺序：确保在计算状态时，所有依赖的状态都已计算完毕。
输出结果：最终得到的状态值，即为所求解的问题的结果。

三、动态规划的应用实例

1. Fibonacci 数列

下面是一个经典的 Fibonacci 数列问题，要求计算第 n 项的值。通过动态规划来解决，避免了重复计算。

递归解法（暴力解法）：

int fib(int n) {
    if (n <= 1)
        return n;
    return fib(n - 1) + fib(n - 2);
}

动态规划解法：

int fib(int n) {
    if (n <= 1) return n;
    
    vector<int> dp(n + 1);
    dp[0] = 0;
    dp[1] = 1;
    
    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    
    return dp[n];
}

2. 最长公共子序列（LCS）

给定两个字符串，求它们的最长公共子序列的长度。我们可以使用动态规划来解决这个问题。

状态定义：dp[i][j] 表示第一个字符串的前 i 个字符和第二个字符串的前 j 个字符的最长公共子序列的长度。

状态转移方程：

如果 s1[i-1] == s2[j-1]，则 dp[i][j] = dp[i-1][j-1] + 1。
否则，dp[i][j] = max(dp[i-1][j], dp[i][j-1])。

C++ 实现：

#include <vector>
#include <string>
#include <algorithm>
using namespace std;

int longestCommonSubsequence(string s1, string s2) {
    int m = s1.size(), n = s2.size();
    vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
    
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (s1[i - 1] == s2[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            } else {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }
    
    return dp[m][n];
}

3. 0-1 背包问题

在 0-1 背包问题中，我们给定一个容量为 W 的背包和 n 个物品，每个物品有一个重量和价值，目标是尽可能高地填满背包的价值。

状态定义：dp[i][w] 表示前 i 个物品在总重量不超过 w 的情况下能够获得的最大价值。

状态转移方程：

如果不选择第 i 个物品：dp[i][w] = dp[i-1][w]
如果选择第 i 个物品：dp[i][w] = dp[i-1][w-weight[i]] + value[i]（前提是 w >= weight[i]）

C++ 实现：

#include <vector>
#include <algorithm>
using namespace std;

int knapsack(int W, vector<int>& weights, vector<int>& values) {
    int n = weights.size();
    vector<vector<int>> dp(n + 1, vector<int>(W + 1, 0));
    
    for (int i = 1; i <= n; i++) {
        for (int w = 0; w <= W; w++) {
            dp[i][w] = dp[i - 1][w]; // 不选择第 i 个物品
            if (weights[i - 1] <= w) { // 选择第 i 个物品
                dp[i][w] = max(dp[i][w], dp[i - 1][w - weights[i - 1]] + values[i - 1]);
            }
        }
    }
    
    return dp[n][W];
}