leetcode—— 不同路径I II

/*

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

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

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

*/

思路：

从起点 (x=0,y=0)(x=0,y=0)(x=0,y=0) 出发，下一步只能向右或者向下到达第二点，向右则为 (x+1，y)(x+1，y)(x+1，y) 向下则为 (x，y+1)(x，y+1)(x，y+1)，一直到 (x=m，y=n)(x=m，y=n)(x=m，y=n) 这个点则为结束点视为一条路径。
因此从起点到终点的所有路径总数则为 222 个 以第二个点到终点的路径数的总和。

 

//static int ve[101][101] = {0};  //0s
vector<vector<int>> ve(101,vector<int>(101,0)); //4s
class Solution {
public:
    int uniquePaths(int m, int n) {
        if(m == 1 || n == 1)
            return 1;
        if(m == 2 && n == 2)
            return 2;
        if(m == 2 && n == 3 || m == 3 && n == 2)
            return 3;
        if(ve[m][n] > 0)
            return ve[m][n];
        ve[m-1][n] = uniquePaths(m-1,n);
        ve[m][n-1] = uniquePaths(m,n-1);
        ve[m][n] = ve[m-1][n] + ve[m][n-1];
        
        return ve[m][n];
    }

};

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

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

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

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int R = obstacleGrid.size();
        int C = obstacleGrid[0].size();
        
        //obstacleGrid数组存储的是到达这一位置的路径数
        
        //如果第一个节点处的值就为1，那机器人一步也走不了
        if(obstacleGrid[0][0] == 1)
            return 0;
        
        obstacleGrid[0][0] = 1;
        
        //从0，0 出发先看最边上的这一列是否有障碍物，并且计算到边上的某一点的路径
        for(int i=1; i<R; i++) 
        {                                                   //说明它的上一个节点不是障碍物
            obstacleGrid[i][0] = (obstacleGrid[i][0] == 0 && obstacleGrid[i-1][0] == 1) ? 1 : 0;
        }
        
        for(int i=1; i<C; i++)
        {
            obstacleGrid[0][i] = (obstacleGrid[0][i] == 0 && obstacleGrid[0][i-1] == 1) ? 1: 0;
        }
        
        for(int i=1; i < R; i++)
        {
            for(int j=1; j < C; j++)
            {
                if(obstacleGrid[i][j] == 0)
                {
                    obstacleGrid[i][j] = obstacleGrid[i-1][j] + obstacleGrid[i][j-1];
                }
                else
                    obstacleGrid[i][j] = 0;
               
            }
        }
        return obstacleGrid[R-1][C-1];
    }
};

复杂度分析

时间复杂度 ： O(M×N)O(M \times N)O(M×N) 。长方形网格的大小是 M×NM \times NM×N，而访问每个格点恰好一次。
空间复杂度 ： O(1)O(1)O(1)。我们利用 obstacleGrid 作为 DP 数组，因此不需要额外的空间。