动态规划：不同路径

1. 不同路径

LeetCode第62题是关于“不同路径”的问题，其描述如下：

问题描述：
一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为“Start”）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。问总共有多少条不同的路径？

例如，一个 7 x 3 的网格有多少可能的路径？

动态规划解法思路：

1. 定义状态：
   dp[i][j] 表示从起点到达点 (i, j) 的路径总数。

2. 状态转移方程：
   dp[i][j] = dp[i-1][j] + dp[i][j-1]，表示机器人可以从上方或左方移动到 (i, j)。

3. 初始化条件：

   • 对于网格的第一行 dp[0][j] 和第一列 dp[i][0]，只有一种方法到达，即一直向右或一直向下，所以这些值应初始化为 1。

4. 填表计算：

   • 从 dp[0][0] 开始填充，直到 dp[m-1][n-1]。

5. 输出结果：

   • 输出 dp[m-1][n-1]，即为从左上角到右下角的不同路径数量。

以下是相应的Java实现代码：

public class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        
        // 初始化第一行和第一列
        for (int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }
        for (int j = 0; j < n; j++) {
            dp[0][j] = 1;
        }
        
        // 填充dp表
        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[m-1][n-1] 中。这种方法的时间复杂度和空间复杂度均为 O(m * n)，其中 m 和 n 是网格的行数和列数。如果要优化空间复杂度，可以进一步只使用一个一维数组来实现。

2. 不同路径2

LeetCode第63题是“不同路径 II”的问题，这是对第62题的一个扩展，现在网格中包含了一些障碍物，这些障碍物标记为 1，空位置标记为 0。问题描述如下：

问题描述：
一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为“Start”），网格中的障碍和空位置分别用 1 和 0 来表示。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。问总共有多少条不同的路径？

动态规划解法思路：

1. 定义状态：
   dp[i][j] 表示从起点到达点 (i, j) 的路径总数。

2. 状态转移方程：
   dp[i][j] = dp[i-1][j] + dp[i][j-1]，但如果 (i, j) 是一个障碍，那么 dp[i][j] = 0，因为不可能通过障碍。

3. 初始化条件：

   • 如果起点 (0,0) 是障碍，则 dp[0][0] = 0，否则 dp[0][0] = 1。
   • 对于第一行或第一列，只要一旦遇到障碍，则该位置及其后的位置都不可达，即初始化为0。

4. 填表计算：

   • 遍历每一个格点，按照状态转移方程计算。

5. 输出结果：

   • 输出 dp[m-1][n-1]，即为从左上角到右下角的不同路径数量。

以下是相应的Java实现代码：

public class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length, n = obstacleGrid[0].length;
        if (obstacleGrid[0][0] == 1) return 0;  // 如果起点就是障碍物，直接返回0

        int[][] dp = new int[m][n];
        dp[0][0] = 1;  // 起始点

        // 初始化第一列
        for (int i = 1; i < m; i++) {
            if (obstacleGrid[i][0] == 0 && dp[i-1][0] == 1) {
                dp[i][0] = 1;
            } else {
                dp[i][0] = 0;
            }
        }
        
        // 初始化第一行
        for (int j = 1; j < n; j++) {
            if (obstacleGrid[0][j] == 0 && dp[0][j-1] == 1) {
                dp[0][j] = 1;
            } else {
                dp[0][j] = 0;
            }
        }

        // 填充dp表
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 0) {
                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
                } else {
                    dp[i][j] = 0;
                }
            }
        }

        // 返回结果
        return dp[m-1][n-1];
    }
}

在这个解法中，我们考虑了障碍物的存在，因此需要在初始化和状态转移过程中判断当前格点是否为障碍。如果是障碍，则该点的路径数为0；否则，根据动态规划的逻辑计算路径数。这种方法的时间复杂度和空间复杂度仍为 O(m * n)。