动～～～～～态de规划——c++中的的动态规划-CSDN博客

本文链接：https://blog.csdn.net/imlarry0616/article/details/149075795

动态规划（Dynamic Programming, DP）是一种通过将复杂问题分解为重叠子问题，并存储子问题解以避免重复计算的高效算法设计方法。在 C++ 中，动态规划凭借其空间和时间上的优化特性，被广泛应用于各类问题求解。

一、动态规划的核心思想

动态规划的有效性基于两个关键性质：

最优子结构：问题的最优解包含子问题的最优解
重叠子问题：子问题会被重复计算多次

其核心思想是 "记忆化"，即通过存储中间结果来避免重复计算，通常有两种实现方式：

自顶向下（记忆化搜索）：递归 + 缓存
自底向上（递推）：迭代 + 表格

二、动态规划的基本步骤

定义状态（通常用dp[i]表示与前i个元素相关的解）
推导状态转移方程
确定初始条件
规划计算顺序（自底向上时）
提取最终结果

三、C++ 中动态规划的经典实现

下面通过几个经典案例展示 C++ 动态规划的实现：

1. 斐波那契数列（Fibonacci）

问题：计算第 n 个斐波那契数
状态定义：dp[i]表示第 i 个斐波那契数
状态转移：dp[i] = dp[i-1] + dp[i-2]
初始条件：dp[0]=0, dp[1]=1

cpp

// 方法1：朴素递归（时间复杂度O(2^n)，存在大量重复计算）
long long fibRecursive(int n) {
    if (n <= 1) return n;
    return fibRecursive(n-1) + fibRecursive(n-2);
}

// 方法2：记忆化搜索（自顶向下，时间复杂度O(n)）
long long fibMemo(int n, vector<long long>& memo) {
    if (n <= 1) return n;
    // 若已计算过，直接返回缓存结果
    if (memo[n] != -1) return memo[n];
    return memo[n] = fibMemo(n-1, memo) + fibMemo(n-2, memo);
}

// 方法3：递推（自底向上，时间复杂度O(n)，空间复杂度O(n)）
long long fibDP(int n) {
    if (n <= 1) return n;
    vector<long long> 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];
}

// 方法4：空间优化递推（空间复杂度O(1)）
long long fibDPOptimized(int n) {
    if (n <= 1) return n;
    long long a = 0, b = 1, c;
    for (int i = 2; i <= n; i++) {
        c = a + b;
        a = b;
        b = c;
    }
    return b;
}

2. 背包问题（0-1 Knapsack）

问题：有 n 个物品，每个物品有重量w[i]和价值v[i]，背包容量为 W，求能装入的最大价值
状态定义：dp[i][j]表示前 i 个物品放入容量为 j 的背包的最大价值
状态转移：dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i-1]] + v[i-1])（选或不选第 i 个物品）
初始条件：dp[0][j]=0, dp[i][0]=0

cpp

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

// 二维数组实现（时间复杂度O(n*W)，空间复杂度O(n*W)）
int knapsack2D(vector<int>& weights, vector<int>& values, int W) {
    int n = weights.size();
    vector<vector<int>> dp(n+1, vector<int>(W+1, 0));
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= W; j++) {
            if (weights[i-1] <= j) { // 能装入第i个物品
                // 不选第i个物品 vs 选第i个物品
                dp[i][j] = max(dp[i-1][j], dp[i-1][j-weights[i-1]] + values[i-1]);
            } else { // 不能装入第i个物品
                dp[i][j] = dp[i-1][j];
            }
        }
    }
    return dp[n][W];
}

// 一维数组优化（空间复杂度O(W)）
int knapsack1D(vector<int>& weights, vector<int>& values, int W) {
    int n = weights.size();
    vector<int> dp(W+1, 0);
    
    for (int i = 0; i < n; i++) {
        // 逆序遍历避免重复使用当前物品
        for (int j = W; j >= weights[i]; j--) {
            dp[j] = max(dp[j], dp[j-weights[i]] + values[i]);
        }
    }
    return dp[W];
}

int main() {
    vector<int> weights = {2, 3, 4, 5};
    vector<int> values = {3, 4, 5, 6};
    int W = 8;
    cout << "二维DP最大价值: " << knapsack2D(weights, values, W) << endl;
    cout << "一维DP最大价值: " << knapsack1D(weights, values, W) << endl;
    return 0;
}

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

问题：求两个字符串的最长公共子序列长度
状态定义：dp[i][j]表示字符串 A 前 i 个字符和字符串 B 前 j 个字符的 LCS 长度
状态转移：

若A[i-1] == B[j-1]，则dp[i][j] = dp[i-1][j-1] + 1
否则，dp[i][j] = max(dp[i-1][j], dp[i][j-1])
初始条件：dp[0][j]=0, dp[i][0]=0

cpp

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

// 二维数组实现
int lcs(string& text1, string& text2) {
    int m = text1.length();
    int n = text2.length();
    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]) {
                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];
}

// 打印LCS具体内容
string printLCS(string& text1, string& text2) {
    int m = text1.length();
    int n = text2.length();
    vector<vector<int>> dp(m+1, vector<int>(n+1, 0));
    
    // 计算DP表
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (text1[i-1] == text2[j-1]) {
                dp[i][j] = dp[i-1][j-1] + 1;
            } else {
                dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
            }
        }
    }
    
    // 回溯构建LCS
    string lcs;
    int i = m, j = n;
    while (i > 0 && j > 0) {
        if (text1[i-1] == text2[j-1]) {
            lcs += text1[i-1];
            i--; j--;
        } else if (dp[i-1][j] > dp[i][j-1]) {
            i--;
        } else {
            j--;
        }
    }
    reverse(lcs.begin(), lcs.end()); // 反转得到正确顺序
    return lcs;
}

int main() {
    string text1 = "ABCBDAB";
    string text2 = "BDCAB";
    cout << "LCS长度: " << lcs(text1, text2) << endl;
    cout << "LCS内容: " << printLCS(text1, text2) << endl;
    return 0;
}

四、动态规划的优化技巧

空间优化
- 使用一维数组替代二维数组（如 0-1 背包的一维优化）
- 仅保留必要的历史状态（如斐波那契数列的 O (1) 空间解法）
状态定义优化
- 重新定义更简洁的状态（如将二维状态压缩为一维）
- 引入辅助状态简化转移方程
递推顺序优化
- 合理规划计算顺序，确保状态转移时依赖的子问题已求解
- 利用分治思想减少重复计算（如矩阵快速幂优化线性 DP）

五、动态规划的典型应用场景

字符串处理：编辑距离、最长回文子串、正则表达式匹配
数组问题：最大子序和、打家劫舍、跳跃游戏
组合数学：不同路径、整数划分、子集和问题
图论问题：最短路径（如 Floyd-Warshall 算法）、旅行商问题
博弈论：石子游戏、Nim 游戏变种

六、动态规划与其他算法的对比

算法类型	核心思想	时间复杂度	适用场景
动态规划	记忆化子问题解	通常 O (n²)~O (n³)	有重叠子问题和最优子结构
贪心算法	局部最优推全局最优	通常 O (n log n)	无后效性的问题
分治算法	分解为独立子问题	通常 O (n log n)	子问题相互独立
回溯算法	穷举所有可能解	通常 O (2ⁿ)	解空间为树状结构的问题