2021-4-20 不同路径

题目 不同路径

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

示例 1：

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

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

1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

解1 动态规划

设置数组dp[ i ][ j ]表示第 i 行，第 j 列格子的路径个数。则

1. dp[ 0 ][ j ] = dp[ i ][ 0 ] = 0;
2. dp[ i ][ j ] = dp[ i-1 ][ j ]+dp[ i ][ j-1 ] 当 i-1 > 0 且 j-1 > 0时。

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m,vector<int>(n,0));
        for(int i=0 ; i<m ; i++)
        {
            for(int j=0 ; j<n ; j++)
            {
                if(i==0 && j==0)
                    dp[i][j] = 1;
                else if((i == 0 || j == 0))
                    dp[i][j] = 1;
                else
                    dp[i][j] = dp[i][j-1]+dp[i-1][j];
            }
        }
        return dp[m-1][n-1];
    }
};

解2 数学组合法##

从左上角到右下角的过程中，我们需要移动 m+n-2 次，其中有 m-1 次向下移动，n-1 次向右移动。因此路径的总数，就等于从 m+n-2 次移动中选择 m-1 次向下移动的方案数，即组合数：

class Solution {
public:
    int uniquePaths(int m, int n) {
        long long ans = 1;
        for (int x = n, y = 1; y < m; ++x, ++y) {
            ans = ans * x / y;
        }
        return ans;
    }
};

转载：力扣最大路径详解

题目 不同路径+障碍

在上题基础上，中间可能会存在某个障碍，无法通过，求解
题目给的直接为数组，且障碍用1表示。因此我们使用：-obstacleGrid[ i ][ j ]表示可能的路径数。

1. 边缘初始化：若边缘任意一个地方有障碍，则障碍后面的路径数均为0。
2. 求数组每个值，与上题类似，不过需要查看obstacleGrid[ i-1 ][ j ]和obstacleGrid[ i ][ j-1 ]的值。
   a. obstacleGrid[ i-1 ][ j ] = obstacleGrid[ i ][ j-1 ] = 1： obstacleGrid[ i ][ j ] = 0；
   b. obstacleGrid[ i-1 ][ j ] = 1，obstacleGrid[ i ][ j-1 ] != 1： obstacleGrid[ i ][ j ] = obstacleGrid[ i ][ j-1 ]；
   c. obstacleGrid[ i ][ j-1 ] = 1，obstacleGrid[ i-1 ][ j ] != 1： obstacleGrid[ i ][ j ] = obstacleGrid[ i-1 ][ j ]；
   d. obstacleGrid[ i ][ j-1 ] != 1，obstacleGrid[ i-1 ][ j ] != 1： obstacleGrid[ i ][ j ] = obstacleGrid[ i ][ j-1 ] + obstacleGrid[ i-1 ][ j ]；

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int i,j;
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        if(obstacleGrid[m-1][n-1] == 1) return 0;
        //初始化
        for(i=0 ; i<m ; i++)
        {
            if(obstacleGrid[i][0] == 1) 
                break;
            obstacleGrid[i][0] = -1;
        }
        for(j=0 ; j<n ; j++)
        {
            if(obstacleGrid[0][j] == 1)
                 break;
            obstacleGrid[0][j] = -1;
        }

        for( i=1 ; i<m ; i++)
        {
            for( j=1 ; j<n ; j++)
            {
                if(obstacleGrid[i][j] == 1)
                    continue;
                else 
                {
                    if(obstacleGrid[i][j-1] == 1 && obstacleGrid[i-1][j] == 1)
                        obstacleGrid[i][j] = 0;
                    else if(obstacleGrid[i-1][j] == 1)
                        obstacleGrid[i][j] = obstacleGrid[i][j-1];
                    else if(obstacleGrid[i][j-1] == 1)
                        obstacleGrid[i][j] = obstacleGrid[i-1][j];
                    else
                        obstacleGrid[i][j] = obstacleGrid[i-1][j]+obstacleGrid[i][j-1];
                }
           
            }
        }
        return -obstacleGrid[m-1][n-1];
    }
};