找往期文章包括但不限于本期文章中不懂的知识点：

个人主页：我要学编程程(ಥ_ಥ)-CSDN博客

所属专栏：动态规划

目录

62.不同路径

63.不同路径Ⅱ

LCR166.珠宝的最高价值

931.下降路径最小和

64.最小路径和

174.地下城游戏 

---

62.不同路径

题目：

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：

​

输入：m = 3, n = 7
输出：28

示例 2：

输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：

输入：m = 7, n = 3
输出：28

示例 4：

输入：m = 3, n = 3
输出：6

提示：

• 1 <= m, n <= 100
• 题目数据保证答案小于等于 2 * 10^9

思路：

1、确定dp[i][j]以及i、j的含义；

dp[i][j]表示到达i、j位置时，总共的方法路径

2、推导公式；

根据最近一步来进行推导，即[i-1, j]和[i, j-1]位置。由于这两个位置到达[i, j]位置只需要往下或者往右走一步就可以了（就是原来的方法路径总数），因此到达[i, j]位置的方法路径总数就是两者之和。
dp[i][j] = dp[i][j-1] + dp[i-1][j]

3、初始化dp数组；

为了避免数组下标越界问题，得确保 j-1 >= 0 && i-1 >= 0，也就是将 i==0 和 j==0 的位置进行初始化即可。
注意：从[0,0]位置到达[i, 1]只有一种方法，同理，到达[1, j]也只有一种方法。

4、遍历顺序；

由于dp[i][j] = dp[i][j-1] + dp[i-1][j]，因此在初始化[i, j]位置之时，需要对[i,j-1]和[i-1,j]位置的值明确，即从上到下、从左到右进行初始化即可。

5、打印数组

代码实现：

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        // 将 i==0 和 j==0 的位置全部初始化为1
        for (int i = 0; i < n; i++) {
            dp[0][i] = 1;
        }
        for (int i = 0; i < m; i++) {
            dp[i][0] = 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];
            }
        }
        return dp[m-1][n-1];
    }
}

上述代码在初始化的部分比较繁杂，需要单独进行，那我们就可以将dp数组多申请一行以及一列，但是这就需要考虑应该问题了：如何确保新的dp数组和原始的dp数组值相对应呢？

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m+1][n+1];
        dp[0][1] = 1; // 将[0,1]位置初始化为1即可
        // 原始的dp表的[0,0]是和新dp表的[1,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];
            }
        }
        return dp[m][n];
    }
}

63.不同路径Ⅱ

题目：

给定一个 m x n 的整数数组 grid。一个机器人初始位于 左上角（即 grid[0][0]）。机器人尝试移动到 右下角（即 grid[m - 1][n - 1]）。机器人每次只能向下或者向右移动一步。

网格中的障碍物和空位置分别用 1 和 0 来表示。机器人的移动路径中不能包含 任何 有障碍物的方格。

返回机器人能够到达右下角的不同路径数量。

测试用例保证答案小于等于 2 * 109。

示例 1：

输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：2
解释：3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：
1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

示例 2：

输入：obstacleGrid = [[0,1],[0,0]]
输出：1

提示：

• m == obstacleGrid.length
• n == obstacleGrid[i].length
• 1 <= m, n <= 100
• obstacleGrid[i][j] 为 0 或 1

思路：

1、确定dp[i][j]以及i、j的含义；

dp[i][j]表示：到达i、j位置时，总共的方法路径数

2、推导公式；

根据最近一步来进行推导，即[i-1, j]和[i, j-1]位置。由于这两个位置到达[i, j]位置只需要往下或者往右走一步就可以了（就是原来的方法路径总数），因此到达[i, j]位置的方法路径总数就是两者之和。但要注意的是如果原始数组 [i-1, j] 或者 [i, j-1]位置是障碍物的话，那么是不能到达 [i, j]位置的，因此dp数组的值是不能对其相加的。

3、初始化；

为了避免数组下标越界问题，得确保 j-1 >= 0 && i-1 >= 0，也就是将 i==0 和 j==0 的位置进行初始化，同样要注意，由于存在障碍物的情况，因此若在初始化时，遇到了障碍物后，该位置及其后面的位置都是不能初始化为1的，因为根本就到达不了后面的位置。

4、遍历顺序；

由于dp[i][j] = dp[i][j-1] + dp[i-1][j]，因此在初始化[i, j]位置之时，需要对[i,j-1]和[i-1,j]位置的值明确，即从上到下、从左到右进行初始化即可。

5、打印dp数组

代码实现：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length, n = obstacleGrid[0].length;
        // 排除特殊情况：障碍物在目标位置
        if (obstacleGrid[m-1][n-1] == 1) {
            return 0;
        }
        int[][] dp = new int[m][n];
        // 将i==0和j==0的位置进行初始化
        // 如果没有遇到障碍物就一直初始化为1
        // 如果遇到了，则后面的无需初始化了（到达不了）
        for (int i = 0; i < m; i++) {
            if (obstacleGrid[i][0] != 1) {
                dp[i][0] = 1;
            } else {
                break;
            }
        }
        for (int i = 0; i < n; i++) {
            if (obstacleGrid[0][i] != 1) {
                dp[0][i] = 1;
            } else {
                break;
            }
        }

        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                // 判断正上方和左侧是否是障碍物
                // 如果是的话，根本就到达不了，不需要加上该位置的值
                if (obstacleGrid[i][j-1] != 1) {
                    dp[i][j] += dp[i][j-1];
                }
                if (obstacleGrid[i-1][j] != 1) {
                    dp[i][j] += dp[i-1][j];
                }
            }
        }

        return dp[m-1][n-1];
    }
}

同样上述代码的初始化部分过于繁琐，我们也可以多申请一行和一列来处理数组越界的情况：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length, n = obstacleGrid[0].length;
        // 排除特殊情况
        if (obstacleGrid[m-1][n-1] == 1) {
            return 0;
        }
        int[][] dp = new int[m+1][n+1];
        dp[0][1] = 1; // 也可以初始化[1,0]位置
        
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                // dp[1,1]对应obstacleGrid[0,0]
                if (obstacleGrid[i-1][j-1] != 1) {
                    dp[i][j] = dp[i][j-1] + dp[i-1][j];
                }
            }
        }

        return dp[m][n];
    }
}

LCR166.珠宝的最高价值

题目：

现有一个记作二维矩阵 frame 的珠宝架，其中 frame[i][j] 为该位置珠宝的价值。拿取珠宝的规则为：

• 只能从架子的左上角开始拿珠宝
• 每次可以移动到右侧或下侧的相邻位置
• 到达珠宝架子的右下角时，停止拿取

注意：珠宝的价值都是大于 0 的。除非这个架子上没有任何珠宝，比如 frame = [[0]]。

示例 1：

输入：frame = [[1,3,1],[1,5,1],[4,2,1]]
输出：12
解释：路径 1→3→5→2→1 可以拿到最高价值的珠宝

提示：

• 0 < frame.length <= 200
• 0 < frame[0].length <= 200

思路：

1、确定dp[i][j]以及i、j的含义；

dp[i][j]表示：到达i、j位置时，珠宝的价值最大。

2、推导公式；

根据最近一步来进行推导，即[i-1, j]和[i, j-1]位置。由于这两个位置到达[i, j]位置只需要往下或者往右走一步就可以了，在原始的基础上，加上当前位置的值，然后比较两者得出最大值，更新i、j位置即可。

3、初始化；

为了避免数组下标越界问题，得确保 j-1 >= 0 && i-1 >= 0，也就是将 i==0 和 j==0 的位置进行初始化，但要注意的是，初始化的值为到达i、j位置的珠宝价值

4、遍历顺序；

由于dp[i][j] = dp[i][j-1] + dp[i-1][j]，因此在初始化[i, j]位置之时，需要对[i,j-1]和[i-1,j]位置的值明确，即从上到下、从左到右进行初始化即可。

5、打印dp数组

代码实现：

class Solution {
    public int jewelleryValue(int[][] frame) {
        int m = frame.length, n = frame[0].length;
        int[][] dp = new int[m][n];
        // 将i==0和j==0的位置进行初始化
        dp[0][0] = frame[0][0];
        for (int i = 1; i < m; i++) {
            dp[i][0] = frame[i][0] + dp[i-1][0];
        }
        for (int i = 1; i < n; i++) {
            dp[0][i] = frame[0][i] + dp[0][i-1];
        }

        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]) + frame[i][j];
            }
        }

        return dp[m-1][n-1];
    }
}

同样在初始化时，也可以简化，为了避免越界问题，还是选择多申请一行与一列，但在初始化时就要注意了： 

class Solution {
    public int jewelleryValue(int[][] frame) {
        int m = frame.length, n = frame[0].length;
        int[][] dp = new int[m+1][n+1];
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                // 注意: frame数组的下标
                dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]) + frame[i-1][j-1];
            }
        }

        return dp[m][n];
    }
}

931.下降路径最小和

题目：

给你一个 n x n 的 方形 整数数组 matrix ，请你找出并返回通过 matrix 的下降路径 的 最小和 。

下降路径 可以从第一行中的任何元素开始，并从每一行中选择一个元素。在下一行选择的元素和当前行所选元素最多相隔一列（即位于正下方或者沿对角线向左或者向右的第一个元素）。具体来说，位置 (row, col) 的下一个元素应当是 (row + 1, col - 1)、(row + 1, col) 或者 (row + 1, col + 1) 。

示例 1：

输入：matrix = [[2,1,3],[6,5,4],[7,8,9]]
输出：13
解释：如图所示，为和最小的两条下降路径

示例 2：

输入：matrix = [[-19,57],[-40,-5]]
输出：-59
解释：如图所示，为和最小的下降路径

提示：

• n == matrix.length == matrix[i].length
• 1 <= n <= 100
• -100 <= matrix[i][j] <= 100

思路：

dp[i][j]的含义：到达[i, j]位置时，路径最小和

推导公式：根据最近一步来进行推导，即[i-1, j-1]、[i-1, j]、[i-1, j+1]位置，[i, j]位置可以由上述三个位置求出，我们只需要拿到三者的最小值，然后再加上当前位置在原始数组中的值即可。dp[i][j] = min(dp[i-1][j], dp[i-1][j-1], dp[i-1][j+1]) + matrix[i][j]

初始化：把i==0的位置全部初始化为matrix数组的值

遍历顺序：从上到下【从左到右可以，从右到左也是可以的】

返回值：遍历最后一行，求出最小值即可

代码实现：

class Solution {
    public int minFallingPathSum(int[][] matrix) {
        int n = matrix.length;
        int[][] dp = new int[n][n];

        // 先将第一行全部初始化
        for (int i = 0; i < n; i++) {
            dp[0][i] = matrix[0][i];
        }

        for (int i = 1; i < n; i++) {
            for (int j = 0; j < n; j++) {
                // 求出三者的值（注意初始化问题）
                int x = Integer.MAX_VALUE, y = Integer.MAX_VALUE, z = Integer.MAX_VALUE;
                if (j-1 >= 0) {
                    x = dp[i-1][j-1];
                }
                y = dp[i-1][j];
                if (j+1 < n) {
                    z = dp[i-1][j+1];
                }
                dp[i][j] = Math.min(Math.min(x, y), z) + matrix[i][j];
            }
        }

        // 遍历最后一行求出结果
        int ret = Integer.MAX_VALUE; // 不能初始化为0
        for (int i = 0; i < n; i++) {
            if (dp[n-1][i] < ret) {
                ret = dp[n-1][i];
            }
        }

        return ret;
    }
}

上述代码在处理数组越界的问题上，是直接把第一行提前初始化了，并且后续在循环时，直接去判断该位置是否合法，如果合法再计算，反之，则是直接将该位置的标志初始化为最大值。这种处理方法也是有点繁琐的，我们可以直接将数组可能会越界的地方加上空间即可，处理方式就是直接在原数组的基础上加上一行和两列：

class Solution {
        public int minFallingPathSum(int[][] matrix) {
        int n = matrix.length;
        int[][] dp = new int[n+1][n+2]; // 多加一行、两列

        // 将两侧的值全部初始化为最大值
        for (int i = 1; i <= n; i++) {
            dp[i][0] = Integer.MAX_VALUE;
            dp[i][n+1] = Integer.MAX_VALUE;
        }

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                // 求出三者的值
                int x = dp[i-1][j-1], y = dp[i-1][j], z = dp[i-1][j+1];
                dp[i][j] = Math.min(Math.min(x, y), z) + matrix[i-1][j-1]; // 注意下标
            }
        }

        // 注意 ret 的初始值
        int ret = Integer.MAX_VALUE;
        // 遍历最后一行得出结果
        for (int i = 1; i <= n; i++) {
            if (dp[n][i] < ret) {
                ret = dp[n][i];
            }
        }

        return ret;
    }
}

64.最小路径和

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

说明：每次只能向下或者向右移动一步。

示例 1：

输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
输出：7
解释：因为路径 1→3→1→1→1 的总和最小。

示例 2：

输入：grid = [[1,2,3],[4,5,6]]
输出：12

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 200
• 0 <= grid[i][j] <= 200

思路：

dp[i][j]的含义：到达[i, j]位置时，路径最小和

推导公式：根据最近一步来进行推导，即[i，j-1]、[i-1，j]位置，[i, j]位置可以由上述两个位置求出，我们只需要拿到两者的最小值，然后再加上当前位置在原始数组中的值即可。dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]

初始化：把i == 0和j == 0的位置全部初始化。

遍历顺序：从上到下、从左到右

返回值：返回[m-1，n-1]位置的值即可

代码实现： 

class Solution {
    public int minPathSum(int[][] grid) {        
        int m = grid.length, n = grid[0].length;
        int[][] dp = new int[m][n];

        // 将 i==0 和 j==0 的位置初始化
        dp[0][0] = grid[0][0];
        for (int i = 1; i < n; i++) {
            dp[0][i] = dp[0][i-1] + grid[0][i];
        }
        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] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
            }
        }

        return dp[m-1][n-1];
    }
}

同样可以在原数组的基础上加上一行一列来避免数组越界的问题。

还是需要考虑两个问题：1、下标的映射关系；2、如何确保新dp数组中的值依旧是正确的。

原始的dp数组[0，0]位置对应着新dp数组的[1，1]位置，因此新dp数组下标映射到原始dp数组下标时，行与列都需要-1。

至于如何确保dp数组是否正确，我们先来看新dp数组的[1，1]位置，对应原始位置时，只需要求grid数组的值即可，因此新dp数组的[0,1]和[1,0]位置都是不能影响到的，即初始化为0；再来看新dp数组的[1,2]位置，对应原始dp数组时，不需要考虑[0，2]位置，同样该位置对应在dp数组也是不能影响求最小值的，但是由于前面存在了最小值了，因此该位置不能初始化为0，只能初始化为最大值才能不影响，同理后续的位置都是如此。

class Solution {
    public int minPathSum(int[][] grid) {
        // 创建dp表、初始化、填表、返回值
        
        int m = grid.length, n = grid[0].length;
        int[][] dp = new int[m+1][n+1]; // 多加一行与一列

        // 将虚拟行与列都初始化为最大值
        for (int i = 0; i <= n; i++) {
            dp[0][i] = Integer.MAX_VALUE;
        }
        for (int i = 0; i <= m; i++) {
            dp[i][0] = Integer.MAX_VALUE;
        }
        // 将[0,1]和[1,0]初始化为0
        dp[0][1] = dp[1][0] = 0;

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i-1][j-1];
            }
        }

        return dp[m][n];
    }
}

174.地下城游戏 

题目：

恶魔们抓住了公主并将她关在了地下城 dungeon 的 右下角 。地下城是由 m x n 个房间组成的二维网格。我们英勇的骑士最初被安置在 左上角 的房间里，他必须穿过地下城并通过对抗恶魔来拯救公主。

骑士的初始健康点数为一个正整数。如果他的健康点数在某一时刻降至 0 或以下，他会立即死亡。

有些房间由恶魔守卫，因此骑士在进入这些房间时会失去健康点数（若房间里的值为负整数，则表示骑士将损失健康点数）；其他房间要么是空的（房间里的值为 0），要么包含增加骑士健康点数的魔法球（若房间里的值为正整数，则表示骑士将增加健康点数）。

为了尽快解救公主，骑士决定每次只 向右 或 向下 移动一步。

返回确保骑士能够拯救到公主所需的最低初始健康点数。

注意：任何房间都可能对骑士的健康点数造成威胁，也可能增加骑士的健康点数，包括骑士进入的左上角房间以及公主被监禁的右下角房间。

示例 1：

输入：dungeon = [[-2,-3,3],[-5,-10,1],[10,30,-5]]
输出：7
解释：如果骑士遵循最佳路径：右 -> 右 -> 下 -> 下 ，则骑士的初始健康点数至少为 7 。

示例 2：

输入：dungeon = [[0]]
输出：1

提示：

• m == dungeon.length
• n == dungeon[i].length
• 1 <= m, n <= 200
• -1000 <= dungeon[i][j] <= 1000

思路：如果这道题根据我们前面的经验来做的话，会发现根本就行不通，因为下一个位置或者说后面的位置由于存在不确定性的情况，我们只能从最后一个位置开始往前推，直至到达骑士所在的位置。

代码实现：

class Solution {
    public int calculateMinimumHP(int[][] dungeon) {
        int m = dungeon.length, n = dungeon[0].length;
        int[][] dp = new int[m][n];

        // 初始化 最后一行 和 最后一列
        dp[m-1][n-1] = dungeon[m-1][n-1] >= 0 ? 1 : (-dungeon[m-1][n-1] + 1);
        for (int i = m-2; i >= 0; i--) {
            dp[i][n-1] = dp[i+1][n-1] - dungeon[i][n-1];
            if (dp[i][n-1] < 1) {
                dp[i][n-1] = 1;
            }
        }
        for (int i = n-2; i >= 0; i--) {
            dp[m-1][i] = dp[m-1][i+1] - dungeon[m-1][i];
            if (dp[m-1][i] < 1) {
                dp[m-1][i] = 1;
            }
        }

        for (int i = m-2; i >= 0; i--) {
            for (int j = n-2; j >= 0; j--) {
                dp[i][j] = Math.min(dp[i+1][j], dp[i][j+1]) - dungeon[i][j];
                if (dp[i][j] < 1) {
                    dp[i][j] = 1;
                }
            }
        }

        return dp[0][0];
    }
}

同样也可以通过多申请一行与一列避免越界的情况，还是考虑两个问题：下标的映射以及如何确保新dp数组的值是否正确？由于我们这里的加行与加列是在最后一行与最后一列，所以新dp数组的[0, 0]位置还是对应着原始dp数组的[0, 0]位置。由于推导公式中，是求两个位置的最小值，因此为了后续不影响得初始化为最大值，但[m-1，n-1]位置需要计算的位置是 [m，n-1]和[m-1，n]，这两个位置的值如果都是最大值的话，那么最终会导致结果错误，根据最初的初始结果来推：如果当前位置是大于等于0的话，就需要初始化为1；反之，则是1-该位置的值，那么将上述两个位置初始化为1即可。

class Solution {
    public int calculateMinimumHP(int[][] dungeon) {
        int m = dungeon.length, n = dungeon[0].length;
        int[][] dp = new int[m+1][n+1];

        // 将最后一行和最后一列初始化为最大值
        for (int i = 0; i <= m; i++) {
            dp[i][n] = Integer.MAX_VALUE;
        }
        for (int i = 0; i <= n; i++) {
            dp[m][i] = Integer.MAX_VALUE;
        }

        // 将[m, n-1]和[m-1, n]位置初始化为1
        dp[m][n-1] = dp[m-1][n] = 1;
        for (int i = m-1; i >= 0; i--) {
            for (int j = n-1; j >= 0; j--) {
                dp[i][j] = Math.min(dp[i+1][j], dp[i][j+1]) - dungeon[i][j];
                if (dp[i][j] < 1) {
                    dp[i][j] = 1;
                }
            }
        }

        return dp[0][0];
    }
}

好啦！本期  动态规划 —— 路径问题 的刷题之旅 就到此结束啦！我们下一期再一起学习吧！