递归，动态规划法解决不同路径||

题目描述:一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。 现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

说明：m 和 n 的值均不超过 100。

示例 1:

输入:
[
[0,0,0],
[0,1,0],
[0,0,0]
]
输出: 2
解释:
3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：

1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

该题可以在不同路径|的基础上进行修改，添加遇到障碍物做出的不同的反应

方法一

递归实现

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
		
		int m=obstacleGrid.length;
		int n=obstacleGrid[0].length;
    HashMap<String, Integer> visited = new HashMap<>();

    return getAns(0, 0, m - 1, n - 1, 0, visited,obstacleGrid); 
}
private int getAns(int x, int y, int m, int n, int num, HashMap<String, Integer> visited,int[][] obstacleGrid) {
    if(obstacleGrid[x][y]==1)
    return 0;
    if (x == m && y == n) {

        return 1;

    }
    int n1 = 0;

    int n2 = 0;

    String key = x + 1 + "." + y;

    //判断当前点是否已经求过了

    if (!visited.containsKey(key)&&obstacleGrid[x][y]!=1) {

        if (x + 1 <= m) {

            n1 = getAns(x + 1, y, m, n, num, visited,obstacleGrid);

        }

    } else {

        n1 = visited.get(key);

    }

    key = x + "@" + (y + 1);

    if (!visited.containsKey(key)&&obstacleGrid[x][y]!=1) {

        if (y + 1 <= n) {

            n2 = getAns(x, y + 1, m, n, num, visited,obstacleGrid);

        }

    } else {

        n2 = visited.get(key);

    }

    //将当前点加入 visited 中

    key = x + "." + y;

    visited.put(key, n1+n2);

    return n1 + n2;

}
    }

方法二：

动态规划

java实现
与不同路径问题|不同的是在初始化的处理不同
参考与leetcode官方题解

算法

• 如果第一个格点 obstacleGrid[0,0] 是 1，说明有障碍物，那么机器人不能做任何移动，我们返回结果 0。
  否则，如果 obstacleGrid[0,0] 是 0，我们初始化这个值为 1 然后继续算法。
• 遍历第一行，如果有一个格点初始值为 1 ，说明当前节点有障碍物，没有路径可以通过，设值为 0 ；否则设这个值是前一个节点的值 obstacleGrid[i,j] = obstacleGrid[i,j-1]。
• 遍历第一列，如果有一个格点初始值为 1 ，说明当前节点有障碍物，没有路径可以通过，设值为 0 ；否则设这个值是前一个节点的值 obstacleGrid[i,j] = obstacleGrid[i-1,j]。
• 现在，从 obstacleGrid[1,1] 开始遍历整个数组，如果某个格点初始不包含任何障碍物，就把值赋为上方和左侧两个格点方案数之和 obstacleGrid[i,j] = obstacleGrid[i-1,j] + obstacleGrid[i,j-1]。
• 如果这个点有障碍物，设值为 0 ，这可以保证不会对后面的路径产生贡献。

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m=obstacleGrid.length;
        int n=obstacleGrid[0].length;
        
        if(obstacleGrid[0][0]==1)
        return 0;
        obstacleGrid[0][0]=1;
        for(int i=1;i<n;i++)
        obstacleGrid[0][i]=(obstacleGrid[0][i]==0&&obstacleGrid[0][i-1]==1)? 1:0;

        for(int i=1;i<m;i++)
        obstacleGrid[i][0]=(obstacleGrid[i][0]==0&&obstacleGrid[i-1][0]==1)? 1:0;

        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if(obstacleGrid[i][j]==1)
                obstacleGrid[i][j]=0;
                else
                obstacleGrid[i][j] = obstacleGrid[i - 1][j] + obstacleGrid[i][j - 1];
            }
        }
        return obstacleGrid[m - 1][n - 1];  //最终的结果
    }
}