动态规划十大经典题型状态转移、模版等整理（包括leetcode、洛谷题号）

动态规划十大经典题目整理

0-1 背包问题（0-1 Knapsack Problem）

LeetCode题号：无直接对应
洛谷OJ题号：P1048
状态转移方程：dp $j$ = max(dp $j$ , dp $j - weight\[i$ ] + value $i$ )
C++代码模板：

cpp 复制代码

int dp[capacity + 1] = {0};
for (int i = 0; i < n; ++i) {
    for (int j = capacity; j >= weight[i]; --j) {
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
}

完全背包问题（Complete Knapsack Problem）

LeetCode题号：322
洛谷OJ题号：P1616
状态转移方程：dp $j$ = min(dp $j$ , dp $j - coins\[i$ ] + 1)
C++代码模板：

cpp 复制代码

vector<int> dp(amount + 1, INT_MAX);
dp[0] = 0;
for (int i = 0; i < coins.size(); ++i) {
    for (int j = coins[i]; j <= amount; ++j) {
        if (dp[j - coins[i]] != INT_MAX) {
            dp[j] = min(dp[j], dp[j - coins[i]] + 1);
        }
    }
}

编辑距离（Edit Distance）

LeetCode题号：72
洛谷OJ题号：P2758
状态转移方程：
- 若 word1 $i-1$ == word2 $j-1$ ：dp $i$ $j$ = dp $i-1$ $j-1$
- 否则：dp $i$ $j$ = min(dp $i-1$ $j-1$ , dp $i-1$ $j$ , dp $i$ $j-1$ ) + 1
C++代码模板：

cpp 复制代码

vector<vector<int>> dp(m + 1, 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] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;
    }
}

最长公共子序列（Longest Common Subsequence）

LeetCode题号：1143
洛谷OJ题号：P1439
状态转移方程：
- 若 text1 $i-1$ == text2 $j-1$ ：dp $i$ $j$ = dp $i-1$ $j-1$ + 1
- 否则：dp $i$ $j$ = max(dp $i-1$ $j$ , dp $i$ $j-1$ )
C++代码模板：

cpp 复制代码

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]);
    }
}

最长递增子序列（Longest Increasing Subsequence）

LeetCode题号：300
洛谷OJ题号：P1439
状态转移方程：dp $i$ = max(dp $j$ + 1), j < i 且 nums $j$ < nums $i$
C++代码模板：

cpp 复制代码

vector<int> dp(n, 1);
for (int i = 1; i < n; ++i) {
    for (int j = 0; j < i; ++j) {
        if (nums[i] > nums[j])
            dp[i] = max(dp[i], dp[j] + 1);
    }
}

乘积最大子数组（Maximum Product Subarray）

LeetCode题号：152
洛谷OJ题号：无直接对应
状态转移方程：记录当前最大值与最小值
C++代码模板：

cpp 复制代码

int max_prod = nums[0], min_prod = nums[0], result = nums[0];
for (int i = 1; i < n; ++i) {
    if (nums[i] < 0) swap(max_prod, min_prod);
    max_prod = max(nums[i], max_prod * nums[i]);
    min_prod = min(nums[i], min_prod * nums[i]);
    result = max(result, max_prod);
}

不同路径（Unique Paths）

LeetCode题号：62
洛谷OJ题号：P1002
状态转移方程：dp $i$ $j$ = dp $i-1$ $j$ + dp $i$ $j-1$
C++代码模板：

cpp 复制代码

vector<vector<int>> dp(m, vector<int>(n, 1));
for (int i = 1; i < m; ++i) {
    for (int j = 1; j < n; ++j) {
        dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
    }
}

最小路径和（Minimum Path Sum）

LeetCode题号：64
洛谷OJ题号：P1216
状态转移方程：dp $i$ $j$ = min(dp $i-1$ $j$ , dp $i$ $j-1$ ) + grid $i$ $j$
C++代码模板：

cpp 复制代码

vector<vector<int>> dp(m, vector<int>(n, 0));
dp[0][0] = grid[0][0];
for (int i = 1; i < m; ++i) dp[i][0] = dp[i - 1][0] + grid[i][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) {
    for (int j = 1; j < n; ++j) {
        dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
    }
}

打家劫舍（House Robber）

LeetCode题号：198
洛谷OJ题号：P1980（近似）
状态转移方程：dp $i$ = max(dp $i-2$ + nums $i$ , dp $i-1$ )
C++代码模板：

cpp 复制代码

if (nums.empty()) return 0;
if (nums.size() == 1) return nums[0];
vector<int> dp(nums.size());
dp[0] = nums[0];
dp[1] = max(nums[0], nums[1]);
for (int i = 2; i < nums.size(); ++i) {
    dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
}

最长有效括号（Longest Valid Parentheses）

LeetCode题号：32
洛谷OJ题号：无
状态转移方程：复杂，涉及匹配与回溯逻辑
C++代码模板：

cpp 复制代码

int max_len = 0;
vector<int> dp(s.length(), 0);
for (int i = 1; i < s.length(); ++i) {
    if (s[i] == ')') {
        if (s[i - 1] == '(')
            dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
        else if (i - dp[i - 1] > 0 && s[i - dp[i - 1] - 1] == '(')
            dp[i] = dp[i - 1] + ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;
        max_len = max(max_len, dp[i]);
    }
}