leetcode62.不同路径-CSDN博客

本文链接：https://blog.csdn.net/xun_zhao_t521/article/details/119844137

这篇博客介绍了如何使用动态规划方法解决网格中从左上角到达右下角的不同路径数量问题。博主提供了四种解决方案：递归（超时）、记忆化递归、标准动态规划以及动态规划的状态压缩。每种方法都详细阐述了实现思路和代码，并讨论了它们的时间和空间复杂度。通过状态转移方程，实现了从起点到终点路径的高效计算，优化了空间复杂度，尤其是状态压缩的方法，仅使用一行空间即可求解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一.题目描述

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：
输入：m = 3, n = 7
输出：28
示例 2：

输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。

向右 -> 向下 -> 向下
向下 -> 向下 -> 向右
向下 -> 向右 -> 向下
示例 3：

输入：m = 7, n = 3
输出：28
示例 4：

输入：m = 3, n = 3
输出：6

提示：

1 <= m, n <= 100
题目数据保证答案小于等于 2 * 109

二.题目解析

1.递归，超时

public int uniquePaths1(int m, int n) {
        /*递归，--超时，包含大量重复的计算
        * */
        if(m <= 0 || n <= 0){
            return 0;
        }
        return findByRecursion1(0,0,m,n);
    }
    private int findByRecursion1(int i,int j,int m,int n){
        if(i >= m || j >= n){
            return 0;
        }
        if(i == m -1 && j == n - 1){
            return 1;
        }
        return findByRecursion1(i,j + 1,m,n) + findByRecursion1(i + 1,j,m,n);
    }

2.记忆化递归

Map<String,Integer> map = new HashMap<>();
    public int uniquePaths(int m, int n) {
        /*记忆化递归
        * */
        if(m <= 0 || n <= 0){
            return 0;
        }
        return findByRecursion(0,0,m,n);
    }
    private int findByRecursion(int i,int j,int m,int n){
        /*第i行第j列格子到第m行第n列格子的路径数
        * */
        //边界条件
        if(i >= m || j >= n){
            return 0;
        }
        if(i == m -1 && j == n - 1){
            return 1;
        }
        String key = i + "*" + j;
        if(map.containsKey(key)){
            return map.get(key);
        }
        //从右边出发的路径数+从下边出发的路径数之和
        int res = findByRecursion(i,j + 1,m,n) + findByRecursion(i + 1,j,m,n);
        map.put(key,res);
        return res;
    }

在这里插入图片描述
3.动态规划

public int uniquePaths2(int m, int n) {
        /*动态规划
        dp[i][j]表示从(0,0)格子到(i,j)格子的路径数
        时间复杂度O(mn),空间复杂度O(mn)
        * */
        if(m <= 0 || n <= 0){
            return 0;
        }
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                //第一行只能由左侧元素而来，路径数是1；第一列只能由上侧元素而来，路径数是1
                if(i == 0 || j == 0){
                    dp[i][j] = 1;
                }else {
                    //状态转移方程
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
        return dp[m - 1][n - 1];
    }

在这里插入图片描述
4.动态规划的状态压缩

public int uniquePaths3(int m, int n) {
        /*动态规划-状态压缩，每一行的值取决于其上一行的值;
        本行的dp[j] = 上一行的dp[j] + 本行的dp[j-1]
        时间复杂度O(mn),空间复杂度O(n)
        * */
        if(m <= 0 || n <= 0){
            return 0;
        }
        int[] dp = new int[n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                //第一行只能由左侧元素而来，路径数是1；第一列只能由上侧元素而来，路径数是1
                if(i == 0 || j == 0){
                    dp[j] = 1;
                }else {
                    //状态转移方程
                    dp[j] = dp[j - 1] + dp[j];
                }
            }
        }
        return dp[n - 1];
    }

在这里插入图片描述
代码还可以简化：

 public int uniquePaths3(int m, int n) {
        /*动态规划-状态压缩，每一行的值取决于其上一行的值;
        本行的dp[j] = 上一行的dp[j] + 本行的dp[j-1]
        时间复杂度O(mn),空间复杂度O(n)
        * */
        if(m <= 0 || n <= 0){
            return 0;
        }
        int[] dp = new int[n];
        //**数组初始化为1，就不用单独处理第一行或者第一列格子了
        Arrays.fill(dp,1);
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                    //状态转移方程
                    dp[j] = dp[j - 1] + dp[j];
            }
        }
        return dp[n - 1];
    }