题目

题意

示例 1

示例 2

示例 3

提示

$1 <= g r i d . l e n g t h * g r i d [0] . l e n g t h <= 20$

官方题解

回溯

思路

按照要求，假设矩阵中有 $n$ 个 $0$ ，那么一条合格的路径，是长度为 $(n + 1)$ ，由 $1$ 起始，结束于 $2$ ，不经过 $- 1$ ，且每个点只经过一次的路径。
要求出所有的合格的路径，可以采用回溯法，定义函数 $df s$ ，表示当前 $g r i d$ 状态下，从点 $(i, j)$ 出发，还要经过 $n$ 个点，走到终点的路径条数。
到达一个点时，

如果当前的点为终点，且已经经过了 $(n + 1)$ 个点，那么就构成了一条合格的路径，否则就不构成。
如果当前的点不为终点，则将当前的点标记为 $- 1$ ，表示这条路径以后不能再经过这个点，然后继续在这个点往四个方向扩展，如果不超过边界且下一个点的值为 $0$ 或者 $2$ ，则表示这条路径可以继续扩展。

探测完四个方向后，需要将当前的点的值改为原来的值。
将四个方向的合格路径求和，即为当前状态下合格路径的条数。
最终需要返回的是， $g r i d$ 在初始状态下，从起点出发，需要经过 $(n + 1)$ 个点的路径条数。

复杂度

时间复杂度：O(4^(r * c))，其中 $r$ 和 $c$ 分别是 $g r i d$ 的行数和列数。
空间复杂度：O(r * c)，是回溯的深度。

本人代码

Java

class Solution {
    public int uniquePathsIII(int[][] grid) {
        //获取路径总长度 n 和起始坐标 (x, y)
        int n = 0, x = 0, y = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[i].length; j++) {
                if (grid[i][j] == 0) {
                    n++;
                } else if (grid[i][j] == 1) {
                    x = i;
                    y = j;
                    n++;
                }
            }
        }
        //开始递归寻路
        return dfs(x, y, n, grid);
    }

    public int dfs(int x, int y, int n, int[][] grid) {
        //防止越界和躲开障碍
        if (x < 0 || x >= grid.length || y < 0 || y >= grid[x].length || grid[x][y] == -1) {
            return 0;
        }

        //如果已经到达终点，并且剩余路径长度为 0
        //即已经找到一条符合要求的路径
        if (grid[x][y] == 2) {
            return n == 0 ? 1 : 0;
        }
        
        //记录路径数量
        int res = 0;

        //将走过的路置为 -1，不可再次通过
        int t = grid[x][y];
        grid[x][y] = -1;

        //往四个方向寻路
        res += dfs(x - 1, y, n - 1, grid);
        res += dfs(x + 1, y, n - 1, grid);
        res += dfs(x, y - 1, n - 1, grid);
        res += dfs(x, y + 1, n - 1, grid);

        //将走过的路重置为通路，不影响后面寻路
        grid[x][y] = t;

        return res;
    }
}

提交结果：通过

执行用时: $0 m s$
内存消耗: $38.8 MB$