LeetCode 63: Unique Path II

     本题和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;
    }
};