椎名ひる-CSDN博客

原创 322、零钱兑换

思路：假设只用i种硬币，计算dp[j]的状态。然后在此基础上，不断加一种硬币更新状态即可。最后还要判断dp[amount]有没有更新，没有更新说明凑不到这个数，return -1。第一个for遍历每种硬币的情况，第二个for遍历更新dp[j]状态，需要判断是否越界。dp[j]定义为mount=j情况下的最小硬币个数，也就是题设条件。时间复杂度O(amount*len) len为coins长度。空间复杂度O(amount)

2025-06-26 15:29:09 127

原创 377、组合总和IV

按照题意是考虑顺序，比零钱简单。unsigned int是因为某个测试用例溢出了。dp[0]=1是用于方便对dp[nums[i]]进行处理。时间复杂度O(target*n) n为nums长度。空间复杂度O(target)

2025-06-26 11:05:06 165

原创 518、零钱兑换

正确的思路：一共有lencions种硬币，首先假设只有一种硬币，更新dp，然后加上第二种硬币，更新dp,dp[i]+=dp[i-coins[j-1]](下标从0开始)，遍历所有的硬币种类即可。处理一下边界问题就行。一种错误的思路：dp[i]=dp[i-coins[j]]，这样会导致重复计数。原因是此处硬币没有顺序，121,112，211，是同一种，但是以amount进行动态规划计数时重复计数了。输出应该是3+2，3+1+1,2+1+1+1,2+2+1，1+1+1+1+1五种，但是这么算会导致。

2025-06-26 10:55:25 242

原创 2081、k镜像数组的和

奇数情况下还要考虑中间的数的情况。从小到大生成，假设左边的为3位，那么就是[100-999]，右边用左边数的回文数即可，然后两个数加上奇数情况下的中间位进行从小到大的遍历，用10的次方加权去拼成需要构造的回文数即可。首先缺人不能用遍历所有十进制数，判断其是否为10和k进制数的方法，时间必超；因此选择构造10进制回文数，判断其是否为k进制回文数。rem_n为题目中的n的余量，即n-([1,n-1]所构造的满足十进制、k进制回文数的个数)；构造n位的数字，所有可能的10进制回文数，并判断其是否为k进制回文数。

2025-06-25 17:29:49 292

原创 2200、找出数组中的所有K近邻下标

思路：定位所有key下标位置，遍历以key为中心的，左右长度为k的窗口，判断是否已经添加到ans中，没有则添加。优化：部分下标会重复遍历，因此需要一个变量来存储“已经遍历过的下标”的信息，这样可以减少判断的步骤。len==1时，直接return即可，因为题设说明了nums中一定存在key。边界为[0,len-1]，使用min/max调整即可。时间复杂度O(n)，n为nums长度。

2025-06-25 13:20:41 141

原创 2140、解决智力问题

递推：dp[i]=max(dp[i+1],questions[i][0]+dp[i+questions[i][1]+1]) 如果越界了，就截断到dp[n]定义：dp[i] [i,n)的分数。最后return dp[0]即可。正向不好做，反向遍历。初始化：dp[n]=0。

2025-06-22 22:23:11 337

原创 931、下降路径最小和

遍历：最左边、最右边的可行路径为两种，中间n-2个数的可行路径为三种。一共三种情况，分开讨论即可。优化空间，dp[0][j]存储上一行，dp[1][j]存储当前行，本行计算完成后dp[0][j]=dp[1][j]最后遍历最后一行，寻找最小值即可。ans=100*n是一个最大值，只要足够大即可。按照行遍历，dp即可。定义dp[i][j]为(i,j)位置的最小路径。初始化：第一行直接塞入dp[0][j]。时间复杂度O(n*n)

2025-06-22 18:32:11 236

原创 120、三角形最小路径和

其余的，0<j<i,dp[j]为上一层的dp[j]与dp[j-1]的最小值，加上本层的(i,j)值。这种明显是动态规划，每一层用到上一层的信息。对j=i，dp[j]为(i-1,i-1)的dp[i-1]与本层的(i,i)相加。对j=0，dp[0]为(i-1,0)的dp[0]与本层的(i,0)相加。综上三条，每一层的循环应该是从右向左，从大下标到小下标。设dp[n],定义为本层第n个数据的最小路径。遍历n层，最后找到最后一层的最小值输出即可。特殊的两处：(i,j):j=0和j=i。时间复杂度O(n*n)

2025-06-22 18:05:55 171

原创 63、不同路径II

递推：对当前(i,j) 非障碍物时：dp[i][j]=dp[i-1][j]+dp[i][j-1] 有障碍物：dp[i][j]=0 也可以用逻辑去实现。第一行初始化：dp[1][0]->dp[i][0] 碰到有障碍物的，从当前格子开始到末尾全部置0，可以用flag实现，也可以用逻辑与和非实现。obstacleGrid(0,0)=1的，直接return 0即可。入口都被堵住了还怎么走。空间复杂度O(mn),也可以优化。初始化和特殊情况比较麻烦的dp。m=n=1情况，直接判断。时间复杂度O(mn)

2025-06-22 15:47:08 154

原创 64、最小路径和

按照一列一列来遍历，修改初始化条件，先初始化第一列，然后从第二列开始，dp[0][1]单独计算，dp[j][1]按照上述递归式子的算法计算。一列遍历完成后，用dp[m][0]=dp[m][1]来存储状态，继续扫描下一列。递归：dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i][j],也就是从上面到达或者从左边到达。初始化：dp[0][0]=grid[0][0]，同时对第一行和第一列的，第i个就是前i个之和加上自身。定义：dp[i][j]为到达(i,j)所需要的最短路程。

2025-06-22 14:59:31 138

原创 62、不同路径

初始化：dp[i][j]表示从(0,0)到(i,j)有多少种走法。左边一列、上面一行只有一种走法，设置为1。递推：dp[i][j]=dp[i-1][j]+dp[i][j-1] 从左边一格走或者从上边一格走。空间复杂度O(m*n)，也可用滚动数组，降低空间复杂度到O(min(m,n))时间复杂度O(m*n)

2025-06-22 11:10:18 179

原创 70、爬楼梯

简单dp，边界条件n=1为1，n=2为2，递推即可。

2025-06-22 10:57:14 210

原创 509、斐波那契数

摘要：该代码实现了斐波那契数列的计算，采用动态规划优化空间。当n=0时返回0，n=1时返回1。对于n≥2的情况，通过迭代计算当前值（前两数之和），并更新前两数的值，最终在O(n)时间、O(1)空间内完成计算。代码简洁高效，考虑了边界条件。

2025-06-22 10:50:02 146

原创 2138、将字符串拆分为若干长度为k的组

s.substr(pos,len) pos表示字符串s起始下标，len表示需要获取的长度。很简单的题，先填充字符串长度至k的倍数，然后substr即可。时间复杂度O(max(n，k)),n为s长度。空间复杂度O(1),输出不计入复杂度。

2025-06-22 10:29:36 121

原创 3085、成为K特殊字符串需要删除的最小字符数

问题转化为：对一个有限长度有序数列，对其中单个元素作n次减一，使得该数列中任意两个元素之差小于k，求n的最小值。[0,k]左闭右闭，遍历到[cnt[25]-k,cnt[25]]，cnt[25]为出现频次最高的数对应的频次。另一种特殊情况：k>cnt[25]，也就是不需要做任何删减就已经满足了，这时候直接return 0即可。对窗口左边的频次，由于再怎么减少字符频次都不能使其在窗口内，就直接全部删去。特殊情况：字符出现0次的，减去0次，事实上不影响。统计所有的频次数，然后划窗，取所有窗口情况下的最小值即可。

2025-06-21 14:44:24 161

原创 279、完全平方数

继续化简：dp[i]=min(dp[i],dp[i-n*n])，n遍历结束后dp[i]++ 这里的意思是n的遍历不再是从1到根号i，而是以完全平方数的形式遍历。拆到最后是dp[1]=min(dp[1],dp[1-1*1])这种形式，这里1也可以是4,9,16等完全平方式，又dp[0]=0，最后一步一定是0，dp[i]++就是把这一步加上。dp[i]=min(dp[i],dp[i-n]+dp[n]) 相当于将n分别为1+(n-1),2+(n-2)，等等，扫描一遍。dp[0]=0为边界条件。

2025-06-20 19:50:10 292

原创 3443、K次修改后的最大曼哈顿距离

2、对当前第i步，最多只能修改i次，曼哈顿距离不可能超过i。举个例子，k=5，s=NNNS'NNSS，到 ' 位置的时候只修改了一个S。比如原来是在(2,2),将前面走过的x--修改为x++就能在这个时刻处于(4,2)可以得到递推式ans=max(ans,min(abs(x)+abs(y)+2*k,i+1)) 式子按照下面的代码中来了，i从0开始。曼哈顿距离：(x1,y1),(x2,y2) d=|x1-x2|+|y1-y2|也就是说，到第i步，修改次数为min(i步可能最大情况下前面需要修改的步数，k)

2025-06-20 11:17:17 264

原创 2294、划分数组使最大差为K

分组规则：对排序后的有序数组，从第一个数开始往后遍历，遇到大于(本组第一个数+k)的数就新开一个组。思路：排序-->分组，每分一个组就ans++。ans初始为1，也就是至少一个组。时间复杂度O(nlogn)，受排序限制。不考虑排序的情况下空间复杂度O(1)昨天的题换一种问法。题目比较绕，但是很简单。

2025-06-19 15:49:21 138

原创 2966、划分数组并满足最大差限制

sort(begin,end,cmp) begin和end为需要排序的数组的头尾指针，[begin,end),左闭右开，cmp为比较方法，可以不填，sort()时间复杂度为O(nlog2(n))，其根据不同的数量级别以及不同情况，能自动选用合适的排序方法。emplace_back()实现功能和push_back()相同，在vector后面添加元素。而 emplace_back() 在实现时，则是。时间复杂度O(nlog2(n))，由sort()决定，空间复杂度O(n)，省去了拷贝或移动元素的过程。

2025-06-18 09:50:01 113

原创 121、买卖股票的最佳时机

简单的动态规划问题，minvalue存储前i个数中最小的数，遍历更新ans和minvalue。时间复杂度O(n),空间复杂度O(1)

2025-06-16 21:19:54 103

原创 1277、统计全为1的正方形子矩阵

同221，动态规划，递推公式也基本相同，不同的是ans的计算方式，以及matrix存储的是int了。时间复杂度O(mn),空间复杂度O(mn)

2025-06-16 20:58:51 184

原创 221、最大正方形

对(i,j)格子，dp[i-1][j]决定了它能向上走几格，dp[i][j-1]决定了它能向左走几格子，dp[i-1][j-1]决定了它能沿着向左上走几格。递推关系：dp[i][j]=min(dp[i-1][j-1],min(dp[i][j-1],dp[i-1][j]))定义：dp[i][j],下标为i,j的元素对应的，以其为正方形最右下一个角的，正方形边长最大值。时间复杂度O(mn),空间复杂度O(mn),mn为matrix元素个数，m为行，n为列。虽然非常不可置信，这题确实可以用动态规划。

2025-06-16 20:53:53 262

原创 2466、统计构造好字符串的方案数

题意比较绕，但是实际上也是个爬楼梯，步数为zero或者one，统计[low，high]的所有情况数。需要注意的是答案可能会非常大，中间每一步都做好求余工作。写的比较复杂，zero==one和不等的情况进行了分类，不等的情况下对maxstep前的初始化稍微麻烦一些。后续就是简单的动态规划，根据公式迭代即可。对i位置，可以由i-one或者i-first得到，方案数等于两者之和。时间复杂度O(high),空间复杂度O(high)

2025-06-16 18:48:52 125

原创 1137、第N个泰波那契数

n<=2时直接单列讨论，n>=3时初始化0/1/2三个数，后续直接递推即可。同动态规划的方法，用变量暂存数据进行空间优化。也可以用官方题解矩阵快速幂，有点类似于状态方程的思想了。可以优化时间复杂度至O(logn)一个数列，很简单，递推公式也给出了，做法类似于动态规划。时间复杂度O(n),空间复杂度O(1)

2025-06-16 15:56:30 174

原创 746、使用最小花费爬楼梯

遍历：从i=2开始，到len-1，对当前步，判断其是跨一级台阶上来还是跨两级台阶上来dp[i]=max(dp[i-1]+nums[i-1],dp[i-2]+nums[i-2])最后到楼梯顶是i=len，可以让循环多走一次直接return dp[len]n为num长度时间复杂度O(n),空间复杂度O(n),可以优化到O(1)初始化：dp[0]=0,dp[1]=0。可以在空间上进行优化。

2025-06-16 12:31:54 87

原创 2016、增量元素之间的最大差值

min_num存储当前数之前的最小数，每次遍历更新min_num和ans，ans为max(ans,(当前值-当前最小值))需要注意如果数列是降序排列的，类似9876543，那么需要return -1。时间复杂度O(n),空间复杂度O(1)

2025-06-16 10:12:16 148

原创 213、打家劫舍II

直接分情况讨论，设房子数量len，第一个房子偷，最后一个不偷，从第二个房子开始按照打家劫舍I类似的做法，但是将最后一个房子排除在外，范围为[0,len-2]。按照dp[i]=max(dp[i-1],dp[i-2]+num[i])的递推公式来做。第二种情况是最后一个偷，第一个不偷，同理。和打家劫舍I的区别在于，房子围成一个圈，第一个与最后一个相连。时间复杂度O(num),空间复杂度O(num),也可以优化空间复杂度至O(1)

2025-06-15 19:07:05 131

原创 1432、改变一个整数能得到的最大差值

首先判断最高位是否为1，如果不是1，那么直接将最高位和最高位相同的数字全部改为1即可。如果最高位为1，那么从最高位下一位开始，找到不是0或者1的数（0换0不变，但是更低位换0可以让数更小；1换0会导致最高位也被换，出现前导0），记录这个数并将所有的这个数全部换成0。如果说是10000.100100这种全0、1的数，那么就不换，等于是用0换0，因为不能更小了。最大数好找，直接找第一个不为9的数字，替换所有与该数字相同的即可。注意转换成字符串后比较要用'0','1',不能用0/1。

2025-06-15 12:44:55 288

原创 2566、替换一个数字后的最大差值

也就是说，替换的是高位的第一个非9数字以及与它相同的数字。要计算数组长度，不断求余然后返回去操作替换。简单的做法是直接转换为str字符串，查找第一个不为‘9’的字符，然后从那个字符开始全部替换该字符为9，再转换为int类型。但是最大数不能这么做，因为首位可能本身为9，也可能高位有连续的9.range::replace是std::replace的范围版本，遍历范围，在原来的地方将旧值替换为新值。比如99123，替换后最大应该为99923，将百位的1替换为9。stoi(要替换的字符串，转换结束的位置，进制)

2025-06-15 11:04:33 385

原创 198、打家劫舍

数组长度为0和1的时候单独判断。大于等于2时开始动态规划。对下标为i，设f(i)为当前最优。根据题意可以得到f(i)=max(f(i-1),f(i-2)+nums[i])，跳过i-1或者跳过i选择i和i-2.空间优化：由于f(i)只使用了f(i-1),f(i-2),事实上并没有用到f(i-3)以及之前的东西。可以直接通过两个变量存储f(i-1),f(i-2)来优化空间。时间复杂度O(n),空间复杂度O(n)，n为数组长度。空间复杂度降低为O(1)

2025-06-13 15:24:50 248

原创 34、在排序数组中查找元素的第一个和最后一个位置

对题设条件nums全为整数，target右下标只需要查找target+1的左下标，然后-1。即使target+1不存在，也会返回比target+1大的最小数的下标，也是比target大的最小数的下标。left为target前一位，right为target（如果存在）或者比target大的最小值。不过我个人更喜欢左开右开形式，（left,right）,判定条件为left-1=right。时间复杂度O(log n) 表明必须要二分查找（非递减顺序排列也暗示），遍历一定是N。

2025-06-13 13:52:53 137

原创 624、数组列表中的最大距离

思路为：存储最大最小、次大次小、当前值，分别比较，不同情况分配判断。会有很多的if、与非逻辑判断，这样程序会很长，很麻烦。起初的思路是遍历获得第一个元素最大值、最后一个元素最小值，直接相减。tempmax-min、max-tempmin保证了其为错位求ans，max、min始终保存本组之前的所有组的最大值和最小值。每个数组升序排列，并且有用数据只有每个数组的最大值和最小值，因此只需要取每个数组的第一个元素和最后一个元素。为保证max、min不在同一组，只需要将ans的更新放在max、min更新前面。

2025-06-12 19:51:49 226

空空如也

空空如也