leetcode Unique Paths II

最新推荐文章于 2019-05-17 12:08:12 发布

原创最新推荐文章于 2019-05-17 12:08:12 发布 · 382 阅读

0 ·

CC 4.0 BY-SA版权

leetcode Fighting 专栏收录该内容

133 篇文章

订阅专栏

本文探讨了两种解决机器人路径规划问题的方法：递归算法与动态规划。递归算法虽然直观但容易超时；而动态规划方法则能高效地解决包含障碍物的网格路径问题。

递归算法超时

超时的代码

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {
        int iRow = obstacleGrid.size();
        int iCol = obstacleGrid[0].size();
        
        if(iRow==0||iCol==0)
            return 0;
        
        pathNum = 0;
        
        uniquePathsWithObstaclesHelper(obstacleGrid, 0, 0, iRow-1, iCol-1);
        
    }
     
     void uniquePathsWithObstaclesHelper(vector<vector<int> > obstacleGrid, int iCur, int jCur, int finishRow, int finishCol)
     {
         
        if((iCur==finishRow&&jCur==finishCol-1)||(jCur==finishCol&&iCur==finishRow-1))  
        {  
            pathNum++;  
            return;  
        }  
         
        if(iCur<finishRow&&obstacleGrid[iCur+1][jCur]!=1)  
             uniquePathsWithObstaclesHelper(obstacleGrid, iCur+1, jCur, finishRow, finishCol);  
        if(jCur<finishCol&&obstacleGrid[iCur][jCur+1]!=1)  
             uniquePathsWithObstaclesHelper(obstacleGrid, iCur, jCur+1, finishRow, finishCol);  

         
     }
     
    private:
    int pathNum;
};

动态规划

Accepted代码

与Unique Paths 想法一样，不过需要对障碍进行额外处理

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {
        int m= obstacleGrid.size();
        int n = obstacleGrid[0].size();
        
        if(m==0||n==0)
            return 0;
        vector<vector<int> > pathNum(m, vector<int>(n,0));
        
        if(obstacleGrid[0][0])
            pathNum[0][0] = 0;
        else
            pathNum[0][0] = 1;
        
        for(int i = 1; i < m; ++i)
            pathNum[i][0] =(pathNum[i-1][0]&&!obstacleGrid[i][0]);
        for(int j = 1; j < n; ++j)
            pathNum[0][j] =(pathNum[0][j-1]&&!obstacleGrid[0][j]);
        
        for(int i = 1; i < m; ++i)
            for(int j = 1; j < n; ++j)
            {
                if(!obstacleGrid[i][j])
                    pathNum[i][j] = pathNum[i-1][j]+pathNum[i][j-1];
                else
                    pathNum[i][j] = 0;
            }
            
            return pathNum[m-1][n-1];
    }

};