LeetCode 第62题~第63题路径问题

LeetCode 第62题：不同路径

题目描述：

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

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

问总共有多少条不同的路径？

示例1：

输入：m = 3, n = 7
输出：28

示例2：

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

示例3：

输入：m = 7, n = 3
输出：28

示例4：

输入：m = 3, n = 3
输出：6

提示：

• 1 <= m, n <= 100
• 题目数据保证答案小于等于 2 * 10000000000

解题思路：

动态规划：dp[m][n]=dp[m-1][n]+dp[m][n-1]

int uniquePaths(int m,int n)
{
    int **arr = (int**)malloc(sizeof(int*) *n);
//动态分配一个包含 n 个 int* 类型元素的数组。
//返回一个指向该数组的指针（即二级指针 int**），并赋值给 arr。
    int i,v;
    for(i=0;i<n;i++)
    {
        arr[i] = (int*)malloc(sizeof(int)*m);//为二维数组的第 i 行分配 m 个整数的内存空间
//返回一个指向该内存块的 int* 指针，并赋值给 arr[i]。
        for(v=0;v<m;v++)
        {
            if(i==0 || v==0)  arr[i][v]=1;
            else arr[i][v] = arr[i-1][v]+arr[i][v-1];
        }

    }
    return arr[n-1][m-1];
}

LeetCode 第63题：不同路径Ⅱ

题目描述：

给定一个 m * n 的整数数组 grid。一个机器人初始位于 左上角（即 grid[0][0]）。机器人尝试移动到 右下角（即 grid[m - 1][n - 1]）。机器人每次只能向下或者向右移动一步。

网格中的障碍物和空位置分别用 1 和 0 来表示。机器人的移动路径中不能包含 任何 有障碍物的方格。

返回机器人能够到达右下角的不同路径数量。

测试用例保证答案小于等于 2 * 1000000000。

示例1：

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

示例2：

输入：obstacleGrid = [[0,1],[0,0]]
输出：1

提示：

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

解题思路：

动态规划（C++）

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        vector<vector<int>> dp(m, vector<int>(n, 0));
        //行
        for (int i = 0; i < m; i++) {
            if (obstacleGrid[i][0])
                break;
            dp[i][0] = 1;
        }
        //列
        for (int j = 0; j < n; j++) {
            if (obstacleGrid[0][j])
                break;
            dp[0][j] = 1;
        }
        //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++) {
                if (obstacleGrid[i][j])
                    continue;
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};

 动态规划(C语言）

int uniquePathsWithObstacles(int** obstacleGrid, int obstacleGridSize, int* obstacleGridColSize){
    //到达（i，j）位置有dp(i,j)条不同路径
    int dp[obstacleGridSize][*obstacleGridColSize];
    //起点终点都有障碍物的情况
    if(obstacleGrid[obstacleGridSize-1][(*obstacleGridColSize)-1] == 1 || obstacleGrid[0][0] == 1)
    {
        return 0;
    }
    //初始化dp数组
    for(int i=0;i<obstacleGridSize;i++)
    {
        for(int j=0;j<* obstacleGridColSize;j++)
        {
            dp[i][j]=0;
        }}
    for(int i=0;i<obstacleGridSize;i++)
    {
        if(obstacleGrid[i][0] == 0)
        {
            dp[i][0]=1;
        }
        else
        {
            dp[i][0]=0;
            break;
        }
    }
    for(int j=0;j<*obstacleGridColSize;j++)
    {
        if(obstacleGrid[0][j] == 0)
        {
            dp[0][j]=1;
        }
        else
        {
            dp[0][j]=0;
            break;
        }
    }
    //到达dp[i][j]的路径只有从dp[i-1][j]下移和从dp[i][j-1]右移两种情况;
    for(int i=1;i<obstacleGridSize;i++)
    {
        for(int j=1;j<*obstacleGridColSize;j++)
        {
            if(obstacleGrid[i-1][j]==1 && obstacleGrid[i][j-1]==1)
            {
                dp[i][j]=0;
            }
            else if(obstacleGrid[i][j-1] == 1)
            {
                dp[i][j]=dp[i-1][j];
            }            
            else if(obstacleGrid[i-1][j] == 1)
            {
                dp[i][j]=dp[i][j-1];
            }
            else
            {
                dp[i][j]=dp[i-1][j] + dp[i][j-1];
            }
        }
    }
   return dp[obstacleGridSize-1][(*obstacleGridColSize)-1];
}