动态规划之不同的路径

不同的路径

 有一个机器人的位于一个 m × n 个网格左上角.机器人每一时刻只能向下或者向右移
 动一步。机器人试图达到网格的右下角。现在考虑网格中有障碍物，那样将会有多少
 条不同的路径？网格中的障碍和空位置分别用 1 和 0 来表示。
 
 样例 1：
 输入:
 	[[0]]
 输出:
 	1
 
 样例 2：
 输入:
 	[[0,0,0],[0,1,0],[0,0,0]]
 输出:
 	2

解答：
定义dp[i][j]为从左上角到点[i-1][j-1]的路径数，因只可右或下行走
故：
dp[i][j] = dp[i-1][j] + dp[i][j-1] {1<=i<=m,1<=j<=n}

class Solution {
public:
    /**
     * @param obstacleGrid: A list of lists of integers
     * @return: An integer
     */
    int uniquePathsWithObstacles(vector<vector<int>> &obstacleGrid) {
        // write your code here
        /*
        定义dp[i][j]为从左上角到点[i-1][j-1]的路径数，因只可右或下行走，
        故：
        dp[i][j] = dp[i-1][j] + dp[i][j-1] {1<=i<=m,1<=j<=n}
        
        */
        if(obstacleGrid.empty()){
            return 0;
        }
        
        const int m = 101;
        const int n = 101;
        
        int dp[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                dp[i][j] = 0;
            }
        }
        
        // 针对第一列遇到第一个障碍后终止循环，因为后面的路被障碍挡住无法通过了
        for (int i = 1; i <= obstacleGrid[0].size(); i++) {
            if(obstacleGrid[0][i-1] != 1){
                dp[1][i] = 1;
            }
            else{
                break;
            }
        }
        // 针对第一行遇到第一个障碍后终止循环，因为后面的路被障碍挡住无法通过了
        for (int i = 1; i <= obstacleGrid.size(); i++) {
            if(obstacleGrid[i-1][0] != 1){
                dp[i][1] = 1;
            }
            else{
                break;
            }
        }
        
        // 针对无障碍点进行状态转换运算
        for (int i = 2; i <= obstacleGrid.size(); i++) {
            for (int j = 2; j <= obstacleGrid[0].size(); j++) {
                if(obstacleGrid[i-1][j-1] != 1)
                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        
        // dp数组右下角即为路径条数
        return dp[obstacleGrid.size()][obstacleGrid[0].size()];
    }
};