62. Unique Paths

最新推荐文章于 2025-08-09 17:01:50 发布
最新推荐文章于 2025-08-09 17:01:50 发布
阅读量187 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 算法 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/aispeech_cc/article/details/89530685
本文介绍了一种使用动态规划算法来计算机器人在限定网格内从左上角到右下角的唯一路径数量的方法。通过实例展示了当网格大小为3x2和7x3时的路径计数，解释了算法的基本原理和实现过程。

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

A robot is located at the top-left corner of a m x n grid (marked ‘Start’ in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked ‘Finish’ in the diagram below).

How many possible unique paths are there?

img
Above is a 7 x 3 grid. How many possible unique paths are there?

Note: m and n will be at most 100.

Example 1:

Input: m = 3, n = 2
Output: 3
Explanation:
From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
1. Right -> Right -> Down
2. Right -> Down -> Right
3. Down -> Right -> Right

Example 2:

Input: m = 7, n = 3
Output: 28

解析：这道题适合用动态规划。分解方法如下：很容易会想到，从原点到某一点（m,n）的路径数量f(m,n)等于原点到点（m-1,n）的路径数加上原点到点（m,n+1）的路径数，也就是f(m,n) = f(m-1, n) + f(m, n-1)，时间复杂度是o(mn)，代码如下：

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] res = new int[m][n];
		for(int i=0;i<m;i++){
			for(int j=0;j<n;j++){
				if(i==0 || j == 0){
					res[i][j] = 1;
				} else {
					res[i][j] = res[i-1][j] + res[i][j-1];
				}

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

解析2：看解答，有一种基于解析1的优化方法，下次看这题时填坑:)

Leetcode | C++ 62.UniquePaths
weixin_54707168的博客
07-14 236
题意 一个机器人目前停留在一个mxn的表格的左上角（如下图所示，标注为’Start’）. 这个机器人只能向下或者向右移动.机器人的目标是尽力到达表格的右下角（下图标注为’Finish’）. 求：一共有多少条不同的路径可以实现机器人的目的. 注意： m 和 n 均不超过 100. 题解 算法及复杂度(0 ms) 分析题目发现，到达一个点的方法只能是从这个点的上方或者左方.所以问题的解可以尝试通过左边的点的解和上边的解的结合得到. 如何结合得到？如果从开始到达(i, j)这个点的上方点(i - 1, j)的路径
LeetCode-62. Unique Paths
晚晴小筑
03-25 403
A robot is located at the top-left corner of a m x n grid (marked ‘Start’ in the diagram below). The robot can only move either down or right at any point in time. The robot is trying to reach the bo...
62. Unique Paths（不同路径）两种解法（C++ & 注释）
主要研究图形学相关领域
07-12 789
62. Unique Paths（不同路径）1. 题目描述2. 回溯法（Backtracking）2.1 解题思路2.2 实例代码 1. 题目描述 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。 问总共有多少条不同的路径？ 例如，上图是一个7 x 3 的网格。有多少可能的路径？ 示例 1: 输入: m = 3, n = 2 输出: 3 解释: 从左上角开始，总共
leetcode 62. Unique Paths
weixin_41554427的博客
04-02 866
这道题用动态规划解答。按照代码随想录介绍的动态规划五部曲来分析。
62.Unique Paths
weixin_30872337的博客
06-10 99
思路： dfs，超时 class Solution { public: int uniquePaths(int m, int n) { return dfs(m,n,0,0); } int dfs(int m,int n,int curi,int curj){ if(m-1 == curi && n-1 == curj) ...
leetcode 62. Unique Paths（独特的路径）
蓝羽飞鸟的博客
08-01 242
leetcode 62题解
动态规划入门详解+例题P1049装箱问题/62. Unique Paths
m0_51344172的博客
01-31 764
动态规划入门详解+例题P1049装箱问题/62. Unique Paths 小蒟蒻自己的学习记录，呜呜呜 算法思想 动态规划是一种分治思想，但与分支算法不同的是，动态规划也是把原问题分解为若干子问题，然后自底向上，求解最小的子问题，叭结果存储在表格中，再求解大的子问题时，直接从表格中查询小的子问题的解，避免重复计算，从而提高算法效率。 题目特点/算法要素 计数 有多少种方法走到右下角 有多少种方法选出k个数使得和是Sum 求最大最小值 从左上角走到右下角路径的最大数字和 最长上升子序列长度 求存
pcw0118#ZXBlog#LeetCode-62.Unique Paths(不同的路径数量)(简单dp)1
07-25
1、记忆化 2、二维dp 3、滚动优化
leetcode 62. Unique Paths（python）
王大呀呀的博客
07-26 411
另外可以将动态规划的 dp 压缩成一维的列表进行解题，原理和上面大同小异， df[j] = df[j]+df[j-1] 就是相当于上面解法的 dp[i][j] = dp[i][j-1] + dp[i-1][j] ，能节省不少的内存。根据题意，就是给出了一个 m x n 大小的方格矩阵，左上角是起始位置，右下角是结束位置，问从开始位置走到结束位置过程中，只能向下和向右走，一共有多少种不同的路径。原题链接：https://leetcode.com/problems/unique-paths/
62.Unique Paths(不同路径) 文字加详细图解- LeetCode
lsely的博客
12-17 388
前面我们推导出了本题的状态转移方程，由于任意一个网格dp(i,j)的状态是由上方网格dp(i-1,j)与左方网格dp(i,j-1)推导而来，所以我们需要将dp(0,j)与dp(i,0)这两列网格进行状态初始化。，机器人可由dp(i-1,j)或dp(i,j-1)移动到dp(i,j)，那么走到dp(i,j)的走法便是两条不同路径dp(i-1,j)或dp(i,j-1)走法的和了。，在这里我再强调一下，dp(i-1,j)或dp(i,j-1)的含义并不是需要走多少步，而是。
力扣 hot100 Day68
qq_51397044的博客
08-08 231
每个元素都会入栈，当当前数小于栈顶值时，开始处理栈内元素，由于此时栈顶慢慢弹出递减，而宽度慢慢弹出递增，所以此时比较是有意义的。对于一个特定高度，最大的矩形就是左右边界都比该高度更高的范围，这在该循环中都遍历到了。个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1。求在该柱状图中，能够勾勒出来的矩形的最大面积。开始时在原序列末加入0值，防止最后有元素未处理。单调栈，栈内保存一个自栈底递增至栈顶的序列。
Swift 实战：高效设计 Tic-Tac-Toe 游戏逻辑（LeetCode 348）
网罗天下方法，方便你我开发！！！
08-07 985
如果让你实现一个两人对战的井字棋（Tic-Tac-Toe）游戏逻辑，你会怎么做？是不是会直接用二维数组存每个格子的状态，然后在每次落子后从头到尾检查是否赢了？ 这种方式虽然直观，但效率并不高，特别是当棋盘扩大到 n×n 的时候。LeetCode 348 这个题目就挑战我们去优化这个过程：每次落子之后都要快速判断胜负，尽可能降低计算开销。
leetcode 11. 盛最多水的容器 -java
最新发布
weixin_41624462的博客
08-09 71
这是因为木桶底部长度在指针在两头时是最大的，指针内移x轴长度一定会减小，这时如果想要获取更大面积，需要获取两个height里较小的那个，让他增大，面积才会增大，所以较小的元素的指针向内循环，寻找更大的值，一直到左右两个指针重合，结束循环。改进：接水 - 接多少水取决于短版的长度，所以可以使用双指针法，每次比较，保留较大元素的指针不动，较小元素的指针平移寻找更大的指针，直到两个指针相遇。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。说明：你不能倾斜容器。
LeetCode有效三角形的个数
Chihiro_wyj的博客
08-08 251
文章摘要： 题目要求统计数组中能构成三角形的三元组个数。解题关键在于排序后利用双指针技巧：固定最长边nums[third]，用双指针first和second在左侧寻找满足nums[first]+nums[second]>nums[third]的组合。当条件满足时，first到second之间的所有数对都有效，可直接累加结果。时间复杂度因排序和双指针优化降至O(n^2)。代码实现先排序数组，外层循环固定third，内层用双指针搜索有效组合，通过移动指针动态统计满足条件的数对数量。
【纵火犯的春天】纵火犯是如何解题leetcode的?
2301_79903357的博客
08-06 449
一段时间过后，我们发现没路了，前面是海，后面是已做好标记的烧光的陆地，那我们就要考虑停下了，这就是烧光的一整个岛屿。想想我们是一位纵火犯，我们的目的是烧光所有的陆地，可是现在有个问题，陆地并不全是连续的，所以就产生了岛屿，我们想要烧光每一块陆地，就必须到达一块陆地相邻的所有陆地，称之为一个“岛屿”。这个题目可以考虑DFS（深度优先）解决，但是暴力好像也能做，但是非常非常繁琐，远没有递归来的简洁高效，正好这个题目也可以练习熟悉一下递归。，那我们就想，我烧完这块陆地，我就得标记一下，这里用。
分治-快排-215.数组中的第k个最大元素-力扣(LeetCode)
black_bear_white的博客
08-08 255
LeetCode Hot 100 单词拆分
2302_76776557的博客
08-08 280
我们定义 dp[i] 表示字符串 s 前 i 个字符组成的字符串 s[0..i−1] 是否能被空格拆分成若干个字典中出现的单词。公式化来说，我们需要枚举 s[0..i−1] 中的分割点 j ，看 s[0..j−1] 组成的字符串 s。对于检查一个字符串是否出现在给定的字符串列表里一般可以考虑哈希表来快速判断，同时也可以做一些简单的剪枝，枚举分割点的时候倒着枚举，如果分割点 j 到 i 的长度已经大于字典列表里最长的单词的长度，那么就结束枚举，但是需要注意的是下面的代码给出的是不带剪枝的写法。
【力扣 Hot100】 刷题日记
2301_79903357的博客
08-08 303
结果是错误的，因为这个题目橘子腐烂是同时的，腐烂的橘子一分钟就可以同时影响到周围橘子，而且要统计时间，深度优先遍历会朝着一个方向的橘子一直找下去，显然忽略了时间对其他方向橘子的影响，忽略了时间性，不符合题意。广度优先遍历的思路就是，先遍历腐烂的橘子位置list1，记录当前影响到的其他腐烂橘子位置list2，对list2重复过程，是广度有先的。遍历单元格，记录初始已腐烂的橘子位置，遍历腐烂位置，对每个橘子模拟四个方向橘子同时腐烂的过程，将新的位置加入到。仍然大于0，就说明又不会腐烂的橘子。
TypeError: Solution.uniquePaths() missing 1 required positional argument: 'n'
06-04
<think>我们正在处理一个TypeError，提示Solution.uniquePaths方法缺少必要位置参数'n'。这个错误通常发生在调用类的方法时，没有提供足够的位置参数。假设我们有一个类Solution，其中定义了一个方法uniquePaths，这个方法需要两个位置参数（比如m和n），但在调用时只提供了一个（比如只提供了m，而缺少n）。例如：classSolution:defuniquePaths(self,m,n):#一些代码当我们这样调用时：Solution().uniquePaths(3)#这里只提供了一个参数3，但方法需要两个参数（除了self）就会导致错误：TypeError:uniquePaths()missing1requiredpositionalargument:'n'因此，我们需要确保在调用uniquePaths时传递两个整数参数（m和n）。例如：Solution().uniquePaths(3,7)#计算3行7列的网格但是，如果这个方法是静态方法或类方法，可能不需要self，但错误信息仍然会提示缺少参数。下面我们分步骤解释如何解决：步骤1：检查方法定义确保在类中定义uniquePaths方法时，参数包括self（如果是实例方法）、m和n。例如：defuniquePaths(self,m,n):步骤2：检查调用方式在调用时，必须传入两个参数（如果是实例方法，则通过实例调用，并传入m和n；如果是静态方法，则直接传入m和n）。步骤3：注意调用方法时使用的实例如果使用类名直接调用实例方法，则需要显式传递一个实例作为self，然后再传递m和n。通常我们不会这样做，而是创建实例：sol=Solution()sol.uniquePaths(m,n)或者直接：Solution().uniquePaths(m,n)步骤4：如果方法定义为静态方法如果在定义时使用了@staticmethod装饰器，那么就不需要self，但是调用时仍然需要传入两个参数：classSolution:@staticmethoddefuniquePaths(m,n):...调用：Solution.uniquePaths(m,n)#通过类名调用步骤5：如果方法定义为类方法使用@classmethod，第一个参数是cls，然后是两个参数：classSolution:@classmethoddefuniquePaths(cls,m,n):...调用：Solution.uniquePaths(m,n)#通过类名调用步骤6：处理默认参数如果方法的某些参数有默认值，则调用时可以省略。但如果没有默认值，则必须传递。因此，针对这个错误，解决方案是：在调用uniquePaths方法时，确保传递了两个整数参数（m和n）。示例代码：正确调用实例方法：sol=Solution()result=sol.uniquePaths(3,7)或者：result=Solution().uniquePaths(3,7)正确调用静态方法（假设方法被定义为静态）：result=Solution.uniquePaths(3,7)注意：在静态方法和类方法的定义中，第一个参数不是self，因此在调用时不需要传递实例或类（对于静态方法）或者只需要传递类（对于类方法，但通常通过类名调用会自动传递类）。但要注意参数个数。如果问题仍然存在，请检查方法定义和调用的地方是否一致。下面是一个完整的例子（动态规划解决网格路径问题）供参考：```pythonclassSolution:defuniquePaths(self,m,n):#创建一个二维列表用于存储到达每个网格的路径数dp=[[1]*nfor_inrange(m)]#动态规划计算路径数foriinrange(1,m):forjinrange(1,n):dp[i][j]=dp[i-1][j]+dp[i][j-1]returndp[m-1][n-1]#调用sol=Solution()print(sol.uniquePaths(3,7))#传递两个参数```如果我们尝试调用sol.uniquePaths(3)，则会出现错误，因为缺少第二个参数n。因此，请确保在调用时提供了两个参数。</think> 针对TypeError: `Solution.uniquePaths()` missing required positional argument 'n' 的问题，这是由于调用方法时缺少必要的参数导致的。以下是详细分析和解决方案： ### 问题原因分析 1. **方法签名不匹配** `uniquePaths` 方法需要接收特定的位置参数（如 `m` 和 `n`），但调用时只传递了部分参数。例如： ```python class Solution: def uniquePaths(self, m: int, n: int) -> int: # 需要两个参数 ... # 错误调用（缺少n） Solution().uniquePaths(3) # ❌ 缺少第二个参数n ``` 2. **实例化与调用分离问题** 若通过类名直接调用方法而非实例方法，会遗漏实例参数： ```python # 错误调用（未实例化） Solution.uniquePaths(3, 7) # ❌ 缺少self参数 ``` 3. **方法绑定类型错误** 静态方法定义不当会导致参数传递混乱： ```python class Solution: @staticmethod def uniquePaths(m, n): # 静态方法无self参数 ... # 错误实例化调用 Solution().uniquePaths(3, 7) # ❌ 多传了self参数 ``` ### 解决方案 #### ✅ 方案1：补充完整参数（推荐） 确保传递所有必需参数： ```python class Solution: def uniquePaths(self, m: int, n: int) -> int: dp = [[1] * n for _ in range(m)] for i in range(1, m): for j in range(1, n): dp[i][j] = dp[i-1][j] + dp[i][j-1] return dp[-1][-1] # 正确调用 print(Solution().uniquePaths(3, 7)) # 输出网格路径数 ``` #### ✅ 方案2：使用默认参数 在方法定义中设置默认值避免遗漏： ```python class Solution: def uniquePaths(self, m: int, n: int = 1): # n默认值为1 if n == 1: # 边界情况处理 return 1 ... # 灵活调用 Solution().uniquePaths(3) # 使用默认n=1 Solution().uniquePaths(3, 7) # 显式指定n ``` #### ✅ 方案3：正确使用静态方法 统一静态方法的调用方式： ```python class Solution: @staticmethod def uniquePaths(m: int, n: int) -> int: ... # 通过类名调用（无需实例化） Solution.uniquePaths(3, 7) # ✅ ``` ### 关键检查点 1. 方法定义中参数数量（包括 `self`） 2. 调用时实参与形参匹配度 3. 方法类型（实例方法/静态方法）与调用方式的一致性 > 路径计数问题中，动态规划是常见解法：通过二维数组存储中间状态，时间复杂度为 $O(m \times n)$，空间复杂度可优化至 $O(n)$[^1]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值