leetcode 不同路径I.II.III

leetcode 不同路径I
一个机器人位于一个 m x n 网格的左上角, 试图达到网格的右下角。
机器人每次只能向下或者向右移动一步
问总共有多少条不同的路径？

 	// 递归 显然f(m,n) = f(m-1,n) + f(m,n-1).和青蛙跳楼梯类似
 	static Map<String, Integer> map = new HashMap<>();
    public static int uniquePaths(int m, int n) {
        if (m < 1 || n < 1) {
            throw new IllegalArgumentException("参数错误");
        }
        if (m == 1 || n == 1) {
            // 只能一直向右走才能到(1,n)
            // 只能一直向下走才能到(m,1)
            // 通俗点讲就是到第一行或第一列的任意一点都只有1条路径
            return 1;
        }
        // 计算次数较多时递归会超时，由于很多重复计算，用个map缓存下计算结果.空间换时间
        if (map.get(m + "-" + n) != null) {
            return map.get(m + "-" + n);
        }
        int result = uniquePaths(m - 1, n) + uniquePaths(m, n - 1);
        map.put(m + "-" + n, result);
        return result;
    }

    // 动态规划1，数组的val代表到达该点位置的路径数
    public static int uniquePaths2(int m, int n) {
        if (m < 1 || n < 1) {
            throw new IllegalArgumentException("参数错误");
        }
        if (m == 1 || n == 1) {
            // 顶部这行加左边这行都是1.通俗点讲就是到第一行或第一列的任意一点都只有1条路径
            return 1;
        }
        int[][] result = new int[m][n];
        for (int i = 0; i < m; i++) {
            result[i][0] = 1;
        }
        for (int i = 0; i < n; i++) {
            result[0][i] = 1;
        }

        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                result[i][j] = result[i - 1][j] + result[i][j - 1];
            }
        }

        return result[m - 1][n - 1];
    }

    // 动态规划2, 压缩成一维数组
    public static int uniquePaths3(int m, int n) {
        int[] memo = new int[m];
        
        // 顶部这行加左边这行都是1.通俗点讲就是到第一行或第一列的任意一点都只有1条路径
        Arrays.fill(memo, 1);
        for (int i = 1; i < n; i++) {
            // 第二行第二列开始逐行赋值
            for (int j = 1; j < m; j++) {
                // memo[j]赋值时还没被覆盖，保留了同列上一行的记录即上一次循环的数据，
                // memo[j-1]是同行上一列刚赋值的数据
                // 就是递归中的(i,j) = (i-1, j) + (i, j-1)
                memo[j] += memo[j - 1];
            }
        }
        return memo[m - 1];
    }

leetcode 不同路径II
一个机器人位于一个 m x n 网格的左上角, 试图达到网格的右下角。
机器人每次只能向下或者向右移动一步
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径?

	// 数组的val代表到达该点位置的路径数
    public static int uniquePathsWithObstacles(int[][] obstacleGrid) {
 		if (obstacleGrid == null || obstacleGrid.length == 0) {
            throw new IllegalArgumentException("参数错误");
        }
        int clen = obstacleGrid.length;
        int rlen = obstacleGrid[0].length;

        // 设置第一行
        for (int i = 0; i < rlen; i++) {
            if (obstacleGrid[0][i] == 1) {
                // 是障碍就设为0
                obstacleGrid[0][i] = 0;
            } else {
                // 否则等于前面一个格子的val
                obstacleGrid[0][i] = i > 0 ? obstacleGrid[0][i - 1] : 1;
            }
        }
        // 设置第一列
        for (int i = 1; i < clen; i++) {
            if (obstacleGrid[i][0] == 1) {
                // 是障碍就设为0
                obstacleGrid[i][0] = 0;
            } else {
                // 等于上面一个格子的val
                obstacleGrid[i][0] = obstacleGrid[i - 1][0];
            }
        }

        for (int i = 1; i < clen; i++) {
            for (int j = 1; j < rlen; j++) {
                if (obstacleGrid[i][j] == 1) {
                    // 是障碍就设为0
                    obstacleGrid[i][j] = 0;
                } else {
                    // 等于 (上一个格子的val + 前一个格子的val)
                    obstacleGrid[i][j] = obstacleGrid[i - 1][j] + obstacleGrid[i][j - 1];
                }
            }
        }
        return obstacleGrid[clen - 1][rlen - 1];
    }
    // 相比不同路径I就是对障碍进行处理。第一行第一列有障碍,障碍后面/下面的val都为0，其它位置障碍设为0即可

leetcode 不同路径III
在二维网格 grid 上，有 4 种类型的方格：
1 表示起始方格。且只有一个起始方格。
2 表示结束方格，且只有一个结束方格。
0 表示我们可以走过的空方格。
-1 表示我们无法跨越的障碍。
返回在四个方向（上、下、左、右）上行走时，从起始方格到结束方格的不同路径的数目，每一个无障碍方格都要通过一次。

	public static int uniquePathsIII(int[][] grid) {
		if (grid == null || grid.length == 0) {
            throw new IllegalArgumentException("参数错误");
        }
        int sum = 1, r = 0, c = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 0) {
                    sum++; // 求出总步数, 每一个无障碍方格都要通过一次。
                } else if (grid[i][j] == 1) { // 找出起始点位置
                    r = i;
                    c = j;
                }
            }
        }
        return dfs(grid, r, c, sum);
    }

    public static int dfs(int[][] g, int i, int j, int sum) {
        // 越界或障碍
        if (i < 0 || i >= g.length || j < 0 || j >= g[0].length || g[i][j] == -1) {
            return 0;
        }
        // 抵达终点，步数够说明所有方格都跑过,否则此路不通
        if (g[i][j] == 2) {
            return sum == 0 ? 1 : 0;
        }
        int ans = 0;
        g[i][j] = -1; // 访问过该点后设为障碍，防止循环
        // 访问上下左右4个节点
        ans += dfs(g, i + 1, j, sum - 1);
        ans += dfs(g, i - 1, j, sum - 1);
        ans += dfs(g, i, j + 1, sum - 1);
        ans += dfs(g, i, j - 1, sum - 1);
        g[i][j] = 0; // 回溯为空格
        return ans;
    }