动态规划：从暴力递归到多维优化的算法进化论（C++实现）-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_80215285/article/details/146464504

动态规划：从暴力递归到多维优化的算法进化论

一、动态规划的本质突破

动态规划（Dynamic Programming）不是简单的递归优化，而是计算思维范式的革命性转变。其核心价值在于通过状态定义和决策过程形式化，将指数复杂度问题转化为多项式复杂度。本文将揭示动态规划的四个认知层级，并提供六大领域的深度实践方案。

二、动态规划四维认知体系

1. 状态空间建模

// 经典01背包问题状态定义
vector<vector<int>> dp(n+1, vector<int>(W+1, 0)); 
// dp[i][w] 表示前i个物品在容量w下的最大价值

2. 状态转移方程推导

dp[i][w] = max(dp[i-1][w], dp[i-1][w-weights[i-1]] + values[i-1]);

3. 计算顺序设计

正序/逆序选择
维度优先级规划

4. 空间复杂度优化

// 滚动数组优化
vector<int> dp(W+1, 0);
for(int i=1; i<=n; ++i){
    for(int w=W; w>=weights[i-1]; --w){
        dp[w] = max(dp[w], dp[w-weights[i-1]] + values[i-1]);
    }
}

三、六大经典问题解剖

问题1：编辑距离（LeetCode 72）

int minDistance(string word1, string word2) {
    int m = word1.size(), n = word2.size();
    vector<vector<int>> dp(m+1, vector<int>(n+1, 0));
    
    for(int i=0; i<=m; ++i) dp[i][0] = i;
    for(int j=0; j<=n; ++j) dp[0][j] = j;
    
    for(int i=1; i<=m; ++i){
        for(int j=1; j<=n; ++j){
            if(word1[i-1] == word2[j-1]){
                dp[i][j] = dp[i-1][j-1];
            } else {
                dp[i][j] = min({dp[i-1][j], dp[i][j-1], dp[i-1][j-1]}) + 1;
            }
        }
    }
    return dp[m][n];
}

复杂度：

时间复杂度：O(mn)
空间复杂度：O(mn) → 可优化至O(n)

问题2：股票买卖（LeetCode 188）

int maxProfit(int k, vector<int>& prices) {
    int n = prices.size();
    if(n < 2) return 0;
    
    vector<vector<int>> hold(n, vector<int>(k+1, INT_MIN));
    vector<vector<int>> sold(n, vector<int>(k+1, 0));
    
    hold[0][0] = -prices[0];
    for(int i=1; i<n; ++i){
        for(int j=0; j<=k; ++j){
            hold[i][j] = max(hold[i-1][j], (j>0 ? sold[i-1][j-1] : INT_MIN) - prices[i]);
            sold[i][j] = max(sold[i-1][j], hold[i-1][j] + prices[i]);
        }
    }
    
    return *max_element(sold[n-1].begin(), sold[n-1].end());
}

优化点：

状态机建模
交易次数维度压缩

四、动态规划优化五重奏

1. 状态压缩技术

// 最长公共子序列空间优化
int LCS(string s1, string s2){
    vector<int> dp(s2.size()+1, 0);
    for(int i=1; i<=s1.size(); ++i){
        int prev = 0;
        for(int j=1; j<=s2.size(); ++j){
            int temp = dp[j];
            if(s1[i-1] == s2[j-1]){
                dp[j] = prev + 1;
            } else {
                dp[j] = max(dp[j], dp[j-1]);
            }
            prev = temp;
        }
    }
    return dp[s2.size()];
}

2. 决策单调性优化

适用于区间DP类问题，可将复杂度从O(n³)降至O(n²)

五、动态规划思维训练场

问题类型	训练重点	推荐题目
线性DP	状态维度设计	LeetCode 53, 300
区间DP	决策点选择策略	LeetCode 312, 516
树形DP	后序遍历实现	LeetCode 337, 124
状态压缩DP	位运算技巧	LeetCode 464, 691
概率DP	期望值计算	LeetCode 688, 837
数位DP	高位到低位决策	LeetCode 233, 902

六、动态规划调试方法论

1. 状态转移追踪

void printDP(const vector<vector<int>>& dp){
    for(auto& row : dp){
        for(int val : row) cout << setw(3) << val;
        cout << endl;
    }
    cout << "----------------\n";
}

2. 逆向路径重建

vector<int> findPath(const vector<vector<int>>& dp){
    vector<int> path;
    int i = dp.size()-1, j = dp[0].size()-1;
    while(i > 0 && j > 0){
        if(dp[i][j] == dp[i-1][j-1] + 1){
            path.push_back(i-1);
            --i, --j;
        } else if(dp[i][j] == dp[i-1][j]){
            --i;
        } else {
            --j;
        }
    }
    reverse(path.begin(), path.end());
    return path;
}

七、复杂度控制矩阵

问题规模	状态维度	可解性	优化策略
n ≤ 20	O(2ⁿ)	直接暴力枚举	状态压缩DP
n ≤ 100	O(n³)	需优化常数	决策单调性/四边形不等式
n ≤ 1e4	O(n²)	需空间优化	滚动数组/降维打击
n ≤ 1e5	O(n)	需线性递推设计	斜率优化/单调队列