使用动态编程计算网格中的路径数量？

Question

坐在NxN网格左上角的机器人。 机器人只能在两个方向上移动： 向右和向下 ，其中一些单元格已死，即机器人无法进入该单元格。机器人有多少条可能的路径？
可以使用Backtracking来解决，但是时间复杂度太高。我已经使用backtracking解决了这个问题，但在更坏的情况下需要O（2 ^ n）。

bool exist(bool a[][], int i, int j,int N){
        return i>=0 && j >=0 && i < N && j < N;
    }
    int search(bool  a[][], int i, int j,int N){
        if(!exist(a,i,j,N) || a[i][j] == 1)
            return 0; // no path here.
        if(i == N-1 && j == N - 1){
            return 1; // 1 path here.
        }
        a[i][j] = 1; // mark that we have seen this spot here
        int paths = 0; // introduce a counter...
        paths += search(a, i,j+1,N); // add the additional paths as we find them
        paths += search(a, i+1,j,N);
        a[i][j] = 0;
        return paths; // return the number of paths available from this point.
    }

此处具有1的单元格表示死单元。 是否可以通过使用DFS或动态编程等方法来减少时间复杂度？

Answer 1

可以通过认识到到特定节点的路径数仅仅是到左边节点的路径数+到上面节点的路径数之和来解决。 您只需要想出一种算法即可以正确的顺序处理节点，即仅在处理完其“父对象”之后再处理节点。 我相信这可以是O（n）。

Answer 2

让我们假设以下3x3网格，其中网格中的1表示障碍物

[0，0，0]
[0，1，0]
[0，0，0]

在这种情况下，唯一路径的数量为2。我们可以使用动态编程方法来减少时间复杂度，找到唯一路径，这是C ++中相同路径的代码

int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {
       int m = obstacleGrid.size();
       int n = obstacleGrid[0].size();

    vector<vector<int> > arr(m,vector<int>(n,0));

    if (obstacleGrid[0][0]==1){return 0;}
    arr[0][0]=1;
    for (int i=1;i<m;i++){
        if (obstacleGrid[i][0]!=1){
            arr[i][0] = arr[i-1][0];
        }
    }
    for (int i=1;i<n;i++){
        if (obstacleGrid[0][i]!=1){
            arr[0][i] = arr[0][i-1];
        }
    }
    for (int i=1;i<m;i++){
        for(int j=1;j<n;j++){
            if (obstacleGrid[i][j]!=1){
                arr[i][j] = arr[i][j-1] + arr[i-1][j];
            }
        }
    }   
    return arr[m-1][n-1];
}

在这种情况下，时间复杂度为O（mn）。

Answer 3

给定一个NxN grid ，让ways[i][j] = number of possible paths from grid[0][0] to grid[i][j]

初始化grid[0][0] = 1

如果grid[i][j] is dead ，则ways[i][j] = 0

else ways[i][j] = ways[i-1][j] + ways[i][j-1] （但要小心边缘）

一个例子：

grid:(1 means dead)   ways:

0 0 1 0 0             1 1 0 0 0
0 0 0 0 0             1 2 2 2 2
0 1 0 0 1             1 0 2 4 0
1 0 0 0 0             0 0 2 6 6
0 0 0 0 0             0 0 2 8 14

我认为复杂度为O(n^2)因为有n*n网格。