动态规划 on 望境

状态转移方程与动态规划

Mon, 02 Mar 2026 13:57:00 +0800

在算法题当中，我们经常可以看见动态规划的影子，所以在此总结一下动态规划（DP）和其中非常重要的一个部分——状态转移方程。

一、何为动态规划

动态规划（Dynamic Programming，DP）是一种通过把原问题分解为子问题来求解的算法思想。

动态规划不是某种具体的数据结构，而是一种思维方式。

DP 需要满足以下两个性质：

1. 最优子结构

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

2. 重叠子问题

子问题被反复计算，可以缓存避免重复。

二、何为状态转移方程

要了解状态转移方程，首先应当知道何为"状态"。

1. “状态”

状态是对问题在某一阶段的描述，通常用 dp[i] 或 dp[i][j] 表示。

例如：

dp[i] = 前 i 个元素的最优解
dp[i][j] = 从位置 i 到位置 j 的最优解
dp[i][w] = 考虑前 i 个物品、剩余容量为 w 时的最优解

2. 状态转移方程

状态转移方程可以粗略的写成：

`1`	`新状态 = f(旧状态)`

状态转移方程所做的是确定该步有什么选择，以及选择背后所对应的子问题（可以理解为递推式）。

三、典型例题

例 1：线性 DP - 爬楼梯

问题

每次可以爬 1 或 2 个台阶，爬到第 n 阶有多少种方法？

思路分析

定义状态：dp[i] = 爬到第 i 阶的方法数
最后一步分析：到达第 i 阶，只能从第 i-1 阶（迈 1 步）或第 i-2 阶（迈 2 步）过来
根据分析，我们可以得到这样一个状态转移方程：

$$dp[i] = dp[i-1] + dp[i-2]$$

注意：此状态转移方程还有两个边界状态：dp[1] = 1，dp[2] = 2

图解：

i = 5
dp[1] = 1
dp[2] = 2
dp[3] = 3
dp[4] = 5
dp[5] = 8

代码实现

#include <stdio.h>

int climbStairs(int n) {
    if (n <= 2) return n;
    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 main() {
    printf("爬 5 阶楼梯的方法数: %d\n", climbStairs(5));  // 输出: 8
    return 0;
}

时间复杂度与优缺点

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

优点：

问题简单，易于理解
状态定义直观

缺点：

只能计算一固定地方的值，若要计算多次则需多次递推

例 2：线性 DP - 打家劫舍

问题

一排房子不能抢相邻的，求最大金额。给定数组 nums 表示各房子的金额。

思路分析

定义状态：dp[i] = 抢到第 i 间房能获得的最大金额
最后一步分析：第 i 间房，要么抢，要么不抢
- 抢这间：得到 nums[i] + dp[i-2]（前面最多抢到 i-2 间）
- 不抢这间：得到 dp[i-1]（抢到 i-1 间的最大值）
状态转移方程：

$$dp[i] = \max(dp[i-1], dp[i-2] + nums[i])$$

图解：

nums = [2, 7, 9, 3, 1]
dp[0] = 2
dp[1] = max(2, 7) = 7
dp[2] = max(7, 2+9) = 11
dp[3] = max(11, 7+3) = 11
dp[4] = max(11, 11+1) = 12  (抢第 0、2、4 间：2+9+1=12)

代码实现

#include <stdio.h>

int max(int a, int b) { return a > b ? a : b; }

int rob(int *nums, int n) {
    if (n == 1) return nums[0];
    int dp[n];
    dp[0] = nums[0];
    dp[1] = max(nums[0], nums[1]);
    for (int i = 2; i < n; i++) {
        dp[i] = max(dp[i-1], dp[i-2] + nums[i]);  // 状态转移方程
    }
    return dp[n-1];
}

int main() {
    int nums[] = {2, 7, 9, 3, 1};
    int n = sizeof(nums) / sizeof(nums[0]);
    printf("最大金额: %d\n", rob(nums, n));  // 输出: 12
    return 0;
}

时间复杂度与优缺点

时间复杂度 ：$O(n)$
空间复杂度 ：$O(n)$，可优化为 $O(1)$（仅保留前两项）

优点：

✅ 与爬楼梯类似，思路清晰
✅ 可优化空间至 O(1)

缺点：

❌ 不能直接回溯具体哪些房子被抢

例 3：背包 DP - 0/1 背包

问题

n 个物品，重量 w[]，价值 v[]，背包容量 W，求最大价值。

思路分析

定义状态：dp[i][j] = 考虑前 i 个物品、容量为 j 时的最大价值
最后一步分析：第 i 个物品，放或不放
- 不放：dp[i][j] = dp[i-1][j]
- 放：dp[i][j] = dp[i-1][j - w[i]] + v[i]（需 $j \geq w[i]$）
状态转移方程：

$$dp[i][j] = \max(dp[i-1][j], dp[i-1][j - w[i]] + v[i])$$

图解：

物品：(w=2, v=3)、(w=3, v=4)、(w=4, v=5) 背包容量 W=5

      j=0  j=1  j=2  j=3  j=4  j=5
i=0    0    0    0    0    0    0
i=1    0    0    3    3    3    3
i=2    0    0    3    4    4    7   ← 放物品 1 + 物品 2，价值=3+4=7
i=3    0    0    3    4    5    7

答案：dp[3][5] = 7

代码实现

#include <stdio.h>

#define MAX_N 105
#define MAX_W 1005

int dp[MAX_N][MAX_W];

int max(int a, int b) { return a > b ? a : b; }

int knapsack(int *w, int *v, int n, int W) {
    for (int i = 0; i <= n; i++)
        for (int j = 0; j <= W; j++)
            dp[i][j] = 0;

    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= W; j++) {
            dp[i][j] = dp[i-1][j];                          // 不放
            if (j >= w[i-1])                                 // 放得下
                dp[i][j] = max(dp[i][j],
                               dp[i-1][j - w[i-1]] + v[i-1]);  // 状态转移方程
        }
    }
    return dp[n][W];
}

int main() {
    int w[] = {2, 3, 4};
    int v[] = {3, 4, 5};
    int n = 3, W = 5;
    printf("最大价值: %d\n", knapsack(w, v, n, W));  // 输出: 7
    return 0;
}

空间优化 ：二维 dp 可以压缩成一维，内层循环必须倒序，防止同一件物品被重复放入：

1
2
3

for (int i = 0; i < n; i++)
    for (int j = W; j >= w[i]; j--)        // 倒序！
        dp[j] = max(dp[j], dp[j - w[i]] + v[i]);

时间复杂度与优缺点

时间复杂度 ：$O(nW)$
空间复杂度 ：$O(nW)$，优化后为 $O(W)$

优点：

DP 框架经典，易于扩展
可一次性解决所有容量的最优值

缺点：

物品数量或容量很大时，时间空间压力大

例 4：序列 DP - 最长公共子序列（LCS）

问题

两个字符串，求最长公共子序列的长度。例："abcde" 和 "ace" → 长度为 3（ace）

思路分析

定义状态：dp[i][j] = s1 前 i 个字符与 s2 前 j 个字符的 LCS 长度
最后一步分析：s1[i] 和 s2[j] 是否相等：
- 相等：dp[i][j] = dp[i-1][j-1] + 1
- 不相等：dp[i][j] = max(dp[i-1][j], dp[i][j-1])（去掉 s1[i] 或 s2[j]，看哪个更优）
状态转移方程：当 s1[i-1] == s2[j-1] 时，dp[i][j] = dp[i-1][j-1] + 1；否则 dp[i][j] = max(dp[i-1][j], dp[i][j-1])

或用分段函数表示：

$$dp[i][j] = \begin{cases} \text{dp[i-1][j-1] + 1} & \text{相等时} \\ \text{max(dp[i-1][j], dp[i][j-1])} & \text{不相等时} \end{cases}$$

图解：

s1 = “abcde” s2 = “ace”

        ""   a    c    e
    ""   0   0    0    0
    a    0   1    1    1
    b    0   1    1    1
    c    0   1    2    2
    d    0   1    2    2
    e    0   1    2    3   ← 得解

代码实现

#include <stdio.h>
#include <string.h>

#define MAX_LEN 105

int dp[MAX_LEN][MAX_LEN];

int max(int a, int b) { return a > b ? a : b; }

int lcs(char *s1, char *s2) {
    int m = strlen(s1);
    int n = strlen(s2);

    for (int i = 0; i <= m; i++) dp[i][0] = 0;
    for (int j = 0; j <= n; j++) dp[0][j] = 0;

    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (s1[i-1] == s2[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];
}

int main() {
    char s1[] = "abcde";
    char s2[] = "ace";
    printf("LCS 长度: %d\n", lcs(s1, s2));  // 输出: 3
    return 0;
}

时间复杂度与优缺点

时间复杂度 ：$O(mn)$
空间复杂度 ：$O(mn)$，可优化为 $O(\min(m,n))$（滚动数组）

优点：

框架适用于序列对齐问题
可扩展到 LCS 具体字符（回溯）

缺点：

m、n 都很大时空间压力大

例 5：区间 DP - 戳气球

问题

戳破气球 i 得分 = nums[i-1] * nums[i] * nums[i+1]，求最大总得分。

思路分析

关键思路 ：不想"先戳哪个"，而想"区间 (i,j) 中最后一个戳哪个"，这样两侧边界已知，避免状态混乱
定义状态：dp[i][j] = 戳破开区间 (i,j) 内所有气球的最大得分
根据分析，我们可以得到这样一个状态转移方程：

$$dp[i][j] = \max_{i < k < j}(dp[i][k] + dp[k][j] + nums[i] \times nums[k] \times nums[j])$$

其中 k 是区间 (i,j) 中最后一个被戳的气球。

代码实现

#include <stdio.h>
#include <string.h>

#define MAX_N 305

int dp[MAX_N][MAX_N];
int nums[MAX_N];

int max(int a, int b) { return a > b ? a : b; }

int maxCoins(int *arr, int n) {
    // 加哨兵边界
    nums[0] = 1;
    for (int i = 1; i <= n; i++) nums[i] = arr[i-1];
    nums[n+1] = 1;
    int N = n + 2;

    memset(dp, 0, sizeof(dp));

    // 按区间长度从小到大枚举
    for (int len = 2; len < N; len++) {
        for (int i = 0; i < N - len; i++) {
            int j = i + len;
            for (int k = i+1; k < j; k++) {   // k 是最后被戳的气球
                int score = dp[i][k] + dp[k][j]
                          + nums[i] * nums[k] * nums[j];
                dp[i][j] = max(dp[i][j], score);  // 状态转移方程
            }
        }
    }
    return dp[0][N-1];
}

int main() {
    int arr[] = {3, 1, 5, 8};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("最大得分: %d\n", maxCoins(arr, n));  // 输出: 167
    return 0;
}

时间复杂度与优缺点

时间复杂度 ：$O(n^3)$
空间复杂度 ：$O(n^2)$

优点：

区间 DP 的经典例题
“最后一个"的思路极具启发性
可通过回溯得到具体戳的顺序

缺点：

思路相对复杂，初次接触易困惑
时间复杂度为立方级

四、DP 模型总结

DP 模型对比总结：

类型	状态转移方程	时间复杂度	空间复杂度	代表问题
线性 DP	递推关系	$O(n)$	$O(n)$	爬楼梯、打家劫舍
背包 DP	选择最大值	$O(nW)$	$O(nW)$	0/1 背包、完全背包
序列 DP	两指针递推	$O(mn)$	$O(mn)$	LCS、编辑距离
区间 DP	区间分割递推	$O(n^3)$	$O(n^2)$	戳气球、矩阵链乘

总结与建议

从问题出发 ：确定能否用 DP（有最优子结构和重叠子问题）
定义状态 ：清晰地定义 dp[...] 的含义
写出转移方程 ：确定状态间的关系
确定初始条件 ：边界情况的处理
实现与优化 ：代码实现，再考虑空间+时间优化

P1004 [NOIP 2000 提高组] 方格取数分析与总结

Sat, 28 Feb 2026 11:31:00 +0800

这是一道经典但具有一定难度的棋盘模型题。虽然是 2000 年的 NOIP 题目，但作为压轴题，对于第一次接触的人来说还是相当困难的。本文总结了三种不同的解法：动态规划、DFS 记忆化和最小费用最大流，从易到难逐步展开。

问题

题目来源

NOIP 2000 提高组 T4

问题描述

设有 N×N 的方格图 (N≤9)，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字 0。某人从图的左上角的 A 点（0，0）出发，可以向下行走，也可以向右走，直到到达右下角的 B 点（N, N)。在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字 0）。此人从 A 点到 B 点共走两次，试找出 2 条这样的路径，使得取得的数之和为最大。

输入输出

输入格式 ：输入的第一行为一个整数 N（表示 N×N 的方格图），接下来的每行有三个整数，前两个表示位置，第三个数为该位置上所放的数。一行单独的 0 表示输入结束。

输出格式 ：只需输出一个整数，表示 2 条路径上取得的最大的和。

样例

输入：

输出：

约束条件

数据范围：1≤N≤9

问题分析

为什么不能采取两次枚举（即先找一条最优路径，再在剩余格子中找第二条）？因为一次路径会改变地图（取走数字），影响第二次的结果，所以两条路径必须联动考虑，而不能独立优化。

思路分析

三种解法的思路分别如下：

解法一：动态规划

核心思想 ：将两条路径同步推进，用一个 DP 同时模拟两个人的行走。

状态设计 ：设 dp[k][x1][x2]，其中：

k 为当前走的步数（即 x + y 的值，从 2 到 2N）
x1、x2 分别为两人当前所在的行号
由 k 和 x 可以推出 y = k - x（关键优化，这一步降低了维度），因此列号不需要单独存储

去重处理 ：当两人在同一格时（x1 == x2，则 y1 == y2），该格只取一次。

状态转移 ：每步两人各自可以选择向右或向下，共 4 种组合。每个状态 dp[k][x1][x2] 代表走到第 k 步，人 1 在行 x1、人 2 在行 x2 时的最大取数和。

解法二：DFS + 记忆化搜索

核心思想 ：类似于 DP 算法（毕竟深搜和 DP 本质上就是一个东西），但添加了记忆化搜索来避免重复计算。若无记忆化搜索，计算量将是指数级爆炸，在 N=9 时约为 $4^{16}$ 次。

实现方式 ：从初始状态出发，递归地尝试所有可能的转移，同时用 memo 数组缓存已计算过的状态，避免重复。在达到终点时返回 0，逐层返回最大值。

解法三：费用流（最小费用最大流）

核心思想 ：将"两条路径取最大值"转化为网络流问题。

建模思路 ：

两条从 A 到 B 的路径 = 从源点到汇点流量为 2 的流
每个格子最多取一次 = 每个节点容量限制
取得数字最大 = 费用最大（转为最小费用取负值）

拆点处理 ：每个格子 (i,j) 拆成两个节点 in 和 out：

in → out 容量 1，费用 -map[i][j]（第一条路径取数）
in → out 再加容量 1，费用 0（第二条路径经过但不取数）

连边：(i,j) 的 out 连向 (i+1,j) 的 in 和 (i,j+1) 的 in，容量 2，费用 0。

代码实现

解法一：动态规划

完整代码

#include <stdio.h>

int N;
int map[10][10];
int dp[20][10][10]; // dp[步数][人1的行][人2的行]

int main() {
    scanf("%d", &N);

    int x, y, v;
    while (scanf("%d %d %d", &x, &y, &v) && (x || y || v))
        map[x][y] = v;

    // 初始化为-1表示不可达
    for (int k = 0; k < 20; k++)
        for (int i = 0; i < 10; i++)
            for (int j = 0; j < 10; j++)
                dp[k][i][j] = -1;

    dp[2][1][1] = map[1][1];

    // ========== 动态规划主循环 ==========
    for (int k = 2; k < 2 * N; k++) {
        for (int x1 = 1; x1 <= N; x1++) {
            int y1 = k - x1;
            if (y1 < 1 || y1 > N) continue;

            for (int x2 = x1; x2 <= N; x2++) {
                int y2 = k - x2;
                if (y2 < 1 || y2 > N) continue;
                if (dp[k][x1][x2] < 0) continue;

                // 尝试所有4种移动组合
                for (int m1 = 0; m1 <= 1; m1++) {
                    for (int m2 = 0; m2 <= 1; m2++) {
                        int nx1 = x1 + m1,     ny1 = y1 + (1 - m1);
                        int nx2 = x2 + m2,     ny2 = y2 + (1 - m2);

                        if (nx1 > N || ny1 > N) continue;
                        if (nx2 > N || ny2 > N) continue;

                        // 计算当前步收益
                        int gain = map[nx1][ny1];
                        if (nx1 != nx2) gain += map[nx2][ny2];

                        // 规范化：保证 a <= b
                        int a = nx1, b = nx2;
                        if (a > b) { int t = a; a = b; b = t; }

                        int newval = dp[k][x1][x2] + gain;
                        if (newval > dp[k + 1][a][b])
                            dp[k + 1][a][b] = newval;
                    }
                }
            }
        }
    }

    printf("%d\n", dp[2 * N][N][N]);
    return 0;
}

解法二：DFS + 记忆化搜索

#include <stdio.h>
#include <string.h>

// ========== DFS + 记忆化搜索 ==========

int N;
int map[10][10];
int memo[20][10][10];    // 记忆化数组
int visited[20][10][10]; // 标记是否计算过

int dfs(int k, int x1, int x2) {
    if (x1 == N && x2 == N) return 0;

    if (visited[k][x1][x2]) return memo[k][x1][x2];
    visited[k][x1][x2] = 1;

    int y1 = k - x1;
    int y2 = k - x2;
    int best = -1;

    for (int m1 = 0; m1 <= 1; m1++) {
        for (int m2 = 0; m2 <= 1; m2++) {
            int nx1 = x1 + m1,  ny1 = y1 + (1 - m1);
            int nx2 = x2 + m2,  ny2 = y2 + (1 - m2);

            if (nx1 > N || ny1 > N) continue;
            if (nx2 > N || ny2 > N) continue;

            int a = nx1, b = nx2;
            if (a > b) { int t = a; a = b; b = t; }

            int sub = dfs(k + 1, a, b);
            if (sub < 0) continue;

            int gain = map[nx1][ny1];
            if (nx1 != nx2) gain += map[nx2][ny2];

            if (gain + sub > best) best = gain + sub;
        }
    }

    memo[k][x1][x2] = best;
    return best;
}

int main() {
    scanf("%d", &N);

    int x, y, v;
    while (scanf("%d %d %d", &x, &y, &v) && (x || y || v))
        map[x][y] = v;

    memset(visited, 0, sizeof(visited));

    int start_val = map[1][1];
    int result = dfs(2, 1, 1);

    printf("%d\n", result >= 0 ? start_val + result : 0);
    return 0;
}

解法三：费用流（最小费用最大流）

#include <stdio.h>
#include <string.h>

#define MAXN 1000
#define MAXE 10000
#define INF  0x3f3f3f3f

// ========== 链式前向星数据结构 ==========

int head[MAXN], nxt[MAXE], to[MAXE], cap[MAXE], cost[MAXE], tot;

void init() {
    memset(head, -1, sizeof(head));
    tot = 0;
}

void add_edge(int u, int v, int c, int w) {
    to[tot] = v; cap[tot] = c; cost[tot] = w; nxt[tot] = head[u]; head[u] = tot++;
    to[tot] = u; cap[tot] = 0; cost[tot] = -w; nxt[tot] = head[v]; head[v] = tot++;
}

int dist[MAXN], in_queue[MAXN], prevv[MAXN], preve[MAXN];
int queue[MAXN * 100];

// ========== SPFA算法 ==========

int spfa(int s, int t, int n) {
    memset(dist, 0x3f, sizeof(int) * (n + 1));
    memset(in_queue, 0, sizeof(int) * (n + 1));
    dist[s] = 0;

    int front = 0, rear = 0;
    queue[rear++] = s;
    in_queue[s] = 1;

    // SPFA主循环
    while (front != rear) {
        int u = queue[front++];
        in_queue[u] = 0;

        // 松弛边
        for (int e = head[u]; e != -1; e = nxt[e]) {
            if (cap[e] > 0 && dist[to[e]] > dist[u] + cost[e]) {
                dist[to[e]] = dist[u] + cost[e];
                prevv[to[e]] = u;
                preve[to[e]] = e;

                if (!in_queue[to[e]]) {
                    queue[rear++] = to[e];
                    in_queue[to[e]] = 1;
                }
            }
        }
    }

    return dist[t] < INF;
}

// ========== 最小费用最大流 ==========

int mcmf(int s, int t, int n) {
    int total_cost = 0;

    while (spfa(s, t, n)) {
        int flow = INF;
        for (int v = t; v != s; v = prevv[v])
            if (cap[preve[v]] < flow) flow = cap[preve[v]];

        for (int v = t; v != s; v = prevv[v]) {
            cap[preve[v]] -= flow;
            cap[preve[v] ^ 1] += flow;
        }

        total_cost += dist[t] * flow;
    }

    return total_cost;
}

int main() {
    int N;
    scanf("%d", &N);

    int map[10][10] = {0};
    int x, y, v;
    while (scanf("%d %d %d", &x, &y, &v) && (x || y || v))
        map[x][y] = v;

    init();

    int S = 2 * N * N + 1;
    int T = 2 * N * N + 2;
    int total_nodes = T;

    #define IN(i,j)  ((i-1)*N+(j))
    #define OUT(i,j) (N*N+(i-1)*N+(j))

    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            if (map[i][j] > 0) {
                add_edge(IN(i,j), OUT(i,j), 1, -map[i][j]);
                add_edge(IN(i,j), OUT(i,j), 1, 0);
            } else {
                add_edge(IN(i,j), OUT(i,j), 2, 0);
            }

            if (j + 1 <= N) add_edge(OUT(i,j), IN(i,j+1), 2, 0);
            if (i + 1 <= N) add_edge(OUT(i,j), IN(i+1,j), 2, 0);
        }
    }

    add_edge(S, IN(1,1), 2, 0);
    add_edge(OUT(N,N), T, 2, 0);

    int ans = -mcmf(S, T, total_nodes);
    printf("%d\n", ans);
    return 0;
}

时间复杂度与优缺点

解法一：动态规划

时间复杂度 ：$O(N^3)$

状态数：$O(N^2) \times O(N^2) / 2 = O(N^4)$，但由于降维和 x1、x2 的约束，实际为 $O(N^3)$
每个状态有 4 次转移

空间复杂度 ：$O(N^3)$

dp 数组大小为 $2N \times N \times N$

优点：

思路清晰，易于理解
一次遍历解决问题
代码相对简洁

缺点：

空间占用较大（N=9 时约 1.3MB）

解法二：DFS + 记忆化搜索

时间复杂度 ：$O(N^3)$

状态数与 DP 相同
每个状态最多计算一次（记忆化）

空间复杂度 ：$O(N^3)$

memo 和 visited 数组各占 $O(N^3)$

优点：

逻辑自然，从上向下思考
易于添加剪枝（虽然此题中剪枝不多）
可灵活调整状态定义

缺点：

递归调用栈深度为 $O(N)$（栈空间）
空间复杂度与 DP 相同

解法三：费用流

时间复杂度 ：$O(Flow \times SPFA) = O(2 \times E \log V) = O(N^2 \times N^2) = O(N^4)$

流量为 2
SPFA 每次 $O(V \log V)$，其中 $V = O(N^2)$，$E = O(N^2)$

空间复杂度 ：$O(V + E) = O(N^2)$

图的存储空间

优点：

适用于更一般的场景（多条路径、带限制的图等）
代码框架可复用于其他费用流问题
空间占用相对较少

缺点：

时间复杂度最高（约 $O(N^4)$ vs $O(N^3)$）
代码长且复杂，易出错
难度陡升，超出竞赛难度范围

对比与总结

特性	解法一 DP	解法二 DFS	解法三费用流
易理解度	★★★★☆	★★★★☆	★☆☆☆☆
实现难度	★★☆☆☆	★★☆☆☆	★★★★★
时间复杂度	$O(N^3)$	$O(N^3)$	$O(N^4)$
空间复杂度	$O(N^3)$	$O(N^3)$	$O(N^2)$
推荐指数	★★★★★	★★★★☆	★★☆☆☆

结论：对于此题，解法一（DP） 是最佳选择，既清晰高效又不过度复杂。解法二适合想要练习 DFS 的同学。解法三虽然优雅，但对于 N≤9 的规模效率不如 DP，仅作扩展知识。

动态规划 on 望境

状态转移方程与动态规划

一、何为动态规划

1. 最优子结构

2. 重叠子问题

二、何为状态转移方程

1. “状态”

2. 状态转移方程

三、典型例题

例 1：线性 DP - 爬楼梯

问题

思路分析

代码实现

时间复杂度与优缺点

例 2：线性 DP - 打家劫舍

问题

思路分析

代码实现

时间复杂度与优缺点

例 3：背包 DP - 0/1 背包

问题

思路分析

代码实现

时间复杂度与优缺点

例 4：序列 DP - 最长公共子序列（LCS）

问题

思路分析

代码实现

时间复杂度与优缺点

例 5：区间 DP - 戳气球

问题

思路分析

代码实现

时间复杂度与优缺点

四、DP 模型总结

总结与建议

P1004 [NOIP 2000 提高组] 方格取数 分析与总结

问题

题目来源

问题描述

输入输出

样例

约束条件

问题分析

思路分析

解法一：动态规划

解法二：DFS + 记忆化搜索

解法三：费用流（最小费用最大流）

代码实现

解法一：动态规划

解法二：DFS + 记忆化搜索

解法三：费用流（最小费用最大流）

时间复杂度与优缺点

解法一：动态规划

解法二：DFS + 记忆化搜索

解法三：费用流

对比与总结

P1004 [NOIP 2000 提高组] 方格取数分析与总结