本題和62題相似，所以放在一起講，對於這題，提供一個地圖，上面會有個別障礙，只能選擇往右或者往下，問從左上角到右下角有多少種走法，本題第一種思路是利用回溯的方法，若沒碰到障礙，則往前進，到達一次終點計數一次，但是這種方法最終超時，仔細想一下，這是一點典型的DP問題，做法如下：

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        
        
        int H=obstacleGrid.size();
        if(H==0) return 0;
        
        int W=obstacleGrid[0].size();
        
        vector<int> tmp(W+1,0);
        vector<vector<int>>DP(H+1,tmp);
        
        if(obstacleGrid[0][0]==0)
            DP[1][1]=1;
        else DP[1][1]=0;
        
        for(int i=0;i<H;i++)
        {
            for(int j=0;j<W;j++)
            {
                if(i==0&&j==0) continue;
                if(obstacleGrid[i][j]==1)
                {
                    DP[i+1][j+1]=0;
                }
                else DP[i+1][j+1]=DP[i][j+1]+DP[i+1][j];
            }
        }
        
        return DP[H][W];
        
    }
};
 

對於上一題62，由於全域性沒有障礙，一方面可以同樣使用DP方法，但是仔細想一下就是從帶重複元素的序列中找到所有排列，即可以簡化為  A(m+n-2)/(A(m-1)*A(n-1)) 的形式，但是直接算上下的話可能會出現溢位現象，因此加上一個小trick，先約簡，再除，方法如下（程式碼可以更加精簡一點，但是這樣寫會更加直觀）：

class Solution {
public:
      
    int uniquePaths(int m, int n) {
        
        m=m-1;
        n=n-1;
        
        int ret;
        long long ans=1;
        long long tmp=1;
        if(m>n)
        {
            for(int i=m+1;i<=m+n;i++)
            {
                ans*=i;
            }
            
            for(int i=1;i<=n;i++)
            {
                tmp*=i;
            }
            ret=(int)(ans/tmp);
        }
        else{
            for(int i=n+1;i<=m+n;i++)
            {
                ans*=i;
            }
            
            for(int i=1;i<=m;i++)
            {
                tmp*=i;
            }
            ret=(int)(ans/tmp);
        }
        return ret;
    }
};