算法-不同路径问题

1、不同路径(I)

62. 不同路径

本问题是动态规划的一个比较经典的题目，和跳台阶问题本质上是一样的，只是跳的位置不一样而已。

	一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
	机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
	问总共有多少条不同的路径？

例如，上图是一个7 x 3 的网格。有多少可能的路径？

示例 1:

输入: m = 3, n = 2
输出: 3
解释:
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向右 -> 向下
2. 向右 -> 向下 -> 向右
3. 向下 -> 向右 -> 向右
示例 2:

输入: m = 7, n = 3
输出: 28
 

提示：

1 <= m, n <= 100
题目数据保证答案小于等于 2 * 10 ^ 9

1.1 初步解

由于只能向右或者向下，那么在机器人经过某个点的时候就会有这样的关系

dp[i][j]=dp[i-1][j]+dp[i][j-1];

即当前位置的方案数为左侧方案数和上侧方案数之和。

那初始条件我们怎么确定呢？

由于这个机器人走路比较独特，所以其实我们可以它走到第一行或者第一列的每个位置，都只有一种方案：一条路走到黑。为此，我们将其初始化为1即可

public int uniquePaths(int m, int n) {
	int[][]dp=new int[m][n];//表示到达每个位置的方案数
	for(int i=0;i<m;i++){
		dp[m][0]=1;
	}
	for(int i=0;i<n;i++){
		dp[0][n]=1;
	}
	for(int i=1;i<m;i++){
		for(int j=1;j<n;j++){
			dp[i][j]=dp[i-1][j]+dp[i][j-1];
		}
	}
	return dp[m-1][n-1];
}

我们还可以对其进一步优化，

1.2 时间优化

我们使用了两个循环来初始化dp数组，其实这是不必的，我们只需要在遍历矩阵的时候判断访问的是不是左边界和上边界，将左边界和上边界置为1即可。

    public int uniquePaths(int m, int n) {
        if(m==1||n==1){
            return 1;
        }
        int[][]dp=new int[m][n];//表示到达每个位置的方案数
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                if(i-1==0){
                    dp[0][j]=1;
                }
                if(j-1==0){
                    dp[i][0]=1;
                }
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }

2、不同路径(II)

63.不同路径(||)

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？



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

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

示例 1:

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

这次我们的路径里出现了障碍物，不过这不是什么问题。

转移方程还是上面的

dp[i][j]=dp[i-1][j]+dp[i][j-1];

只不过我们需要对障碍物加一个条件，如果i,j的位置为障碍物，那么我们将dp[i][j]标注为0，这样就可以了。

    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
    	int m=obstacleGrid.length,n=obstacleGrid[0].length;
		int[][]dp=new int[m][n];//表示到达每个位置的方案数
		for(int i=0;i<m&&(obstacleGrid[i][0]!=1);i++){
			dp[i][0]=1;
		}
		for(int i=0;i<n&&(obstacleGrid[0][i]!=1);i++){
			dp[0][i]=1;
		}
		for(int i=1;i<m;i++){
			for(int j=1;j<n;j++){
				if(obstacleGrid[i][j]==1){
					dp[i][j]=0;
				}else{
					dp[i][j]=dp[i-1][j]+dp[i][j-1];
				}
			}
		}
		return dp[m-1][n-1];
    }

上面的空间复杂度还可以再优化一下，不过写出来就不太优雅了。