动态规划：从入门到精通

本文全章节一共一万七千多字，详细介绍动态规划基础与进阶技巧，全篇以代码为主，认真读完理解，你对动态规划的理解一定会有一个质的飞跃。

一、动态规划简介:

动态规划（Dynamic Programming，简称DP） 是一种通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。它的核心思想是：将复杂问题分解成子问题，保存子问题的解，避免重复计算。

动态规划本质上是一种用空间换时间的算法思想：

• 时间优化：避免重复计算相同的子问题
• 空间代价：需要额外的存储空间来保存子问题的解

动态规划 vs 其他算法思想

算法思想	特点	适用场景	时间复杂度
暴力递归	直观，但有重复计算	小规模问题	指数级
分治算法	分解独立子问题	子问题无重叠	通常O(nlogn)
贪心算法	局部最优选择	具有贪心选择性质	通常O(n)或O(nlogn)
动态规划	保存子问题解	有重叠子问题和最优子结构	通常O(n²)或O(n³)

动态规划的适用条件,动态规划能够解决的问题必须具备以下两个特征:

1.1 最优子结构（Optimal Substructure）

问题的最优解包含其子问题的最优解。

// 示例：最短路径问题
// 如果A到C的最短路径是A->B->C，那么B到C的路径也必须是B到C的最短路径

1.2 重叠子问题（Overlapping Subproblems）

在用递归算法自顶向下求解时，每次产生的子问题并不总是新问题，有些子问题会被重复计算多次。

// 斐波那契数列的递归实现中，f(n-1)和f(n-2)会被重复计算
int fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n-1) + fibonacci(n-2); // 大量重复计算
}

1.3 动态规划的设计步骤:

步骤1：状态定义

确定用什么变量来表示子问题的解。

步骤2：状态转移方程

找出状态之间的递推关系。

步骤3：初始条件和边界处理

确定初始状态的值。

步骤4：确定计算顺序

确保计算每个状态时，所依赖的状态都已经计算出来。

二、经典入门案例

案例1：斐波那契数列

问题描述：计算斐波那契数列的第n项，其中F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)。

方法1：暴力递归（指数时间复杂度）

#include <iostream>
#include <chrono>

// 暴力递归实现（效率极低）
long long fibonacciRecursive(int n) {
    if (n <= 1) return n;
    return fibonacciRecursive(n - 1) + fibonacciRecursive(n - 2);
}

时间复杂度 ：O(2^n)
空间复杂度：O(n)（递归栈空间）

方法2：自顶向下的记忆化搜索

#include <vector>
#include <unordered_map>

class FibonacciMemo {
private:
    std::unordered_map<int, long long> memo;
    
public:
    long long fibonacci(int n) {
        // 基础情况
        if (n <= 1) return n;
        
        // 检查是否已经计算过
        if (memo.find(n) != memo.end()) {
            return memo[n];
        }
        
        // 计算并存储结果
        memo[n] = fibonacci(n - 1) + fibonacci(n - 2);
        return memo[n];
    }
};

时间复杂度 ：O(n)
空间复杂度：O(n)

方法3：自底向上的动态规划

class FibonacciDP {
public:
    // 使用数组存储
    long long fibonacciArray(int n) {
        if (n <= 1) return n;
        
        std::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];
    }
    
    // 空间优化版本
    long long fibonacciOptimized(int n) {
        if (n <= 1) return n;
        
        long long prev2 = 0, prev1 = 1;
        long long current;
        
        for (int i = 2; i <= n; i++) {
            current = prev1 + prev2;
            prev2 = prev1;
            prev1 = current;
        }
        
        return current;
    }
};

时间复杂度 ：O(n)
空间复杂度：O(1)

案例2：爬楼梯问题

问题描述：假设你正在爬楼梯。需要n阶你才能到达楼顶。每次你可以爬1或2个台阶。你有多少种不同的方法可以爬到楼顶呢？

分析过程：

1. 状态定义 ：dp[i] 表示爬到第i级台阶的方法数
2. 状态转移方程 ：dp[i] = dp[i-1] + dp[i-2]
   • 要到达第i级台阶，可以从第i-1级台阶爬1步，或从第i-2级台阶爬2步
3. 初始条件 ：dp[1] = 1, dp[2] = 2

代码实现：

#include <iostream>
#include <vector>

class ClimbingStairs {
public:
    // 基础DP版本
    int climbStairs(int n) {
        if (n <= 2) return n;
        
        std::vector<int> dp(n + 1);
        dp[1] = 1;
        dp[2] = 2;
        
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        
        return dp[n];
    }
    
    // 空间优化版本
    int climbStairsOptimized(int n) {
        if (n <= 2) return n;
        
        int prev2 = 1, prev1 = 2;
        int current;
        
        for (int i = 3; i <= n; i++) {
            current = prev1 + prev2;
            prev2 = prev1;
            prev1 = current;
        }
        
        return current;
    }
    
    // 扩展版本：每次可以爬1到k个台阶
    int climbStairsK(int n, int k) {
        std::vector<int> dp(n + 1, 0);
        dp[0] = 1; // 0级台阶有1种方法（不爬）
        
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= k && j <= i; j++) {
                dp[i] += dp[i - j];
            }
        }
        
        return dp[n];
    }
};

案例3：背包问题系列

背包问题是动态规划的经典应用，我们来看最重要的几种类型。

0-1背包问题

问题描述 ：给定n个物品，每个物品有重量weight[i]和价值value[i]。背包容量为W，每个物品只能取一次，求背包能装入物品的最大价值。

状态定义与转移：

• 状态定义 ：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]）
  • dp[i][w] = max(dp[i-1][w], dp[i-1][w-weight[i]] + value[i])

代码实现

#include <iostream>
#include <vector>
#include <algorithm>

class Knapsack01 {
public:
    // 二维DP实现
    int knapsack2D(std::vector<int>& weights, std::vector<int>& values, int capacity) {
        int n = weights.size();
        // dp[i][w] 表示前i个物品，容量为w的最大价值
        std::vector<std::vector<int>> dp(n + 1, std::vector<int>(capacity + 1, 0));
        
        for (int i = 1; i <= n; i++) {
            for (int w = 0; w <= capacity; w++) {
                // 不选择第i个物品
                dp[i][w] = dp[i - 1][w];
                
                // 如果能选择第i个物品
                if (w >= weights[i - 1]) {
                    dp[i][w] = std::max(dp[i][w], 
                                       dp[i - 1][w - weights[i - 1]] + values[i - 1]);
                }
            }
        }
        
        return dp[n][capacity];
    }
    
    // 一维DP实现（空间优化）
    int knapsack1D(std::vector<int>& weights, std::vector<int>& values, int capacity) {
        std::vector<int> dp(capacity + 1, 0);
        
        for (int i = 0; i < weights.size(); i++) {
            // 从后往前遍历，避免重复使用同一个物品
            for (int w = capacity; w >= weights[i]; w--) {
                dp[w] = std::max(dp[w], dp[w - weights[i]] + values[i]);
            }
        }
        
        return dp[capacity];
    }
    
    // 输出具体的选择方案
    std::vector<int> knapsackSolution(std::vector<int>& weights, std::vector<int>& values, int capacity) {
        int n = weights.size();
        std::vector<std::vector<int>> dp(n + 1, std::vector<int>(capacity + 1, 0));
        
        // 填充DP表
        for (int i = 1; i <= n; i++) {
            for (int w = 0; w <= capacity; w++) {
                dp[i][w] = dp[i - 1][w];
                if (w >= weights[i - 1]) {
                    dp[i][w] = std::max(dp[i][w], 
                                       dp[i - 1][w - weights[i - 1]] + values[i - 1]);
                }
            }
        }
        
        // 回溯找出具体选择的物品
        std::vector<int> selected;
        int w = capacity;
        for (int i = n; i > 0; i--) {
            if (dp[i][w] != dp[i - 1][w]) {
                selected.push_back(i - 1); // 选择了第i-1个物品（0-indexed）
                w -= weights[i - 1];
            }
        }
        
        std::reverse(selected.begin(), selected.end());
        return selected;
    }
};

完全背包问题

问题描述：与0-1背包类似，但每个物品可以选择无限次。

class KnapsackComplete {
public:
    int completeKnapsack(std::vector<int>& weights, std::vector<int>& values, int capacity) {
        std::vector<int> dp(capacity + 1, 0);
        
        for (int i = 0; i < weights.size(); i++) {
            // 从前往后遍历，允许重复使用同一个物品
            for (int w = weights[i]; w <= capacity; w++) {
                dp[w] = std::max(dp[w], dp[w - weights[i]] + values[i]);
            }
        }
        
        return dp[capacity];
    }
};

案例四：序列DP问题

最长递增子序列（LIS）

问题描述：给定一个数组，找到其中最长的严格递增子序列的长度。

#include <vector>
#include <algorithm>
#include <iostream>

class LIS {
public:
    // O(n²) DP解法
    int lengthOfLIS_DP(std::vector<int>& nums) {
        if (nums.empty()) return 0;
        
        int n = nums.size();
        std::vector<int> dp(n, 1); // dp[i]表示以nums[i]结尾的最长递增子序列长度
        int maxLength = 1;
        
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    dp[i] = std::max(dp[i], dp[j] + 1);
                }
            }
            maxLength = std::max(maxLength, dp[i]);
        }
        
        return maxLength;
    }
    
    // 获取具体的LIS序列
    std::vector<int> findLIS(std::vector<int>& nums) {
        if (nums.empty()) return {};
        
        int n = nums.size();
        std::vector<int> dp(n, 1);
        std::vector<int> parent(n, -1); // 记录前驱元素的索引
        
        int maxLength = 1;
        int maxIndex = 0;
        
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i] && dp[j] + 1 > dp[i]) {
                    dp[i] = dp[j] + 1;
                    parent[i] = j;
                }
            }
            if (dp[i] > maxLength) {
                maxLength = dp[i];
                maxIndex = i;
            }
        }
        
        // 构造LIS序列
        std::vector<int> lis;
        int current = maxIndex;
        while (current != -1) {
            lis.push_back(nums[current]);
            current = parent[current];
        }
        
        std::reverse(lis.begin(), lis.end());
        return lis;
    }
    
    // O(nlogn) 二分搜索解法
    int lengthOfLIS_Binary(std::vector<int>& nums) {
        if (nums.empty()) return 0;
        
        std::vector<int> tails; // tails[i] 表示长度为i+1的递增子序列的最小尾部元素
        
        for (int num : nums) {
            auto it = std::lower_bound(tails.begin(), tails.end(), num);
            if (it == tails.end()) {
                tails.push_back(num);
            } else {
                *it = num;
            }
        }
        
        return tails.size();
    }
};

最长公共子序列（LCS）

问题描述：给定两个字符串，找到它们的最长公共子序列的长度。

class LCS {
public:
    int longestCommonSubsequence(std::string text1, std::string text2) {
        int m = text1.length(), n = text2.length();
        // dp[i][j] 表示text1[0..i-1]和text2[0..j-1]的LCS长度
        std::vector<std::vector<int>> dp(m + 1, std::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] = std::max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        
        return dp[m][n];
    }
    
    // 获取具体的LCS字符串
    std::string findLCS(std::string text1, std::string text2) {
        int m = text1.length(), n = text2.length();
        std::vector<std::vector<int>> dp(m + 1, std::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] = std::max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        
        // 回溯构造LCS
        std::string lcs;
        int i = m, j = n;
        while (i > 0 && j > 0) {
            if (text1[i - 1] == text2[j - 1]) {
                lcs = text1[i - 1] + lcs;
                i--;
                j--;
            } else if (dp[i - 1][j] > dp[i][j - 1]) {
                i--;
            } else {
                j--;
            }
        }
        
        return lcs;
    }
};

案例五：路径问题

最小路径和

问题描述：给定一个包含非负整数的m×n网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

class PathSum {
public:
    int minPathSum(std::vector<std::vector<int>>& grid) {
        if (grid.empty() || grid[0].empty()) return 0;
        
        int m = grid.size(), n = grid[0].size();
        std::vector<std::vector<int>> dp(m, std::vector<int>(n));
        
        // 初始化第一个格子
        dp[0][0] = grid[0][0];
        
        // 初始化第一行
        for (int j = 1; j < n; j++) {
            dp[0][j] = dp[0][j - 1] + grid[0][j];
        }
        
        // 初始化第一列
        for (int i = 1; i < m; i++) {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }
        
        // 填充其余位置
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = std::min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
            }
        }
        
        return dp[m - 1][n - 1];
    }
    
    // 空间优化版本
    int minPathSumOptimized(std::vector<std::vector<int>>& grid) {
        if (grid.empty() || grid[0].empty()) return 0;
        
        int m = grid.size(), n = grid[0].size();
        std::vector<int> dp(n);
        
        dp[0] = grid[0][0];
        for (int j = 1; j < n; j++) {
            dp[j] = dp[j - 1] + grid[0][j];
        }
        
        for (int i = 1; i < m; i++) {
            dp[0] += grid[i][0];
            for (int j = 1; j < n; j++) {
                dp[j] = std::min(dp[j], dp[j - 1]) + grid[i][j];
            }
        }
        
        return dp[n - 1];
    }
    
    // 输出具体路径
    std::vector<std::pair<int, int>> findMinPath(std::vector<std::vector<int>>& grid) {
        if (grid.empty() || grid[0].empty()) return {};
        
        int m = grid.size(), n = grid[0].size();
        std::vector<std::vector<int>> dp(m, std::vector<int>(n));
        
        // 计算DP表（同上）
        dp[0][0] = grid[0][0];
        for (int j = 1; j < n; j++) {
            dp[0][j] = dp[0][j - 1] + grid[0][j];
        }
        for (int i = 1; i < m; i++) {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = std::min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
            }
        }
        
        // 回溯找路径
        std::vector<std::pair<int, int>> path;
        int i = m - 1, j = n - 1;
        while (i > 0 || j > 0) {
            path.push_back({i, j});
            if (i == 0) {
                j--;
            } else if (j == 0) {
                i--;
            } else {
                if (dp[i - 1][j] < dp[i][j - 1]) {
                    i--;
                } else {
                    j--;
                }
            }
        }
        path.push_back({0, 0});
        
        std::reverse(path.begin(), path.end());
        return path;
    }
};

案例六：区间DP

区间DP是在区间上进行动态规划，通常用来解决关于区间的最优化问题。

矩阵链乘法

问题描述：给定n个矩阵的维度，求这些矩阵相乘时的最少标量乘法次数。

class MatrixChainMultiplication {
public:
    int matrixChainOrder(std::vector<int>& dims) {
        int n = dims.size() - 1; // n个矩阵
        // dp[i][j] 表示矩阵i到矩阵j相乘的最少乘法次数
        std::vector<std::vector<int>> dp(n, std::vector<int>(n, 0));
        
        // l是链的长度，从2开始
        for (int l = 2; l <= n; l++) {
            for (int i = 0; i <= n - l; i++) {
                int j = i + l - 1;
                dp[i][j] = INT_MAX;
                
                // 尝试所有可能的分割点k
                for (int k = i; k < j; k++) {
                    int cost = dp[i][k] + dp[k + 1][j] + dims[i] * dims[k + 1] * dims[j + 1];
                    dp[i][j] = std::min(dp[i][j], cost);
                }
            }
        }
        
        return dp[0][n - 1];
    }
    
    // 输出最优括号化方案
    void printOptimalParens(std::vector<std::vector<int>>& s, int i, int j, std::string& result) {
        if (i == j) {
            result += "M" + std::to_string(i);
        } else {
            result += "(";
            printOptimalParens(s, i, s[i][j], result);
            printOptimalParens(s, s[i][j] + 1, j, result);
            result += ")";
        }
    }
    
    std::string getOptimalParentheses(std::vector<int>& dims) {
        int n = dims.size() - 1;
        std::vector<std::vector<int>> dp(n, std::vector<int>(n, 0));
        std::vector<std::vector<int>> s(n, std::vector<int>(n, 0)); // 记录分割点
        
        for (int l = 2; l <= n; l++) {
            for (int i = 0; i <= n - l; i++) {
                int j = i + l - 1;
                dp[i][j] = INT_MAX;
                
                for (int k = i; k < j; k++) {
                    int cost = dp[i][k] + dp[k + 1][j] + dims[i] * dims[k + 1] * dims[j + 1];
                    if (cost < dp[i][j]) {
                        dp[i][j] = cost;
                        s[i][j] = k;
                    }
                }
            }
        }
        
        std::string result;
        printOptimalParens(s, 0, n - 1, result);
        return result;
    }
};

案例七：树形DP

树形DP是在树结构上进行的动态规划。

二叉树的最大路径和

问题描述：给定一个二叉树，找到任意两个节点间路径上数值和的最大值。

#include <algorithm>
#include <climits>

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

class TreeDP {
private:
    int maxSum = INT_MIN;
    
    // 返回以当前节点为起点的最大路径和（只能向下）
    int maxPathDown(TreeNode* node) {
        if (!node) return 0;
        
        // 递归计算左右子树的最大贡献值
        // 如果子树路径和为负，则不选择该路径（用0代替）
        int leftMax = std::max(maxPathDown(node->left), 0);
        int rightMax = std::max(maxPathDown(node->right), 0);
        
        // 当前节点的最大路径和（可能经过当前节点连接左右子树）
        int currentMax = node->val + leftMax + rightMax;
        
        // 更新全局最大值
        maxSum = std::max(maxSum, currentMax);
        
        // 返回当前节点向上的最大贡献值（只能选择一边）
        return node->val + std::max(leftMax, rightMax);
    }
    
public:
    int maxPathSum(TreeNode* root) {
        maxSum = INT_MIN;
        maxPathDown(root);
        return maxSum;
    }
};

打家劫舍III（树上版本）

问题描述：小偷在二叉树形状的房屋中偷盗，不能偷相邻的房屋（父子节点不能同时偷）。

class HouseRobberTree {
public:
    // 返回一个pair：{不偷当前节点的最大收益, 偷当前节点的最大收益}
    std::pair<int, int> robHelper(TreeNode* node) {
        if (!node) return {0, 0};
        
        auto left = robHelper(node->left);
        auto right = robHelper(node->right);
        
        // 不偷当前节点：左右子树可偷可不偷，取最大值
        int notRob = std::max(left.first, left.second) + std::max(right.first, right.second);
        
        // 偷当前节点：左右子树都不能偷
        int rob = node->val + left.first + right.first;
        
        return {notRob, rob};
    }
    
    int rob(TreeNode* root) {
        auto result = robHelper(root);
        return std::max(result.first, result.second);
    }
};

案例八：状态压缩DP

当状态数量较少时，可以用位运算来压缩状态，提高效率。

旅行商问题（TSP）

问题描述：给定n个城市和它们之间的距离，找到访问所有城市恰好一次并回到起点的最短路径。

class TSP {
public:
    int tsp(std::vector<std::vector<int>>& dist) {
        int n = dist.size();
        int fullMask = (1 << n) - 1; // 所有城市都访问过的状态
        
        // dp[mask][i] 表示当前访问过的城市集合为mask，当前在城市i的最小距离
        std::vector<std::vector<int>> dp(1 << n, std::vector<int>(n, INT_MAX));
        
        // 从城市0开始
        dp[1][0] = 0; // 状态1表示只访问了城市0
        
        for (int mask = 1; mask < (1 << n); mask++) {
            for (int u = 0; u < n; u++) {
                if (!(mask & (1 << u)) || dp[mask][u] == INT_MAX) continue;
                
                // 尝试从城市u转移到城市v
                for (int v = 0; v < n; v++) {
                    if (mask & (1 << v)) continue; // 城市v已经访问过
                    
                    int newMask = mask | (1 << v);
                    dp[newMask][v] = std::min(dp[newMask][v], dp[mask][u] + dist[u][v]);
                }
            }
        }
        
        // 找到访问所有城市后回到起点的最小距离
        int result = INT_MAX;
        for (int i = 1; i < n; i++) {
            if (dp[fullMask][i] != INT_MAX) {
                result = std::min(result, dp[fullMask][i] + dist[i][0]);
            }
        }
        
        return result;
    }
    
    // 输出具体路径
    std::vector<int> getTSPPath(std::vector<std::vector<int>>& dist) {
        int n = dist.size();
        int fullMask = (1 << n) - 1;
        
        std::vector<std::vector<int>> dp(1 << n, std::vector<int>(n, INT_MAX));
        std::vector<std::vector<int>> parent(1 << n, std::vector<int>(n, -1));
        
        dp[1][0] = 0;
        
        for (int mask = 1; mask < (1 << n); mask++) {
            for (int u = 0; u < n; u++) {
                if (!(mask & (1 << u)) || dp[mask][u] == INT_MAX) continue;
                
                for (int v = 0; v < n; v++) {
                    if (mask & (1 << v)) continue;
                    
                    int newMask = mask | (1 << v);
                    int newDist = dp[mask][u] + dist[u][v];
                    if (newDist < dp[newMask][v]) {
                        dp[newMask][v] = newDist;
                        parent[newMask][v] = u;
                    }
                }
            }
        }
        
        // 找到最优的结束城市
        int minDist = INT_MAX;
        int lastCity = -1;
        for (int i = 1; i < n; i++) {
            if (dp[fullMask][i] + dist[i][0] < minDist) {
                minDist = dp[fullMask][i] + dist[i][0];
                lastCity = i;
            }
        }
        
        // 重构路径
        std::vector<int> path;
        int currentMask = fullMask;
        int currentCity = lastCity;
        
        while (currentCity != -1) {
            path.push_back(currentCity);
            int prevCity = parent[currentMask][currentCity];
            currentMask ^= (1 << currentCity);
            currentCity = prevCity;
        }
        
        std::reverse(path.begin(), path.end());
        path.push_back(0); // 回到起点
        return path;
    }
};

三、DP优化技巧

1. 滚动数组优化空间

当DP状态只依赖于前一个或前几个状态时，可以使用滚动数组节省空间。

// 示例：背包问题的空间优化
class SpaceOptimization {
public:
    // 原始二维DP
    int knapsack2D(std::vector<int>& weights, std::vector<int>& values, int capacity) {
        int n = weights.size();
        std::vector<std::vector<int>> dp(n + 1, std::vector<int>(capacity + 1, 0));
        
        for (int i = 1; i <= n; i++) {
            for (int w = 0; w <= capacity; w++) {
                dp[i][w] = dp[i-1][w];
                if (w >= weights[i-1]) {
                    dp[i][w] = std::max(dp[i][w], dp[i-1][w-weights[i-1]] + values[i-1]);
                }
            }
        }
        return dp[n][capacity];
    }
    
    // 空间优化后的一维DP
    int knapsack1D(std::vector<int>& weights, std::vector<int>& values, int capacity) {
        std::vector<int> dp(capacity + 1, 0);
        
        for (int i = 0; i < weights.size(); i++) {
            for (int w = capacity; w >= weights[i]; w--) {
                dp[w] = std::max(dp[w], dp[w-weights[i]] + values[i]);
            }
        }
        return dp[capacity];
    }
};

2. 单调队列优化

在某些DP转移中，可以使用单调队列来优化时间复杂度。

#include <deque>

class MonotonicQueueOptimization {
public:
    // 滑动窗口最大值的DP应用
    std::vector<int> maxSlidingWindow(std::vector<int>& nums, int k) {
        std::deque<int> dq; // 存储数组下标
        std::vector<int> result;
        
        for (int i = 0; i < nums.size(); i++) {
            // 移除超出窗口范围的元素
            while (!dq.empty() && dq.front() <= i - k) {
                dq.pop_front();
            }
            
            // 维护单调递减队列
            while (!dq.empty() && nums[dq.back()] <= nums[i]) {
                dq.pop_back();
            }
            
            dq.push_back(i);
            
            // 当窗口大小达到k时，记录最大值
            if (i >= k - 1) {
                result.push_back(nums[dq.front()]);
            }
        }
        
        return result;
    }
};

3. 矩阵快速幂优化

对于线性递推关系，可以使用矩阵快速幂将时间复杂度从O(n)降到O(logn)。

class MatrixFastPower {
private:
    using Matrix = std::vector<std::vector<long long>>;
    
    Matrix multiply(const Matrix& A, const Matrix& B) {
        int n = A.size();
        Matrix C(n, std::vector<long long>(n, 0));
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    C[i][j] += A[i][k] * B[k][j];
                }
            }
        }
        return C;
    }
    
    Matrix matrixPower(Matrix base, long long exp) {
        int n = base.size();
        Matrix result(n, std::vector<long long>(n, 0));
        
        // 初始化为单位矩阵
        for (int i = 0; i < n; i++) {
            result[i][i] = 1;
        }
        
        while (exp > 0) {
            if (exp & 1) {
                result = multiply(result, base);
            }
            base = multiply(base, base);
            exp >>= 1;
        }
        
        return result;
    }
    
public:
    // 使用矩阵快速幂计算斐波那契数列
    long long fibonacciMatrix(long long n) {
        if (n <= 1) return n;
        
        // 转移矩阵: [[1,1],[1,0]]
        Matrix base = {{1, 1}, {1, 0}};
        Matrix result = matrixPower(base, n - 1);
        
        // F(n) = result[0][0] * F(1) + result[0][1] * F(0)
        //      = result[0][0] * 1 + result[0][1] * 0
        //      = result[0][0]
        return result[0][0];
    }
};

四、综合练习题

练习1：最大子数组和（Kadane算法）

class MaxSubarray {
public:
    int maxSubArray(std::vector<int>& nums) {
        int maxSum = nums[0];
        int currentSum = nums[0];
        
        for (int i = 1; i < nums.size(); i++) {
            // 要么继续之前的子数组，要么重新开始
            currentSum = std::max(nums[i], currentSum + nums[i]);
            maxSum = std::max(maxSum, currentSum);
        }
        
        return maxSum;
    }
    
    // 返回具体的最大子数组
    std::vector<int> findMaxSubArray(std::vector<int>& nums) {
        int maxSum = nums[0];
        int currentSum = nums[0];
        int start = 0, end = 0, tempStart = 0;
        
        for (int i = 1; i < nums.size(); i++) {
            if (currentSum < 0) {
                currentSum = nums[i];
                tempStart = i;
            } else {
                currentSum += nums[i];
            }
            
            if (currentSum > maxSum) {
                maxSum = currentSum;
                start = tempStart;
                end = i;
            }
        }
        
        return std::vector<int>(nums.begin() + start, nums.begin() + end + 1);
    }
};

练习2：编辑距离

class EditDistance {
public:
    int minDistance(std::string word1, std::string word2) {
        int m = word1.length(), n = word2.length();
        
        // dp[i][j] 表示word1[0..i-1]转换为word2[0..j-1]的最小操作数
        std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1));
        
        // 初始化边界条件
        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] = 1 + std::min({
                        dp[i-1][j],    // 删除
                        dp[i][j-1],    // 插入
                        dp[i-1][j-1]   // 替换
                    });
                }
            }
        }
        
        return dp[m][n];
    }
    
    // 输出具体的编辑操作序列
    std::vector<std::string> getEditOperations(std::string word1, std::string word2) {
        int m = word1.length(), n = word2.length();
        std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1));
        
        // 填充DP表（同上）
        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] = 1 + std::min({dp[i-1][j], dp[i][j-1], dp[i-1][j-1]});
                }
            }
        }
        
        // 回溯操作序列
        std::vector<std::string> operations;
        int i = m, j = n;
        
        while (i > 0 || j > 0) {
            if (i > 0 && j > 0 && word1[i-1] == word2[j-1]) {
                i--; j--;
            } else if (i > 0 && j > 0 && dp[i][j] == dp[i-1][j-1] + 1) {
                operations.push_back("Replace " + std::string(1, word1[i-1]) + " with " + std::string(1, word2[j-1]));
                i--; j--;
            } else if (i > 0 && dp[i][j] == dp[i-1][j] + 1) {
                operations.push_back("Delete " + std::string(1, word1[i-1]));
                i--;
            } else {
                operations.push_back("Insert " + std::string(1, word2[j-1]));
                j--;
            }
        }
        
        std::reverse(operations.begin(), operations.end());
        return operations;
    }
};

总结与进阶建议

DP解题模板：

// 通用DP解题模板
class DPTemplate {
public:
    int solveProblem(/* 输入参数 */) {
        // 第1步：确定状态定义
        // dp[i][j][...] 的含义是什么？
        
        // 第2步：找出状态转移方程
        // dp[i][j] = f(dp[...], dp[...], ...)
        
        // 第3步：确定初始条件和边界
        // dp的初始值是什么？
        
        // 第4步：确定计算顺序
        // 保证计算dp[i][j]时，所依赖的状态都已计算
        
        // 第5步：优化空间复杂度（如果可能）
        // 使用滚动数组等技巧
        
        return 0; // 返回最终答案
    }
};

DP问题分类总结

类型	特征	常见问题	时间复杂度
线性DP	状态转移呈线性关系	爬楼梯、最大子序列和	O(n)
区间DP	在区间上进行DP	矩阵链乘法、回文子串	O(n³)
背包DP	选择物品的最优化问题	0-1背包、完全背包	O(nW)
树形DP	在树结构上的DP	树的直径、打家劫舍III	O(n)
状态压缩DP	用位运算压缩状态	TSP、集合覆盖	O(n²2ⁿ)
数位DP	按数位进行的DP	统计特定数字个数	O(logn)

进阶学习路径

1. 掌握基础问题：从斐波那契、爬楼梯开始
2. 熟练背包问题：0-1背包、完全背包、多重背包
3. 掌握序列DP：LIS、LCS、编辑距离
4. 学习区间DP：矩阵链乘法、石子合并
5. 深入树形DP：树的直径、重心分解
6. 挑战状态压缩：TSP、状态空间搜索
7. 学习优化技巧：单调队列、斜率优化、矩阵快速幂

调试技巧

// DP调试辅助函数
class DPDebugger {
public:
    template<typename T>
    void printDP(const std::vector<std::vector<T>>& dp, const std::string& name) {
        std::cout << "=== " << name << " ===" << std::endl;
        for (int i = 0; i < dp.size(); i++) {
            for (int j = 0; j < dp[i].size(); j++) {
                std::cout << std::setw(6) << dp[i][j] << " ";
            }
            std::cout << std::endl;
        }
        std::cout << std::endl;
    }
    
    template<typename T>
    void print1D(const std::vector<T>& arr, const std::string& name) {
        std::cout << name << ": ";
        for (const auto& x : arr) {
            std::cout << x << " ";
        }
        std::cout << std::endl;
    }
};

🏆 最后的话

动态规划是算法设计中的一颗明珠，它教会我们如何化繁为简，化重复为存储。掌握DP不仅能帮你解决编程竞赛中的难题，更重要的是能培养你分解复杂问题的思维能力。

记住DP的精髓：

• 最优子结构：大问题的最优解包含小问题的最优解
• 重叠子问题：避免重复计算，用空间换时间
• 状态转移：找出问题内在的递推关系

多练习，多思考，相信你一定能掌握这个强大的算法思想！

练习建议：每天至少做1-2道不同类型的DP题目，并尝试优化空间复杂度。熟能生巧，DP的精髓就在于大量的练习和思考。