- 博客(157)
- 收藏
- 关注
RSS订阅原创 代码随想录|单调栈|03求下一个更大的元素II
给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。这里数组变成了循环数组，我最开始想得是把数组复制一个，然后拼接在后面。单调栈找右边第一个比它大的元素，全部套“每日温度”这个题的模版。其实也不需要再去新建一个数组，而是通过。比如原来的数组是【1 2 1】的方式去便利这个环形数组。
2025-06-09 21:18:26
136
原创 代码随想录|单调栈|02下一个更大元素I
为什么需要构建映射逻辑，因为我们用nums2构建单调栈，但是在计算result的时候，是要看nums1的元素，所以在nums2中准备添加result时候，要看一下这个元素在不在nums1里面，如果在的话，就添加到相应的位置。nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。对于 num1 中的数字 4 ，你无法在第二个数组中找到下一个更大的数字，因此输出 -1。对于 num1 中的数字 2 ，第二个数组中没有下一个更大的数字，因此输出 -1。
2025-06-09 20:36:40
237
原创 代码随想录|单调栈|1每日温度
例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。i=1，T[i]=74，因为74>73，所以弹出top放入i，同时可以计算result[top]=i-top，此时top=74。i=2，T[i]=75，因为75>74，所以弹出top放入i，同时可以计算result[top]=i-top，此时top=75。这里单调栈里面存的是索引，而不是元素，因为要计算索引之间的差值。
2025-06-08 21:44:42
275
原创 代码随想录|动态规划|53最长回文子序列
根据dp的定义，可以知道j一定是大于等于i的，而i=j的情况是我们在初始化定义的，所以地推的时候j要从i+1开始。如果s[i] = s[j]，就看里面的子序列，此时dp[i][j] = dp[i+1][j-1] + 2。[i,i]是回文的，所以dp[i][i]=1，其他的就初始化为0，因为确实不知道到底是不是回文。如果s[i] ≠ s[j]，就要考虑[i,j-1] [i+1,j] 这两种情况，取最大的值。示例 1: 输入: "bbbab" 输出: 4 一个可能的最长回文子序列为 "bbbb"。
2025-06-07 21:44:37
388
原创 代码随想录|动态规划|52回文子串
dp如何定义，这里不能像之前那样，定义成以i为结尾什么的，假如说定义dp[i]是以i为结尾的回文数组，但是发现是很难找到递推关系的。（3）i ≠ j的条件下，dp[i][j]=false，所以初始化都给它定义为false，然后在循环里面就直接不用考虑这个情况了。具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。注意是只有左下角，左边和下面都没有，所以在第二层循环的时候，j要从i开始。dp[i][j]表示[i,j]的子串是回文子串。dp的定义，是根据回文子串的性质来写的。
2025-06-07 21:18:58
387
原创 代码随想录|动态规划|50编辑距离
解释： intention -> inention (删除 't') inention -> enention (将 'i' 替换为 'e') enention -> exention (将 'n' 替换为 'x') exention -> exection (将 'n' 替换为 'c') exection -> execution (插入 'u')以[i-1]结尾的word1和以[j-1]结尾的word2，最近的编辑距离是dp[i][j]word1删：dp[i][j]=dp[i-1][j]+1。
2025-06-04 22:09:05
543
原创 代码随想录|动态规划|49两个字符串的删除操作
题目题目给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。思路本题和“不同的子序列”相比，就是两个子序列都可以进行删除操作。动归五部曲（1）dp含义dp[i][j]：以i-1为结尾的字符串word1，和以j-1位结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。（2）递推公式。
2025-06-04 21:33:06
389
原创 代码随想录|动态规划|48不同的子序列
一部分是用s[i - 1]来匹配，那么个数为dp[i - 1][j - 1]。当s[i - 1] 与 t[j - 1]不相等时，dp[i][j]只有一部分组成，不用s[i - 1]来匹配（就是模拟在s中删除这个元素）所以当s[i - 1] 与 t[j - 1]相等时，dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。所以 dp[i][j] = dp[i-1][j]
2025-06-02 21:38:09
400
原创 代码随想录|动态规划|47判断子序列
（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。如果s[i - 1] == t[j - 1]，那么这两段子序列最后一个字符相同，同时去掉最后这个字符，然后再找公共子序列长度，最后+1。dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。当时写的是 max(dp[i - 1][j], dp[i][j - 1])给定字符串 s 和 t ，判断 s 是否为 t 的子序列。t的长度要比s更长，所以只写dp[i][j - 1]
2025-06-02 20:56:08
366
原创 代码随想录|动态规划|46最大子序和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。贪心之前做过，这里用动态规划还是更为简单。
2025-06-01 20:10:43
122
原创 代码随想录|动态规划|45不相交的线
直线不能相交，这就是说明在字符串nums1中 找到一个与字符串nums2相同的子序列，且这个子序列不能改变相对顺序，只要相对顺序不改变，连接相同数字的直线就不会相交。在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。第一眼看真的不清楚，这种就是在基础题上面套了应用的外壳，但是自己看不出来😅。请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。以这种方法绘制线条，并返回可以绘制的最大连线数。就是跟上面的 “最长公共子序列” 是一样的。代码也是一样的，就是变量名字换了。
2025-06-01 19:59:23
230
原创 代码随想录|动态规划|44最长公共子序列
上一题因为是连续的，所以如果A[i-1][j-1]≠B[i-1][j-1]，对于dp[i][j]没有影响。根据dp[i][j]的定义，dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。那么dp[i][j] = max(dp[i][j-1] , dp[i-1][j])（为什么是i-1 j-1在之前已经解释过了，为了方便初始化）所以如果A[i-1][j-1]≠B[i-1][j-1]如果A[i-1][j-1]==B[i-1][j-1]那么dp[i][j]=dp[i-1][j-1]+1。
2025-05-31 22:32:55
411
原创 代码随想录|动态规划|43最长重复子数组
dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。但是为了递推公式还是需要初始化的，dp[i][0] 和 dp[0][j]都初始化为0即可，不会影响到后面的递推。根据dp[i][j]的定义，dp[i][0] 和dp[0][j]其实都是没有意义的。dp[1][1] = dp[0][0] + 1，结果应该是1。那么i的范围是[1,lenA]，j的范围是[1,lenB]那么dp[i][j]=dp[i-1][j-1]+1。所以dp[0][0]=0。
2025-05-22 11:38:00
303
原创 代码随想录|动态规划|42最长连续递增子系列
连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。跟上面一道题的区别在于，这里是连续的，也就是如果dp[i]>dp[i-1]那么dp[i]=dp[i-1]+1。
2025-05-22 11:03:39
395
原创 代码随想录|动态规划|41最长上升子系列
子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值。给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。每一个i，对应的dp[i]（即最长递增子序列）起始大小至少都是1。外层是i，内层是j，j的范围是[0,i)，所以i从1开始就可以。，可以跳，但是顺序维持原数组顺序！
2025-05-22 10:54:10
559
原创 代码随想录|动态规划|39买卖股票的最佳时机含手续费
给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格；非负整数 fee 代表了交易股票的手续费用。你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。在卖出股票的时候，需要减去手续费。dp[i][1] 第i天不持有股票。dp[i][0] 第i天持有股票。看到这里就总结一下股票问题吧。返回获得利润的最大值。
2025-05-20 10:49:49
137
原创 代码随想录|动态规划|37买卖股票最佳时机含冷冻期
dp[i][1] 不持有股票状态，保持卖出股票的状态（两天前就卖出了股票，度过一天冷冻期。由于dp[0][0]=dp[0][1]-prices[1]，第1天买入股票，那么第0天的现金默认是0，dp[i][0] 持有股票状态（今天买入股票，或者是之前就买入了股票然后没有操作，一直持有）。dp[i][j]，第i天状态为j，所剩的最多现金为dp[i][j]。dp[i][3] 今天为冷冻期状态，但冷冻期状态不可持续，只有一天！dp[i][2] 不持有股票状态，今天卖出股票。所以dp[0][1]=0。
2025-05-20 10:41:58
362
原创 代码随想录|动态规划|36买卖股票的最佳时机IV
输出：7 解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4。随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3。输出：2 解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2。输入：k = 2, prices = [2,4,1]
2025-05-19 16:38:08
781
原创 代码随想录|动态规划|35买卖股票的最佳时机III
输出：6 解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3。随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3。输出：4 解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4。输入：prices = [3,3,5,0,0,3,1,4]
2025-05-19 11:03:53
483
原创 代码随想录|动态规划|34买卖股票的最佳时机II
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4。解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4。所以dp[i][0]=max(dp[i-1][0],dp[i-1][1]-prices[i])所以dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[i])输入: [7,1,5,3,6,4]
2025-05-16 14:27:52
859
原创 代码随想录|动态规划|32买卖股票的最佳时机
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。dp[0][0]=-prices[0]，因为第一天就买了，但是本来手头上最大金钱为0，这样相当于贷款。在遍历的过程中计算dp[i][0]和dp[i][1]，最终的结果只要dp[len-1][1]？dp[0][1]=0，第一天不买，手头上就是0。（1）dp[i][0] 表示第i天。
2025-05-16 11:44:52
628
1
原创 代码随想录|动态规划|31打家劫舍III
之前打家劫舍的问题，我们最后求的是dp[nums.size()-1]也就是偷最后一个房子的最大金钱，那么这里按照后序遍历，可以把root根节点看作是最后的房子。这里不可以再用i去代表每一个状态的下标了，因为是二叉树，不是数组，二叉树有自己的遍历方式。树形dp，dp数组的形式真的没想到还能这样子写，归根还是在于数组跟树的遍历区别，树的遍历一定是那3种遍历顺序的，你用下标i根本无法表示。父节点一定和子节点连着的，所以相邻的节点不可以都偷，只能隔着偷。通过递归左节点，得到左节点偷与不偷的金钱。
2025-04-06 12:56:22
583
原创 代码随想录|动态规划|30打家劫舍II
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。当然情况2、3实际上包含了情况1，比如情况2，我只是考虑了首元素，没说一定要选啊。输入：nums = [1,2,3,1]输入：nums = [2,3,2]
2025-04-06 12:11:37
443
原创 代码随想录|动态规划|29打家劫舍
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。然后dp[i]取最大值，即dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);（1）dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。如果偷第i房间，那么dp[i] = dp[i - 2] + nums[i]如果不偷第i房间，那么dp[i] = dp[i - 1]，即考虑i-1房，（（3）递推公式有i-2和i-1，所以初始化应该考虑dp[0]和dp[1]。
2025-04-06 12:09:51
337
原创 代码随想录|动态规划|26单词拆分
（2）如果确定dp[j] 是true，且 [j, i] 这个区间的子串出现在字典里，那么dp[i]一定是true。给定一个非空字符串 s 和一个包含非空单词的列表 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。（1）dp[i]： 字符串长度为i的话，dp[i]为true，表示可以拆分为一个或多个在字典中出现的单词。（4）dp[0]一定为true，不然后面根据递推公式会一直为false。从小到大逐渐找s的子串，看子串是不是数组里面的元素。你可以假设字典中没有重复的单词。
2025-04-04 16:30:48
260
原创 代码随想录|动态规划|24完全平方数
（3）dp[0]表示 和为0的完全平方数的最小数量，本来写的是1，但是题目要求n>=1，所以这里j=0只是为了递推公式好写，实际上是dp[0]=0。（1）dp[j]：填满容量为j的背包，需要的最少物品个数。（和为j的完全平方数的最小个数）物品：i从0开始，最大满足i*i<=n。（4）求个数，不考虑遍历的顺序。转换成背包问题之后就很好写了。原问题转换为完全背包问题。背包容量：n，需要填满。物品的容量：i*i。
2025-04-04 15:35:33
285
原创 代码随想录|动态规划|23零钱兑换
（2）如果包含coins[i]，凑足总额为j - coins[i]的最少个数为dp[j - coins[i]]，那么只需要加上一个钱币coins[i]即dp[j - coins[i]] + 1就是dp[j]。考虑到递推公式的特性，dp[j]必须初始化为一个最大的数，否则就会在min(dp[j - coins[i]] + 1, dp[j])比较的过程中被初始值覆盖。递推公式：dp[j] = min(dp[j - coins[i]] + 1, dp[j]);所以下标非0的元素都是应该是最大值。
2025-04-04 15:14:19
278
原创 代码随想录|动态规划|21组合总和IV
所有可能的组合为： (1, 1, 1, 1) (1, 1, 2) (1, 2, 1) (1, 3) (2, 1, 1) (2, 2) (3, 1)给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的组合的个数。递推公式为 dp[j] += dp[j-nums[i]];排列强调排序顺序，所以先遍历背包，再遍历物品。物品就是nums数组的每一个元素nums[i]这里跟上面那道题的区别在于 “排列！请注意，顺序不同的序列被视作不同的组合。物品对应的容量也是nums[i]
2025-04-03 20:38:25
194
原创 代码随想录|动态规划|19零钱兑换II
（1）dp[i][j]：使用 下标为[0, i]的coins[i]能够凑满j（包括j）这么大容量的包，有dp[i][j]种组合方法。那么就是先把1加入计算，然后再把5加入计算，得到的方法数量只有{1, 5}这种情况。背包容量的每一个值，都是经过 1 和 5 的计算，包含了{1, 5} 和 {5, 1}两种情况。第一列：背包容量为0，就是啥也装不了，就一种方法，即dp[i][0]=1.假设：coins[0] = 1，coins[1] = 5。（1）dp[j]：凑成总金额j的货币组合数为dp[j]
2025-04-03 20:27:40
1007
原创 代码随想录|动态规划|18完全背包理论基础
背包空出物品i的容量后，背包容量为j - weight[i]，dp[i][j - weight[i]] 为背包容量为j - weight[i]且不放物品i的最大价值，那么dp[i][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值。递推公式： dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]);现在：剩下的容量还可以再放物品1，dp[1][4-nums[1]]+values[1]；
2025-04-03 19:58:51
900
原创 代码随想录|动态规划|17一和零
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4。其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"}。输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3。（1）dp[i][j]：最多有i个0，j个1的strs的最大子集的大小为dp[i][j]（3）根据定义，最多有0个0，0个1，这就根本没有子集，所以dp[0][0]=0。
2025-04-03 16:35:36
467
原创 代码随想录|动态规划|16目标和
此时装满背包容量为1 有 dp[1][1] 种方法，即： 不放物品2，背包容量为1，只考虑物品 0 和 物品 1，有 dp[1][1] 种方法。第一行： 只放物品0，把容量为j的背包填满，只有nums[0]==j的情况，才可以恰好把背包填满，其余情况要么填不满，要么填不够。： 先空出物品i的容量，背包容量为（j - 物品i容量），放满背包有 dp[i - 1][j - 物品i容量] 种方法。（1）dp[i][j]：使用下标为[0, i]的nums[i]能够装满j这么大容量的包，有dp[i][j]种方法。
2025-04-02 17:01:58
1627
原创 代码随想录|动态规划|14最后一块石头的重量II
target=sum/2是向下取整的，也就是说dp[target]≤sum/2，所以sum-dp[j]≥dp[j]，所以最终的差值为。假设石头的重量分别为 x 和 y，且 x <= y。（2）01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。（1）dp[j]表示容量为j的背包，最多可以背最大重量为dp[j]。如果 x == y，那么两块石头都会被完全粉碎；
2025-04-02 15:39:53
459
原创 代码随想录|动态规划|13分割等和子集
（2）01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);（1）01背包中，dp[j] 表示： 容量（所能装的重量）为j的背包，所背的物品价值最大可以为dp[j]。所以递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])这里target=sum/2，背包最大重量为target，背包最大能装dp[target]这里的weight[i]就是nums[i]，value[i]就是nums[i]。
2025-04-02 15:24:24
389
原创 代码随想录|动态规划|12“0-1”背包问题二
二维数组的时候，递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);dp[2] = dp[2 - weight[0]] + value[0] = 15 （dp数组已经都初始化为0）dp[i][j]都是通过上一层即dp[i - 1][j]计算而来，本层的dp[i][j]并不会被覆盖。（1）在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。如果正序遍历（这里都是i=0的情况下）
2025-04-02 15:07:51
368
原创 代码随想录|动态规划|11“0-1”背包问题一
背包容量为 3，上一行同一状态，背包只能放物品0，这次也可以选择物品1了，背包可以放物品1 或者 物品0，物品1价值更大，背包里的价值为20。背包容量为 4，上一行同一状态，背包只能放物品0，这次也可以选择物品1了，背包可以放下物品0 和 物品1，背包价值为35。首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
2025-04-01 17:54:00
693
原创 代码随想录|动态规划|09不同的二叉搜索树
（2）dp[i] += dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量]给定一个整数 n，求以 1 ... n 为节点组成的二叉搜索树有多少种？（5）自己画图画到3就得了，后面的太复杂，直接给出答案。（1）1到i为节点组成的二叉搜索树的个数为dp[i]。（3）空节点也是单独的一棵树，dp[0] = 1。（4）i从1到n，j从1到i，分析过程已经说了。1为头节点：左子树0节点*右子树2节点。2为头节点：左子树1节点*右子树1节点。3为头节点：左子树2节点*右子树0节点。
2025-03-31 15:04:26
451
原创 代码随想录|动态规划|08整数拆分
给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。返回你可以获得的最大乘积。正整数拆分，应该是尽可能拆分成比较接近的数，比如9拆成3*3*3，因为距离相近的数相乘更大。（3）按照题意来看，0和1是无法进行初始化的，所以初始化dp[2] = 1。这个递推公式真的不好想，其实j的范围还可以再缩小，等二刷的时候我再加。因为dp[i - j]里面已经包括了j的拆分情况，没必要重复拆分。（1）dp[i]：分拆数字i，可以得到的最大乘积为dp[i]。这里为什么j不拆分？
2025-03-31 14:47:10
359
原创 代码随想录|动态规划|07不同路径II
（2）每个点的路径还是只可从上面或者左边得到，即dp[i][j] = dp[i - 1][j] + dp[i][j - 1]。（1）dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径.但是这里要考虑障碍物的情况，如果这个点有障碍物，那么其实是无法到达这个点，也就是0。（4） 遍历顺序还是跟以前一样的，只是在遍历的过程中加了一个障碍物的判断条件。（3）如果障碍物出现在第一行或者第一列，那么障碍物往后的点全都无法达到。网格中的障碍物和空位置分别用 1 和 0 来表示。
2025-03-31 14:26:14
342
原创 代码随想录|动态规划|06不同路径
（2）dp[i][j]只能从dp[i-1][j]和dp[i][j-1]获取，所以dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，这里的逻辑有点像前几天做的爬楼梯那个题，只能从上一个或者上上个楼梯爬过来。（4）每个网格的取值要看它的左边和它的上边，所以i遍历每一行，j遍历每一列，用两层for循环遍历就行了，不过起始位置是i=1和j=1。（1）dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。有点像小学里面的一些画图题，递归公式不难想。
2025-03-31 12:22:44
344
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人