LeetCode 62. Unique Paths LeetCode 63 Unique Paths II 不同的路径之二

最新推荐文章于 2022-08-01 14:51:02 发布

momo_mo520

最新推荐文章于 2022-08-01 14:51:02 发布

阅读量179

点赞数

分类专栏： LeetCode 文章标签： LeetCode 动态规划

本文链接：https://blog.csdn.net/momo_mo520/article/details/79933502

版权

LeetCode 专栏收录该内容

69 篇文章 0 订阅

订阅专栏

初识动态规划。

格点(i,j)。由于只能从上格点(i-1,j)或左格点(i,j-1)到达，并且两者路径是不重复的

因此path[i][j] = path[i-1][j]+path[i][j-1]。

最近要开始看动态规划了。

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> ans(m,vector<int>(n,1));
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
                ans[i][j]=ans[i-1][j]+ans[i][j-1];
            //每一个格子只能从上面和左边的格子到达，因此每一个格子到达的路线是左、上相加。遍历完所有的格子，更新一遍（按照上到下左到右的顺序）
        }
        return ans[m-1][n-1];
    }
};

63II 自己写的方法1特复杂。

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        //obstacleGrid={{0,0,0},{0,1,0},{0,0,0}};
        int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        int i,j,j1,i1;
        vector<vector<int>> ans(m,vector<int>(n,1));
        if(m>=1&&n>=1)
        {
            
               for(j=0;j<n;j++) 
               {
                   if(obstacleGrid[0][j]==1) 
               {
                   for(j1=j;j1<n;j1++) ans[0][j1]=0;    
                       break;
               }
               }
            
               for(i=0;i<m;i++) 
               {
                   if(obstacleGrid[i][0]==1) 
               {
                   for(i1=i;i1<m;i1++) ans[i1][0]=0;    
                       break;
               }
        
               }
               
            for(i=1;i<m;i++)
        {   
            for(j=1;j<n;j++)
            {
                 if(obstacleGrid[i][j]!=1)
                    ans[i][j]=ans[i-1][j]+ans[i][j-1];
                else
                    ans[i][j]=0;
            }
               
            //每一个格子只能从上面和左边的格子到达，因此每一个格子到达的路线是左、上相加。遍历完所有的格子，更新一遍（按照上到下左到右的顺序）
            
        }
        return ans[m-1][n-1];
        }
        else return 0;
         
    }
};

方法2：

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