LeetCode题解 21(62，63)不同路径,不同路径Ⅱ

不同路径

思路： 这道题让我求机器人到达星星位置的路径有几条，前提是只能横着走或者竖着走。
这道题我们利用动态规划来解决，dp[i][j]表示的就是到 i，j位置有几种走法。
因此容器我们选择二维数组。
初始化：
因为边界情况只有1种走法，因此我们初始化边界都为1。

          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公式 斜对角的2 就等于上方的路径数加上左方的路径数。
因此dp公式:

                  //到i,j位置的不同走法，为上边的加上左边
                  dp[i][j] = dp[i-1][j] + dp[i][j-1];

遍历顺序自然是从上到下，从左到右。

  for(int i = 1;i<m;i++){
      for(int j = 1;j<n;j++){
          //到i,j位置的不同走法，为上边的加上左边
          dp[i][j] = dp[i-1][j] + dp[i][j-1];
      }
  }

代码解答

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;
          }
          for(int i = 1;i<m;i++){
              for(int j = 1;j<n;j++){
                  //到i,j位置的不同走法，为上边的加上左边
                  dp[i][j] = dp[i-1][j] + dp[i][j-1];
              }
          }
          return dp[m-1][n-1];
    }
}

不同路径Ⅱ

这道题就是在不同路径Ⅰ的基础上多了障碍物,当遇到障碍物时就表示这个位置不能走了。
与Ⅰ的做题方法一样,我们依然将最外层的全部初始化为1，当然当在外层遇到障碍物时就不需要继续往后遍历了，将障碍物后的全部置为0，因为有了障碍物的阻挡，没有办法走过去。

        //将第一行和第一列初始为1 若碰到障碍就不遍历
        for(int i = 0;i<m && obstacleGrid[i][0] == 0;i++){
            dp[i][0] = 1;
        }
        for(int j = 0;j<n && obstacleGrid[0][j] == 0;j++){
            dp[0][j] = 1;
        }

这道题还需要考虑一下特殊情况，当障碍物刚好在起点，或者刚好在终点时这时候无论怎么走都不会到终点，因此直接返回0。

        //先判断临界情况
        if(obstacleGrid[0][0] == 1 || obstacleGrid[m-1][n-1] == 1){
            return 0;
        }

dp方程和上题依然一样，遍历的顺序也是一样的从左到右，从上到下，当我们遇到障碍物时就将该位置置为0。

        for(int i = 1;i<m;i++){
            for(int j = 1;j<n;j++){
                dp[i][j] = (obstacleGrid[i][j] == 0) ? dp[i-1][j] + dp[i][j-1] : 0;
            }
        }

代码解答

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        //先判断临界情况
        if(obstacleGrid[0][0] == 1 || obstacleGrid[m-1][n-1] == 1){
            return 0;
        }
        //定义dp数组
        int[][] dp = new int[m][n];
        //将第一行和第一列初始为1 若碰到障碍就不遍历
        for(int i = 0;i<m && obstacleGrid[i][0] == 0;i++){
            dp[i][0] = 1;
        }
        for(int j = 0;j<n && obstacleGrid[0][j] == 0;j++){
            dp[0][j] = 1;
        }
        for(int i = 1;i<m;i++){
            for(int j = 1;j<n;j++){
                dp[i][j] = (obstacleGrid[i][j] == 0) ? dp[i-1][j] + dp[i][j-1] : 0;
            }
        }
        return dp[m-1][n-1];
    }
}