【LeetCode每日一题】——63.不同路径II

一【题目类别】

• 动态规划

二【题目难度】

• 中等

三【题目编号】

• 63.不同路径II

四【题目描述】

• 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
• 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
• 现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
  
• 网格中的障碍物和空位置分别用 1 和 0 来表示。

五【题目示例】

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

六【题目提示】

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

七【解题思路】

• 与62.不同路径这道题思路一样，只是多了一个判断障碍物的逻辑，遇到障碍物这个位置的可到达路径数就是1，另外初始化第一行和第一列的时候要根据前面是否有障碍物判断，不能随便的初始化为1，其余不变

八【时间频度】

• 时间复杂度：$O(M\ast N)$，M为二维数组的行数，N为二维数组的列数

九【代码实现】

1. Java语言版

package DynamicProgramming;

public class p63_UniquePathsII {

    public static void main(String[] args) {
        p63_UniquePathsII p63_uniquePathsII = new p63_UniquePathsII();
        int[][] obstacleGrid = {
                {0, 0, 0},
                {0, 1, 0},
                {0, 0, 0},
        };
        int res = p63_uniquePathsII.uniquePathsWithObstacles(obstacleGrid);
        System.out.println("res = " + res);
    }

    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        if (obstacleGrid == null || obstacleGrid.length <= 0) {
            return 0;
        }
        int row = obstacleGrid.length;
        int col = obstacleGrid[0].length;
        // 生成对应的二维数组
        int[][] temp = new int[row][col];
        // 因为第一行不管到哪个位置都只有一条路径，所以置为1，除了有障碍物会有特殊说明
        for (int i = 0; i < row; i++) {
            if (obstacleGrid[i][0] == 1) {
                temp[i][0] = 0;
                break; // 因为遇到障碍物后面的也就无法到达了，所以直接返回，置为0
            } else {
                temp[i][0] = 1; // 如果没有遇到障碍物就置为1
            }
        }
        // 因为第一列不管到哪个位置都只有一条路径，所以置为1，除了有障碍物会有特殊说明
        for (int i = 0; i < col; i++) {
            if (obstacleGrid[0][i] == 1) {
                temp[0][i] = 0; // 因为遇到障碍物后面的也就无法到达了，所以直接返回，置为0
                break;
            } else {
                temp[0][i] = 1; // 如果没有遇到障碍物就置为1
            }
        }
        // 然后开始遍历每一个元素，因为最终到达点肯定是从左面或者上面进入的，所以最终点的路径就是左面的之前路径和加上上面的之前路径和，除了有障碍物会有特殊说明
        for (int i = 1; i < row; i++) {
            for (int j = 1; j < col; j++) {
                if (obstacleGrid[i][j] == 1) {
                    temp[i][j] = 0; // 只要遇到一个障碍物，那么就置为0，表示没有通路
                } else {
                    temp[i][j] = temp[i - 1][j] + temp[i][j - 1]; // 如果没有障碍物，按照动态规划走
                }
            }
        }
        return temp[row - 1][col - 1];
    }

}

2. C语言版

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int uniquePathsWithObstacles(int** obstacleGrid, int obstacleGridSize, int* obstacleGridColSize)
{
	/*获取行数*/
	int raw = obstacleGridSize;
	/*获取列数*/
	int col = obstacleGridColSize[0];
	/*动态数组，存放每一个位置可以到达的不同路径数目*/
	int** dp = (int*)malloc(sizeof(int*)*raw);
	for (int i = 0; i < raw; i++)
	{
		dp[i] = (int*)calloc(col, sizeof(int));
	}
	/*遍历每一个位置*/
	for (int x = 0; x < raw; x++)
	{
		for (int y = 0; y < col; y++)
		{
			/*遇到障碍物到达当前位置的不同路径数目就为0*/
			if (obstacleGrid[x][y] == 1)
			{
				dp[x][y] = 0;
			}
			else
			{
				/*起点可以到达的不同路径数目肯定为1*/
				if (x == 0 && y == 0)
				{
					dp[x][y] = 1;
				}
				/*第一行不能全部初始化为1，要根据是否有障碍物判断*/
				else if (x == 0)
				{
					dp[x][y] = dp[x][y - 1];
				}
				/*第一列不能全部初始化为1，要根据是否有障碍物判断*/
				else if (y == 0)
				{
					dp[x][y] = dp[x - 1][y];
				}
				/*因为题目说机器人只能向下走或者向右走，因为之前的状态已经更新，那么除了第一行和第一列的所有位置都可以更新为左面和上面过来的可到达的不同路径数目之和*/
				else
				{
					dp[x][y] = dp[x - 1][y] + dp[x][y - 1];
				}
			}
		}
	}
	/*最终动态数组到达右下角就更新为所有不同路径的数目*/
	return dp[raw - 1][col - 1];
}

/*主函数省略*/

十【提交结果】

1. Java语言版
   

2. C语言版