题目：
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
网格中的障碍物和空位置分别用 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
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
--------------------------------------------------------------------
思路：
首先想到的是BS（广度搜索）和DS（深度搜索）算法。虽然能够得到正确答案，但是超时，时间复杂度为O(n^2)，空间复杂度为O(n^2)
随后想到的是动态规划。
先定义：matrix[][]是迷宫矩阵，0表示可以走，1表示阻塞。row表示matrix的行，column表示matrix的列数。
因为在这里matrix不一定是方阵，为了便于处理，使用方阵ob[][]来表示。（当然每个人的想法不一样，这种做只是比较方便操作而已23333）。
方阵ob的维度为Max(row, column)。使用max表示其维度大小。
使用dp[i][j]来表示：到达ob[i][j]处的道路条数。
Notice：如果i>=row || j>=column。即此时已经处于我们人为扩展处，此时dp[i][j]恒为0，即不可达。
因为该题限定只能往右或者往下走，所以状态转移方程不是很复杂。分几种情况：
① 如果ob[i][j] == 1。dp[i][j] = 0。
② 如果ob[i][j]处于上边界，即：i-1<0，此时 dp[i][j] = dp[i][j-1]。即只有向右走的权重。
③ 如果ob[i][j]处于左边界，即j-1<0，此时dp[i][j] = dp[i-1][j]。即只有向下走的权重。
④ dp[i][j] = dp[i-1][j] + dp[i][j-1]。除去上面三种情况下。
---------------------------------------------------------------------
得到状态转移方程后，便可编程实现。
但是在实现时需要注意：
① dp[][]状态矩阵的初始化问题。
可以像下面这样初始化dp矩阵的上边界值，以及左边界值：
//初始化上边界
for(int i = 0;i < column;i++){
if(ob[0][i] == 1) break;
dp[0][i] = 1;
}
//初始化左边界
for(int i = 0;i < row;i++){
if(ob[i][0] == 1) break;
dp[i][0] = 1;
}② dp[0][0]的初始化问题。
不能一概而论的定义dp[0][0] = 1。
因为如果ob[0][0] == 1，则永远无法到达目的地。。。。
所以可以在初始化dp[0][0]之前先判断ob[0][0]是否为1。如果为1，则直接返回0，否则可以将dp[0][0]初始化为1。
③ 更新状态矩阵的问题。
在更新时，我是按照主对角线来往下走，这也是自己将原始迷宫矩阵扩展为方阵的原因。
在沿着主对角线更新时，一定需要同时更新当前所在主对角线位置所在的一整行和一整列。
如下：
//sr表示当前所在的主对角线的位置的行下标，sc是列下标。
//row是原始迷宫矩阵的行数，column是列数
public void updateRowAndColumn(int [][]ob, int [][]dp, int sr, int sc,int row, int column){
if(sr>=row || sc>=column) return;
//更新当前一行
for(int i = 1;i < column;i++){
if(ob[sr][i] == 1) continue;
dp[sr][i] = dp[sr][i-1] + dp[sr-1][i];
}
//更新当前一列
for(int i = 1;i < row;i++){
if(ob[i][sc] == 1) continue;
dp[i][sc] = dp[i-1][sc] + dp[i][sc-1];
}
}-----------------------------------------------------------------
贴上完整代码。包括DS和动态规划：
package leetcode;/*
name: LeetCode_61
user: ly
Date: 2020/7/6
Time: 8:48
*/
public class LeetCode_61 {
public static void main(String []args){
int [][]ob = {
{1,0}
};
System.out.println(new LeetCode_61().uniquePathsWithObstacles1(ob));
}
// 深度搜索。超时
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int row = obstacleGrid.length;
int colum = obstacleGrid[0].length;
int [][]book = new int[row+1][colum+1];
book[0][0] = 1;
deepSearch(obstacleGrid, 0, 0, book);
return all;
}
int [][]dir = {{-1,0},{0,1},{1,0},{0,-1}};
int all = 0;
public void deepSearch(int [][]ob, int row, int colum, int [][]book){
if(row<0 || row>=ob.length || colum<0 || colum>=ob[0].length || ob[row][colum]==1) return;
if(row==ob.length-1 && colum==ob[0].length-1){
System.out.println("find onw way");
for(int i = 0;i < ob.length;i++){
for(int j = 0;j < ob[0].length;j++){
System.out.print(book[i][j]+"\t");
}
System.out.println();
}
all++;
return;
}
//此时可以走
for(int i = 0;i < 4;i++){
int nrow = row + dir[i][0];
int ncolum = colum + dir[i][1];
if(nrow<0 || nrow>=ob.length || ncolum<0 || ncolum>=ob[0].length) continue;
if(ob[nrow][ncolum]==1 || book[nrow][ncolum]==1) continue;
book[nrow][ncolum] = 1;
{
deepSearch(ob, nrow, ncolum, book);
}
book[nrow][ncolum] = 0;
}
}
// 动态规划.AC
public int uniquePathsWithObstacles1(int[][] obstacleGrid) {
int row = obstacleGrid.length;
int colum = obstacleGrid[0].length;
if(obstacleGrid[0][0] == 1) return 0;
// if(row==colum && row==1){
// if(obstacleGrid[0][0] == 1) return 0;
// else return 1;
// }
int max = row>colum?row:colum;
int [][]dp = new int[max][max]; //扩展成方阵
int [][]ob = new int[max][max];
for(int i = 0;i < max;i++){
for(int j = 0;j < max;j++){
if(i<row && j<colum){
ob[i][j] = obstacleGrid[i][j];
}else{
ob[i][j] = 1;
}
}
}
dp[0][0] = 1;
for(int i = 0;i < colum;i++){
if(ob[0][i] == 1) break;
dp[0][i] = 1;
}
for(int i = 0;i < row;i++){
if(ob[i][0] == 1) break;
dp[i][0] = 1;
}
int sr = 0;
int sc = 0;
int [][]dir = {{0,1},{1,0}}; //向右。向下
while(sr<max && sc<max){
for(int i = 0;i < 2;i++){
int nr = sr + dir[i][0];
int nc = sc + dir[i][1];
if(nr<0 || nr>=max || nc<0 || nc>=max) continue;
if(ob[nr][nc] == 1) continue;
//此时可以走
if(nr-1>=0 && nc-1>=0){
//此时不在左上边界，原则上由两条路到达(nr,nc)
System.out.print("不在左、上边界处。更新("+nr+","+nc+")："+dp[nr-1][nc]+"+"+dp[nr][nc-1]);
dp[nr][nc] = dp[nr-1][nc] + dp[nr][nc-1];
System.out.println("更新后到达该位置的路径有："+dp[nr][nc]+"条");
}else if(nr-1<0 && nc-1>=0){
//上边界
System.out.println("在上边界处。更新("+nr+","+nc+")："+dp[nr][nc-1]);
dp[nr][nc] = dp[nr][nc-1];
System.out.println("更新后到达该位置的路径有："+dp[nr][nc]+"条");
}else if(nr-1>=0 && nc-1<0){
//左边界
System.out.println("在左边界处。更新("+nr+","+nc+")："+dp[nr-1][nc]);
dp[nr][nc] = dp[nr-1][nc];
System.out.println("更新后到达该位置的路径有："+dp[nr][nc]+"条");
}
}
sr++;
sc++;
if(sr>=max || sc>=max) break;
//然后更新对角线
if(ob[sr][sc] == 0){
dp[sr][sc] = dp[sr-1][sc] + dp[sr][sc-1]; //不需要判断是否出界
System.out.println("可更新：（"+sr+","+sc+")"+",此时到该点总共有"+dp[sr][sc]+"种走法");
}else{
System.out.println("不可更新：（"+sr+","+sc+")");
}
if(sr==max-1 && sc==max-1) break;
//更新当前元素所在的行、列
updateRowAndColum(ob, dp, sr, sc, row, colum);
}
for(int i = 0;i < max;i++){
for(int j = 0;j < max;j++){
System.out.print(dp[i][j]+"\t");
}
System.out.println();
}
return dp[row-1][colum-1];
}
public void updateRowAndColum(int [][]ob, int [][]dp, int sr, int sc,int row, int colum){
if(sr>=row || sc>=colum) return;
//更新当前一行
for(int i = 1;i < colum;i++){
if(ob[sr][i] == 1) continue;
dp[sr][i] = dp[sr][i-1] + dp[sr-1][i];
}
//更新当前一列
for(int i = 1;i < row;i++){
if(ob[i][sc] == 1) continue;
dp[i][sc] = dp[i-1][sc] + dp[i][sc-1];
}
}
}
扫一扫
403
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
