力扣第62题 不同路径 c++ 动态规划 dp二维 + dp一维 解法

题目

62. 不同路径

中等

相关标签

数学 动态规划 组合数学

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

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

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

示例 1:

复制代码
输入:m = 3, n = 7
输出:28

示例 2:

复制代码
输入:m = 3, n = 2
输出:3
解释:
从左上角开始,总共有 3 条路径可以到达右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3:

复制代码
输入:m = 7, n = 3
输出:28

示例 4:

复制代码
输入:m = 3, n = 3
输出:6

提示:

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

思路和解题方法

  1. 首先,创建一个大小为m×n的二维数组dp,并将所有元素初始化为0。这个二维数组用于保存到达每个位置的唯一路径数量。
  2. 然后,通过两个循环分别将第一行和第一列的元素设置为1。因为从起点出发,只有一条路径可以到达第一行和第一列的任意位置。
  3. 接下来,使用两个嵌套的循环遍历除第一行和第一列之外的其他位置。对于每个位置(i, j),它可以从上方的位置(i-1, j)或左边的位置(i, j-1)到达。因此,到达当前位置的唯一路径数量等于到达上方位置和左边位置的唯一路径数量之和,即dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
  4. 最后,返回dp[m - 1][n - 1],即到达右下角位置的唯一路径数量。

复杂度

时间复杂度:

O(m*n)

时间复杂度为O(m*n),其中m和n分别是网格的行数和列数。这是因为代码中使用了两个嵌套的循环来遍历整个网格,所以时间复杂度与网格的大小成正比。

空间复杂度

O(n)

空间复杂度为O(n),其中n是网格的列数。这是因为代码使用了一个大小为n的一维数组dp来保存到达每个位置的路径数。在算法执行过程中,只需要不断更新这个数组中的元素,所以只占用了常数级别的额外空间。因此,空间复杂度与网格的大小无关。

c++ 代码

cpp 复制代码
class Solution {
public:
    int uniquePaths(int m, int n) {
        // 创建一个大小为m×n的二维数组,用于保存到达每个位置的唯一路径数量
        vector<vector<int>> dp(m, vector<int>(n, 0));
        
        // 将第一行的所有元素设置为1,因为从起点出发只有一条路径可以到达第一行的任意位置
        for (int i = 0; i < m; i++)
            dp[i][0] = 1;
        
        // 将第一列的所有元素设置为1,因为从起点出发只有一条路径可以到达第一列的任意位置
        for (int j = 0; j < n; j++)
            dp[0][j] = 1;
        
        // 使用动态规划的思想计算除第一行和第一列之外的其他位置的唯一路径数量
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                // 到达当前位置的唯一路径数量等于到达上方位置和左边位置的唯一路径数量之和
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        
        // 返回到达右下角位置的唯一路径数量
        return dp[m - 1][n - 1];
    }
};

优化空间代码

cpp 复制代码
class Solution {
public:
    int uniquePaths(int m, int n) {
        // 创建一个大小为n的一维数组dp,用于保存到达每个位置的路径数
        vector<int> dp(n);
        
        // 初始化dp数组,将第一行的路径数都设置为1
        for (int i = 0; i < n; i++) {
            dp[i] = 1;
        }
        
        // 使用动态规划的思想计算到达每个位置的路径数
        for (int j = 1; j < m; j++) {
            for (int i = 1; i < n; i++) {
                // 当前位置的路径数等于上方位置的路径数加左侧位置的路径数
                dp[i] += dp[i - 1];
            }
        }
        
        // 返回到达右下角位置的路径数,即dp数组的最后一个元素
        return dp[n - 1];
    }
};

解释

  1. 首先,创建一个大小为n的一维数组dp,用于保存到达每个位置的路径数。
  2. 然后,初始化dp数组,将第一行的路径数都设置为1,因为在第一行的任意位置,只能向右移动,所以只有一条路径可选。
  3. 接着,使用动态规划的思想计算到达每个位置的路径数。从第二行开始遍历到第m行,在每一行中,从第二列开始遍历到第n列,在每次循环中,当前位置的路径数等于上方位置的路径数加左侧位置的路径数,即dp[i] += dp[i - 1]
  4. 最后,返回到达右下角位置的路径数,即dp数组的最后一个元素。
  5. 时间复杂度:O(m × n)
  6. 空间复杂度:O(n)

觉得有用的话可以点点赞,支持一下。

如果愿意的话关注一下。会对你有更多的帮助。

每天都会不定时更新哦 >人< 。

相关推荐
YL2004042616 小时前
048路径总和III
数据结构·dfs
z2005093016 小时前
每日简单算法题——————跟着卡尔
算法
️是7818 小时前
信息奥赛一本通—编程启蒙(3395:练68.3 车牌问题)
数据结构·c++·算法
Liangwei Lin18 小时前
LeetCode 118. 杨辉三角
算法·leetcode·职场和发展
计算机安禾18 小时前
【c++面向对象编程】第24篇:类型转换运算符:自定义隐式转换与explicit
java·c++·算法
鼠鼠我(‘-ωก̀ )好困18 小时前
leetGPU
算法
我星期八休息18 小时前
Linux系统编程—基础IO
linux·运维·服务器·c语言·c++·人工智能·算法
池塘的蜗牛18 小时前
A Low-Complexity Method for FFT-based OFDM Sensing
算法
故事和你9119 小时前
洛谷-【图论2-1】树5
开发语言·数据结构·c++·算法·动态规划·图论
咖啡里的茶i19 小时前
视觉显著目标的自适应分割与动态网格生成算法研究
人工智能·算法·目标跟踪