在面对动态规划问题时，建立一个系统的思考框架能大大提升解题效率。本文以 LeetCode 64 题为例，展示如何用"自我提问模板"梳理 DP 思路，并在实战中验证其有效性。
什么是动态规划自我提问模板？
动态规划的本质是"记忆化递归 + 最优子结构"，但很多时候我们会在定义状态、推导转移方程时感到困惑。为了更系统地分析 DP 问题，我总结了一套"自我提问模板"，包含以下关键要素：
- dp[i][j] 定义：明确每个状态代表什么
- 默认值：初始化的边界条件
- 外部遍历：如何遍历整个状态空间
- choice：在每个状态下有哪些选择（如果适用）
- cost：每个选择的代价（如果适用）
- 转移条件：什么情况下进行状态转移
- 转移方程：如何从子问题推导到当前问题
- 返回值：最终答案在状态空间的哪个位置
bash
我的思路
dp[i][j]定义：dp 和 grid 大小相同，dp[i][j]表示对应走到 grid[i][j] 的最小sum
默认值：dp[0][0] = grid[0][0]
外部遍历：遍历 grid，i 为行，j 为列，跳过 i = 0，j = 0
choice: N/A
cost: N/A
转移条件：N/A
转移方程：i = 0: dp[i][j] = dp[i][j-1] + grid[i][j]
j = 0: dp[i][j] = dp[i-1][j] + grid[i][j]
else dp[i][j] = min(dp[i][j-1] + grid[i][j], dp[i-1][j] + grid[i][j])
返回值：dp[gridSize][gridColSize[gridSize - 1]] 行的最小值实战案例：LeetCode 64. Minimum Path Sum
题目描述
给定一个 m x n 的网格 grid，每个格子里是一个非负整数。从左上角 (0,0) 出发，只能向右或向下移动，走到右下角 (m-1, n-1)。要求找到一条路径，使路径上所有格子数字之和最小，并返回这个最小和。
使用模板分析
1. dp[i][j] 定义
dp 和 grid 大小相同，dp[i][j] 表示对应走到 grid[i][j] 的最小sum
这个定义很直观：我们需要知道"到达每个格子时的最小路径和"，因此 dp[i][j] 就表示从起点 (0,0) 走到位置 (i,j) 的最小路径和。
2. 默认值
dp[0][0] = grid[0][0]
起点是我们的初始状态，它的最小路径和就是起点格子本身的值。
3. 外部遍历
遍历 grid，i 为行，j 为列，跳过 i = 0，j = 0
我们需要填充整个 dp 数组，按行列顺序遍历。由于起点已经初始化，可以跳过 (0,0)。
4. choice & cost
N/A
在这道题中，我们不需要显式地考虑"选择"和"代价"的概念，因为路径是确定性的：只能向右或向下走，没有多个选择需要对比。
5. 转移条件
N/A
这道题的转移是无条件的，每个格子都需要根据其左边和上边的格子更新。
6. 转移方程
i = 0: dp[i][j] = dp[i][j-1] + grid[i][j] // 第一行只能从左边来
j = 0: dp[i][j] = dp[i-1][j] + grid[i][j] // 第一列只能从上边来
else: dp[i][j] = min(dp[i][j-1] + grid[i][j], dp[i-1][j] + grid[i][j]) // 其他位置取左边和上边的最小值这个转移方程体现了 DP 的核心：
- 对于第一行（i=0），只能从左边走过来
- 对于第一列（j=0），只能从上边走过来
- 对于其他位置，可以从左边或上边过来，我们选择路径和更小的那条
7. 返回值
注意：原始思路写的是"dp[gridSize][gridColSize[gridSize - 1]] 行的最小值"，这是错误的！
正确的返回值应该是：dp[gridSize-1][gridColSize[gridSize-1]-1]
即右下角那个格子的值，因为题目要求必须走到右下角，而不是最后一行的任意位置。
C 语言代码实现
c
#include <stdlib.h>
#define INF_MAX 0x7fffffff
#define MIN(a, b) ((a) < (b) ? (a) : (b))
int minPathSum(int **grid, int gridSize, int *gridColSize) {
int i, j, result, col_size;
int **dp;
// 分配 dp 数组
dp = (int **)malloc(gridSize * sizeof(int *));
for (i = 0; i < gridSize; i++) {
col_size = gridColSize[i];
dp[i] = (int *)malloc(col_size * sizeof(int));
for (j = 0; j < col_size; j++)
dp[i][j] = INF_MAX; // 初始化为最大值
}
// 设置起点
dp[0][0] = grid[0][0];
// 遍历整个 grid
for (i = 0; i < gridSize; i++) {
col_size = gridColSize[i];
for (j = 0; j < col_size; j++) {
if (i == 0 && j == 0)
continue; // 跳过起点
if (i == 0)
// 第一行：只能从左边来
dp[i][j] = dp[i][j - 1] + grid[i][j];
else if (j == 0)
// 第一列：只能从上边来
dp[i][j] = dp[i - 1][j] + grid[i][j];
else
// 其他位置：取左边和上边的最小值
dp[i][j] = MIN(dp[i][j - 1] + grid[i][j],
dp[i - 1][j] + grid[i][j]);
}
}
// 获取右下角的结果
col_size = gridColSize[gridSize - 1];
result = dp[gridSize - 1][col_size - 1];
// 释放内存
for (i = 0; i < gridSize; i++)
free(dp[i]);
free(dp);
return result;
}模板的价值
通过这个案例，我们可以看到自我提问模板的价值：
- 系统性：按照模板逐项分析，不容易遗漏关键要素
- 纠错性：在填写"返回值"时，发现了原始思路的错误
- 可复用：这个模板可以应用到其他 DP 问题上
当你面对新的 DP 问题时，不妨试试用这个模板梳理思路：
- 先明确状态定义
- 找出初始值和边界条件
- 确定遍历顺序
- 分析选择和代价（如果有）
- 推导转移方程
- 确认返回值
这样的思考流程能帮助你更快地理清思路，写出正确的代码。
总结
动态规划的难点不在于写代码，而在于理清状态和转移的逻辑。通过建立一套自我提问的模板，我们可以：
- 将复杂问题拆解成可回答的小问题
- 系统地分析 DP 的各个要素
- 及时发现思路中的错误
希望这个模板能帮助你在 DP 的道路上走得更顺畅！