动态规划之不同路径

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

image-20190327181243286

示例：

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

解

这个和之前最短路径和的那题如出一辙，一样的解法, 动态规划之最短路径和

[
  [0,0,0],
  [0,0,0],
  [0,0,0]
]

• 如果点在最上面，x=0的位置，那么只有一种可能方式
• 如果点在最左边，y=0的位置，也是只有一种可能
• 如果点在中间[x,y],x>0,y>0的位置，那么其走法为[x-1] [y]与[x] [y-1]走法的和

    public static int uniquePaths(int m, int n) {

        // 存储在每一个位置的可能性
        int[][] res = new int[m][n];
        res[0][0] = 1;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i ==0 && j ==0){
                    continue;
                }
                // 第一行的时候
                if (i == 0) {
                    res[i][j] = res[i][j - 1];
                // 第一列的时候
                } else if (j == 0) {
                    res[i][j] = res[i - 1][j];
                } else {
                    res[i][j] = res[i - 1][j] + res[i][j - 1];
                }
            }
        }

        // 到达终点的路径可能性
        return res[m-1][n-1];

    }

扩展

在走向终点的路上有障碍物的存在。那么可以有多少种走法呢。如果理解了上面的方式，那么其实在障碍物的位置上，走法为0即可。

public static int uniquePathsWithObstacles(int[][] obstacleGrid) {
        if (obstacleGrid.length == 0 || obstacleGrid[0][0] == 1){
            return 0;
        }

        // 存储在每一个位置的可能性
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] res = new int[m][n];
        res[0][0] = 1;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i ==0 && j ==0){
                    continue;
                }
                // 第一行的时候
                // 如果发现了障碍物，此路不通
                if (obstacleGrid[i][j] == 1){
                    res[i][j] = 0;
                    continue;
                }

                if (i == 0) {
                    res[i][j] = res[i][j - 1];
                // 第一列的时候
                } else if (j == 0) {
                    res[i][j] = res[i - 1][j];
                } else {
                    res[i][j] = res[i - 1][j] + res[i][j - 1];
                }
            }
        }

        // 到达终点的路径可能性
        return res[m-1][n-1];
    }

最后

方案比较类似

参考

• 62 不同路径
• 63. 不同路径 II