代码世界的“拼图大师”：C++动态规划揭秘-CSDN博客

本文链接：https://blog.csdn.net/abcdeWA/article/details/147711394

代码世界的“拼图大师”：C++动态规划揭秘

文章目录

代码世界的“拼图大师”：C++动态规划揭秘

一、动态规划初印象

嘿，各位编程小伙伴！今天咱们来聊聊C++里超厉害的动态规划。这动态规划啊，就像是生活里拼拼图。你想啊，一幅巨大又复杂的拼图摆在你面前，直接上手拼那简直是无从下手。但要是把它拆分成一小块一小块的，先把容易拼的部分搞定，再慢慢把这些小部分组合起来，最后完整的拼图就大功告成啦！

动态规划也是这个道理，它就是专门对付复杂问题的。碰到一个难题，先把它拆成一个个简单的子问题，然后把这些子问题都解决了，那原来的大问题自然也就解决咯。这么一说，是不是感觉动态规划还挺亲切的呢？

二、动态规划的“秘密武器”

1. 重叠子问题：不做重复劳动

在动态规划的世界里，重叠子问题可是个常见的家伙。啥是重叠子问题呢？简单来说，就是在解决问题的过程中，有些子问题会被反复计算。就拿经典的斐波那契数列来说吧，斐波那契数列的定义是 $F (n) = F (n - 1) + F (n - 2)$ ，其中 $F (0) = 0$ ， $F (1) = 1$ 。咱们要是计算 $F (5)$ ，就得先算 $F (4)$ 和 $F (3)$ ，算 $F (4)$ 的时候又得算 $F (3)$ 和 $F (2)$ ，这里的 $F (3)$ 就被重复计算了。

要是每次都重新计算这些子问题，那可太浪费时间和精力了。动态规划就有个好办法，它会把已经计算过的子问题的结果存起来，下次再碰到同样的子问题，直接拿出来用就行，不用再重新算了。这样就能大大提高效率啦！

2. 最优子结构：小成就构筑大成功

最优子结构也是动态规划的一个重要特性。啥叫最优子结构呢？就是说一个问题的最优解可以由它的子问题的最优解组合而成。打个比方，你要在城市之间找最短路线。从城市A到城市C，中间要经过城市B，那从A到C的最短路线其实就是由从A到B的最短路线和从B到C的最短路线组合起来的。也就是说，这个大问题（找A到C的最短路线）的最优解是由子问题（找A到B和B到C的最短路线）的最优解构成的。

3. 状态转移方程：开启解题大门的钥匙

状态转移方程可以说是动态规划的核心。它就像是一把钥匙，能帮我们打开解决问题的大门。状态转移方程描述的是状态之间的转移关系，通过它我们可以从已知的状态推导出未知的状态。

以0 - 1背包问题为例，有一个容量为 $V$ 的背包，有 $n$ 个物品，每个物品有自己的重量 $w_i$ 和价值 $v_i$ ，要求在不超过背包容量的前提下，选出一些物品，使得它们的总价值最大。我们可以定义一个状态 $d p [i] [j]$ ，表示前 $i$ 个物品放入容量为 $j$ 的背包中所能获得的最大价值。那状态转移方程就是：

当 $j < w_i$ 时，也就是当前背包容量放不下第 $i$ 个物品，那么 $d p [i] [j] = d p [i - 1] [j]$ ，意思就是不选第 $i$ 个物品，最大价值和前 $i - 1$ 个物品放入容量为 $j$ 的背包时一样。
当 $j >= w_i$ 时，我们可以选择放或者不放第 $i$ 个物品，取两者中的最大值，即 $dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w_i] + v_i)$ 。

通过这个状态转移方程，我们就能一步步计算出最终的结果。

三、C++ 与动态规划的“梦幻联动”

1. 代码实现：化理论为行动

斐波那契数列

#include <iostream>
using namespace std;

// 动态规划求解斐波那契数列
int fibonacci(int n) {
    // 如果n为0，直接返回0
    if (n == 0) return 0;
    // 如果n为1，直接返回1
    if (n == 1) return 1;

    // 创建一个数组来存储中间结果
    int dp[n + 1];
    // 初始化F(0)为0
    dp[0] = 0;
    // 初始化F(1)为1
    dp[1] = 1;

    // 从2开始计算斐波那契数列
    for (int i = 2; i <= n; i++) {
        // 根据斐波那契数列的定义，F(i) = F(i - 1) + F(i - 2)
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    // 返回第n个斐波那契数
    return dp[n];
}

int main() {
    int n = 5;
    // 调用fibonacci函数计算第n个斐波那契数
    int result = fibonacci(n);
    cout << "第 " << n << " 个斐波那契数是: " << result << endl;
    return 0;
}

0 - 1背包问题

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

// 0 - 1背包问题的动态规划解法
int knapsack(int V, vector<int>& w, vector<int>& v) {
    int n = w.size();
    // 创建一个二维数组dp来存储中间结果
    vector<vector<int>> dp(n + 1, vector<int>(V + 1, 0));

    // 遍历每个物品
    for (int i = 1; i <= n; i++) {
        // 遍历每个背包容量
        for (int j = 0; j <= V; j++) {
            // 如果当前背包容量小于第i个物品的重量
            if (j < w[i - 1]) {
                // 不选第i个物品，最大价值和前i - 1个物品放入容量为j的背包时一样
                dp[i][j] = dp[i - 1][j];
            } else {
                // 可以选择放或者不放第i个物品，取两者中的最大值
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i - 1]] + v[i - 1]);
            }
        }
    }

    // 返回最终结果
    return dp[n][V];
}

int main() {
    int V = 5; // 背包容量
    vector<int> w = {2, 3}; // 物品重量
    vector<int> v = {3, 4}; // 物品价值

    // 调用knapsack函数计算最大价值
    int result = knapsack(V, w, v);
    cout << "背包能装下的最大价值是: " << result << endl;
    return 0;
}

最长公共子序列问题

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

// 最长公共子序列问题的动态规划解法
int longestCommonSubsequence(string text1, string text2) {
    int m = text1.length();
    int n = text2.length();
    // 创建一个二维数组dp来存储中间结果
    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 (text1[i - 1] == text2[j - 1]) {
                // 最长公共子序列长度加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];
}

int main() {
    string text1 = "abcde";
    string text2 = "ace";
    // 调用longestCommonSubsequence函数计算最长公共子序列的长度
    int result = longestCommonSubsequence(text1, text2);
    cout << "两个字符串的最长公共子序列长度是: " << result << endl;
    return 0;
}

2. 优化技巧：让代码飞起来

在动态规划里，优化也是很重要的。有时候，我们可以通过一些技巧来减少空间的使用。还是以0 - 1背包问题为例，上面的代码用了一个二维数组 $d p [i] [j]$ 来存储中间结果，其实我们可以把它优化成一维数组。

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

// 优化后的0 - 1背包问题的动态规划解法
int knapsackOptimized(int V, vector<int>& w, vector<int>& v) {
    int n = w.size();
    // 创建一个一维数组dp来存储中间结果
    vector<int> dp(V + 1, 0);

    // 遍历每个物品
    for (int i = 0; i < n; i++) {
        // 从后往前遍历背包容量
        for (int j = V; j >= w[i]; j--) {
            // 取放和不放第i个物品的最大值
            dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
        }
    }

    // 返回最终结果
    return dp[V];
}

int main() {
    int V = 5; // 背包容量
    vector<int> w = {2, 3}; // 物品重量
    vector<int> v = {3, 4}; // 物品价值

    // 调用knapsackOptimized函数计算最大价值
    int result = knapsackOptimized(V, w, v);
    cout << "优化后背包能装下的最大价值是: " << result << endl;
    return 0;
}