从棋盘到代码：动态规划解“最低通行费”的实战拆解

1. 棋盘游戏中的动态规划初探

第一次接触"最低通行费"问题时，我正沉迷于棋盘类游戏。想象你站在一个N×N的棋盘左上角，每个格子都标着不同的数字，代表经过该格子需要缴纳的费用。游戏规则很简单：你只能向右或向下移动，目标是用最少的"总过路费"到达右下角。这不就是动态规划的经典场景吗？

动态规划听起来高大上，其实就像玩闯关游戏时记录每个关卡的"最优存档"。在棋盘问题中，我们需要记录从起点到每个格子的最低费用。具体来说：

• 初始状态：起点(1,1)的费用就是该格子的数字本身
• 移动规则：每个格子的最低费用=左边或上边格子的最低费用（取较小值）+当前格子费用
• 边界情况：第一行只能从左往右走，第一列只能从上往下走

python复制# 伪代码示例
def min_path_cost(grid):
    rows = len(grid)
    cols = len(grid[0])
    dp = [[0]*cols for _ in range(rows)]
    dp[0][0] = grid[0][0]
    # 初始化第一行和第一列
    for i in range(1, rows):
        dp[i][0] = dp[i-1][0] + grid[i][0]
    for j in range(1, cols):
        dp[0][j] = dp[0][j-1] + grid[0][j]
    # 填充其他格子
    for i in range(1, rows):
        for j in range(1, cols):
            dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
    return dp[-1][-1]

这种解法的时间复杂度是O(n²)，因为需要遍历整个棋盘。在实际编程竞赛中，遇到类似"只能向右/向下移动"的约束条件，基本可以确定是坐标型动态规划问题。

2. 从物流场景理解状态转移

去年帮朋友优化仓库拣货路径时，我意外发现这和"最低通行费"问题异曲同工。假设仓库被划分成网格，每个区域有不同的通行成本（比如重型设备区绕行成本高），拣货员从左上角仓库门出发，要到右下角取货，如何规划最经济的路径？

这个现实案例让我对状态转移有了更深理解。关键点在于：

1. 最优子结构：到达某位置的最优路径必然包含前面某位置的最优路径
2. 无后效性：当前决策只受左边和上方格子影响，与后续路径无关
3. 重叠子问题：多个路径会经过相同中间点，避免重复计算

在OpenJudge等平台做题时，识别这类问题的特征很重要：

• 题目通常给出矩阵形式的输入数据
• 移动方向受限（如只能向右/向下）
• 求最小/最大路径和或类似指标

cpp复制// C++优化版本（使用滚动数组）
int minCost(vector<vector<int>>& grid) {
    int n = grid.size();
    vector<int> dp(n, 0);
    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 < n; ++i) {
        dp[0] += grid[i][0];
        for (int j = 1; j < n; ++j)
            dp[j] = min(dp[j-1], dp[j]) + grid[i][j];
    }
    return dp[n-1];
}

使用滚动数组可以将空间复杂度从O(n²)降到O(n)，这在处理大规模数据时特别有用。不过要注意，这会丢失具体路径信息，如果题目要求输出路径，还是需要完整的二维DP数组。

3. 信息学奥赛中的解题技巧

参加过几次信息学奥赛辅导后，我总结出这类题目的常见"陷阱"和应对策略：

边界处理是最容易出错的地方。比如：

• 矩阵索引从0开始还是1开始？（竞赛题常用1-based）
• 第一行和第一列需要特殊处理
• 输入数据可能包含负数（虽然本题都是正数）

调试技巧：

1. 先打印出初始化的DP数组
2. 对于小规模测试用例（如3×3矩阵），手动演算预期结果
3. 使用assert检查边界条件

python复制# Python调试示例
def test_min_path():
    grid = [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
    ]
    assert min_path_cost(grid) == 21  # 路径1→2→3→6→9
    edge_case = [[7]]
    assert min_path_cost(edge_case) == 7

在信息学奥赛/OpenJudge环境中，还要注意：

• 输入输出要符合题目要求（比如本题的输入格式）
• 变量范围要合理（本题N≤100，不需要大整数处理）
• 避免不必要的计算（如本题不需要记录路径）

一个实用的解题模板：

1. 仔细阅读题目，确认是坐标型DP问题
2. 定义DP数组和状态含义
3. 确定初始状态
4. 写出状态转移方程
5. 处理边界条件
6. 确定最终答案存储位置

4. 算法优化与变种思考

实际工程中遇到的类似问题往往更复杂。比如去年做的物流系统项目，就遇到了几个变种：

变种1：多方向移动
如果允许对角线移动（向右下），状态转移方程需要增加来自左上方的路径：
dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + cost[i][j]

变种2：障碍物处理
某些格子不可通行（类似迷宫问题），处理方式：

python复制if grid[i][j] == 障碍标记:
    dp[i][j] = INF  # 设为极大值表示不可达
else:
    dp[i][j] = min(上,左) + grid[i][j]

变种3：起点终点不固定
比如要从任意起点到任意终点，可以：

• 将DP数组定义为dp[start_i][start_j][end_i][end_j]
• 或者改造为单源最短路径问题

对于大规模数据，还可以考虑：

• 并行计算：每行或每列的计算相互独立
• 记忆化搜索：用递归+缓存的方式实现
• 启发式算法：如A*搜索，当矩阵很大时可能更高效

java复制// Java记忆化搜索实现
class Solution {
    private int[][] memo;
    private int[][] grid;
    
    public int minPathCost(int[][] grid) {
        this.grid = grid;
        int n = grid.length;
        memo = new int[n][n];
        for (int[] row : memo) Arrays.fill(row, -1);
        return dfs(n-1, n-1);
    }
    
    private int dfs(int i, int j) {
        if (i == 0 && j == 0) return grid[0][0];
        if (memo[i][j] != -1) return memo[i][j];
        int res = Integer.MAX_VALUE;
        if (i > 0) res = Math.min(res, dfs(i-1, j));
        if (j > 0) res = Math.min(res, dfs(i, j-1));
        return memo[i][j] = res + grid[i][j];
    }
}

在准备算法竞赛时，建议从标准解法入手，掌握后再尝试变种。我通常会创建个"算法笔记本"，记录每种变型的解题模板和注意事项。