（1）unique_paths 1

题⽬要求：给定m x n矩阵，求左上⻆到右下⻆的路径总数，每次只能向左或者向右前进。按照动态规
划中矩阵类问题的通⽤⽅法：
1. State: f[m][n] 从起点到坐标(m,n)的路径数⽬
2. Function: f[m][n] = f[m-1][n] + f[m][n-1] 分析终点与左边及右边节点的路径数，发现从左边或者右
边到达终点的路径⼀定不会重合，相加即为唯⼀的路径总数
3. Initialization: f[i][j] = 1, 到矩阵中任⼀节点均⾄少有⼀条路径，其实关键之处在于给第0⾏和第0列
初始化，免去了单独遍历第0⾏和第0列进⾏初始化
4. Answer: f[m - 1][n - 1]

class Solution {
public:
    int uniquePaths(int m, int n) {
        if(m < 1 || n < 1)
            return 0;
        vector<vector<int> > res(m, vector<int>(n,1));
        for(int i = 1; i < m; ++i){
            for(int j = 1; j < n; ++j)
                res[i][j] = res[i-1][j] + res[i][j-1];
        }
        return res[m-1][n-1];
    }
};

（2）unique_paths 2

 在上一个问题上加了障碍物，则意味着，凡是遇到障碍物，其路径数马上变为0；

这一步和上面的问题的区别在于要判断是否有障碍物，因此对于初始化矩阵也有了区别

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {
        if(obstacleGrid.empty() || obstacleGrid.empty())
            return 0;
        int M = obstacleGrid.size();
        int N = obstacleGrid[0].size();
        
        vector<vector<int> > res(M, vector<int>(N,0));
        for(int i = 0; i <M; ++i){
            if(obstacleGrid[i][0] == 1)    //只要遇到了1，那么后面的路径就都不通，为0
                break;
            else
                res[i][0] = 1;
        }
        for(int i = 0; i < N; ++i){
            if(obstacleGrid[0][i] == 1)    //只要遇到了1，那么后面的路径就都不通，为0
                break;
            else
                res[0][i] = 1;
        }
        for(int i = 1; i < M; ++i){
            for(int j = 1; j < N; ++j){
                if(obstacleGrid[i][j] == 1)    //如果当前有障碍区，这道这里的路劲为0
                    res[i][j] = 0;
                else
                    res[i][j] = res[i-1][j] + res[i][j-1];
            }
        }
        return res[M-1][N-1];
    }
};