刷题第39天 | 62.不同路径、63. 不同路径 II

62. Unique Paths

题目链接：62. Unique Paths
思路链接：代码随想录动态规划-不同路径

思路

动态规划：
时间复杂度：O(mn)
空间复杂度：O(mn)

1. 确定dp数组：走到第i行，第j列时有dp[i][j]种走法
2. 初始化dp数组
3. 递归表达式：dp[i][j] = dp[i][j - 1] + dp[i - 1][j]
4. 遍历顺序：按行来从左到右一行一行遍历
5. 打印dp数组
   

深度优先搜索：
时间复杂度：O(2^(m + n - 1) - 1)

排列组合法：
时间复杂度：O(m)
空间复杂度：O(1)

要防止两个int相乘溢出！

Code

class Solution {
    public int uniquePaths(int m, int n) {
        // 确定dp数组：走到第i行，第j列时有dp[i][j]种走法
        int[][] dp = new int[m][n];
        // 初始化dp数组
        for (int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }
        for (int j = 0; j < n; j++) {
            dp[0][j] = 1;
        }
        // 递归表达式：dp[i][j] = dp[i][j - 1] + dp[i - 1][j]
        // 遍历顺序：按行来从左到右一行一行遍历
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
            }
        }
        // 打印dp数组
        // for (int i = 0; i < m; i++) {
        //     for (int j = 0; j < n; j++) {
        //         System.out.print(dp[i][j] + " ");
        //     }
        //     System.out.println("");
        // }
        return dp[m - 1][n - 1];
    }
}

class Solution {
    private int dfs(int m, int n, int i, int j) {
        if (i > m || j > n) return 0; // 越界
        if (i == m && j == n) return 1; // 找到一种方法
        return dfs(m, n, i + 1, j) + dfs(m, n, i, j + 1);
    }
    
    public int uniquePaths(int m, int n) {
        // dfs写法
        return dfs(m, n, 1, 1);
    }
}

class Solution {
    public int uniquePaths(int m, int n) {
        // 排列组合写法
        // choose m - 1 from m + n - 2 elements
        long numerator = 1; // 分子
        long denominator = m - 1; // 分母
        long count = m - 1;
        long t = m + n - 2;
        while (count != 0) {
            numerator *= t;
            t--;
            while (denominator != 0 && numerator % denominator == 0) {
                numerator /= denominator;
                denominator--;
            }
            count--;
        }
        return Math.toIntExact(numerator);
    }
}

63. Unique Paths II

题目链接：63. Unique Paths II
思路链接：代码随想录动态规划-不同路径 II

思路

1. 确定dp数组：走到第i行，第j列时有dp[i][j]种走法
2. 递推表达式：dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
3. 初始化数组 (这里的初始化处理很重要)：如果遇到障碍物，那么障碍物之后不同更新为1，因为走不到
4. 遍历顺序：一行一行来从左到右；注意要讨论遇到障碍物的情况
5. 打印dp数组

Code

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        if (obstacleGrid[obstacleGrid.length - 1][obstacleGrid[0].length - 1] == 1) {
            return 0;
        }
        if (obstacleGrid[0][0] == 1) {
            return 0;
        }
        // 确定dp数组：走到第i行，第j列时有dp[i][j]种走法
        int[][] dp = new int[obstacleGrid.length][obstacleGrid[0].length];
        // 递推表达式：dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
        // 初始化数组 (这里的初始化处理很重要)
        for (int i = 0; i < obstacleGrid.length && obstacleGrid[i][0] == 0; i++) {
            dp[i][0] = 1;
            
        }
        for (int j = 0; j < obstacleGrid[0].length && obstacleGrid[0][j] == 0; j++) {
                dp[0][j] = 1;
        }
        // 遍历顺序：一行一行来从左到右
        for (int i = 1; i < dp.length; i++) {
            for (int j = 1; j < dp[0].length; j++) {
                if (obstacleGrid[i][j] == 1) {
                    continue;
                }
                if (obstacleGrid[i - 1][j] == 1) {
                    dp[i][j] = dp[i][j - 1];
                } else if (obstacleGrid[i][j - 1] == 1) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
        // 打印dp数组
        // for (int i = 0; i < dp.length; i++) {
        //     for (int j = 0; j < dp[0].length; j++) {
        //         System.out.print(dp[i][j] + " ");
        //     }
        //     System.out.println("");
        // }
        return dp[dp.length - 1][dp[0].length - 1];
    }
}