LeetCode 63. 不同路径 II

最新推荐文章于 2022-10-30 20:01:12 发布

原创最新推荐文章于 2022-10-30 20:01:12 发布 · 150 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 同时被 2 个专栏收录

82 篇文章

订阅专栏

6 篇文章

订阅专栏

本文探讨了在存在障碍物的网格中，从左上角到右下角的不同路径计数问题。通过递归和动态规划两种方法解析，展示了如何计算可行路径的数量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

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

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

说明：m 和 n 的值均不超过 100。

示例 1:

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

解题思路：
1.递归：
递归式如下：

代码实现：

int f(int A[][4], int m,int n)
{
    if( m == 0)
        return 1;
    else if(n == 0 )
        return 1;
    else
    {
        if(A[m-1][n] == 1 && A[m][n-1] == 0)
            return f(A, m ,n-1);
        else if(A[m-1][n] == 0 && A[m][n-1] == 1)
            return f(A, m-1, n);
        else if(A[m-1][n] == 0 && A[m][n-1] == 0)
            return f(A, m,n-1) + f(A, m-1, n);
        else
            return 0;
    }
 }

2.动态规划
建立一个二维的辅助数组，保存每次迭代的值
代码实现：

 int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
      int a = obstacleGrid.size();            //行号   
      int b = obstacleGrid[0].size();         //列号
      if(obstacleGrid[a-1][b-1] == 1)
          return 0;
      int A[a][b]  ;                    //辅助数组
      for(int l1 = 0; l1 < a; l1++)
          for(int l2 = 0; l2 < b; l2++)
              A[l1][l2] = 0;
    //int A[a][b];
      for(int i = 0; i < a; i++){          //初始化第一列，只要有一列障碍为1，则其之后的值都为0
          if(obstacleGrid[i][0] == 0)
              A[i][0] =1;
          else
              for(int k = i; k < a; k++)
                  A[i][0] = 0;
          if(obstacleGrid[i][0] == 1)
              break;   
      }
      for(int j = 0; j < b; j++){          //初始化第一行，只要有一行障碍为1，则其之后的值都为0
          if(obstacleGrid[0][j] == 0)
              A[0][j] =1;
          else
              for(int k = j; k < b; k++)
                  A[0][j] =0;
           if(obstacleGrid[0][j] == 1)
              break;
      }
      for(int i = 1; i < a ; i++ )
      {
          for(int j = 1; j < b; j++)                                                   //根据递归式叠加
          { 
              if(obstacleGrid[i-1][j] == 1 && obstacleGrid[i][j-1] == 0)
                   A[i][j] = A[i][j-1];
              else if(obstacleGrid[i-1][j] == 0 && obstacleGrid[i][j-1] == 1)
                   A[i][j] = A[i-1][j];
              else if(obstacleGrid[i-1][j] == 0 && obstacleGrid[i][j-1] == 0)
                   A[i][j] = A[i-1][j] + A[i][j-1];
              else
                   A[i][j] = 0;
          }
    
      }
    return A[a-1][b-1];
}