hlc@-CSDN博客

原创【区间DP】力扣3040. 相同分数的最大操作数目 II

我们观察题目可以发现，题目中最多有三种分数，他们取决于第一次操作采用哪一种方式。也就是说如果我们采用回溯的方式，那么我们可以根据第一次操作的方式来分别进行回溯，因为这样子就知道后面回溯的分数要等于多少。我们定义dfs(i,j)表示下标i到j的nums的相同分数的最大操作数目是多少，也就是说当我们知道我们要使分数为target，那么假设有一种方式。我们回溯的界限是当i >= j当时候，返回0，因为已经无法进行任何操作。输入：nums = [3,2,1,2,3,4]输入：nums = [3,2,6,1,4]

2025-01-15 22:58:14 423

原创【区间DP】【hard】力扣1771. 由子序列构造的最长回文串的长度

我们要求子序列构造的最长回文串长度，实际上就是将word1和word2合成一个字符串，然后求最长回文串长度，由于题目要求word1和word2都要有字符构成回文串。当s[i] = s[j]的时候，dp[i][j]一定包含s[i]和s[j]，那么我们就可以判断i如果在word1范围内，j在word2范围内，就说明该dp[i][j]记录的最长回文串长度一定有word1和word2贡献的字符。解释：从 word1 中选出 “ab” ，从 word2 中选出 “cba” ，得到回文串 “abcba”。

2025-01-15 22:19:05 374

原创【区间DP】【hard】力扣1312. 让字符串成为回文串的最少插入次数

我们转变思路，要找到最少插入次数，实际上就是要找最长的回文子序列的长度是多少，然后剩下的字符我们就需要插入字符配对构成回文串。给你一个字符串 s ，每一次操作你都可以在字符串的任意位置插入任意字符。解释：字符串 “zzazz” 已经是回文串了，所以不需要做任何插入操作。解释：插入 5 个字符后字符串变为 “leetcodocteel”。解释：字符串可变为 “mbdadbm” 或者 “mdbabdm”。输入：s = “leetcode”输入：s = “zzazz”输入：s = “mbadm”

2025-01-14 23:39:11 362

原创【区间DP】【hard】力扣730. 统计不同回文子序列

我们定义一个三维数组dp[k][i][j]来表示在i到j范围内并且以k开头的回文子序列的总数。当s[I] = s[j]的时候，那么i+1到j-1中的回文子序列加上两边的x都是以x为开头的回文子序列，并且字符c可以构成c或者cc两个回文子序列，所以有状态转移方程。因此，当前子串 s[i…j] 中以 c 为边界的回文子序列，与子串 s[i…解释：6 个不同的非空回文子字符序列分别为：‘b’, ‘c’, ‘bb’, ‘cc’, ‘bcb’, ‘bccb’。s[i] 仅包含 ‘a’, ‘b’, ‘c’ 或 ‘d’

2025-01-14 19:32:28 1207

原创【区间DP】力扣516. 最长回文子序列

定义dp[i][j]为从i到j到最大回文子序列长度，然后遍历i和j的索引，如果s[i] = s[j]，那么就可以由dp[i+1][j-1]+2状态转移而来，否则可以由max(dp[i+1][j], dp[i][j-1])进行状态转移而来。子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。解释：一个可能的最长回文子序列为 “bbbb”。解释：一个可能的最长回文子序列为 “bb”。

2025-01-14 01:52:58 300

原创【数据结构-堆】力扣1792. 最大平均通过率

这是我一开始的方法，我们不断寻找最合适的班级来插入聪明的学生，然后我每一轮插入前就先比较classes的增长如何，然后找到会有最大的增长的班级插入聪明的学生。但是这就出现了一个问题，我们计算插入聪明学生的增长，只需要对修改过的classes计算就行，而在该方法中我对每一个classes都进行了运算，其中这部分有大多数计算会是多余的。平均通过率是所有班级的通过率之和除以班级数目。输入：classes = [[2,4],[3,9],[4,5],[2,10]], extraStudents = 4。

2025-01-13 15:20:24 699

原创【数据结构-堆】力扣1834. 单线程 CPU

其中 tasks[i] = [enqueueTimei, processingTimei] 意味着第 i 项任务将会于 enqueueTimei 时进入任务队列，需要 processingTimei 的时长完成执行。当cpu处理任务的时候，可以认为中间不进行任何操作，当处理完后，时间轴来到了t，那么就要将时间小于t的所有任务加入到q中，然后我们q的队头就是执行时间最短的任务，将它丢到cpu中执行。输入：tasks = [[7,10],[7,12],[7,5],[7,4],[7,2]]

2025-01-13 00:09:50 1009

原创【数据结构-堆】力扣2462. 雇佣 K 位工人的总代价

当我们从小根堆中找到最小代价的时候，我们可以通过索引去找到他是在左边的区间还是右边的区间，然后找到对应的区间后，我们就移动其区间的指针，使最前面区间和最后面区间的范围都是candidates。比方说，costs = [3,2,7,7,1,2] 且 candidates = 2 ，第一轮雇佣中，我们选择第 4 位工人，因为他的代价最小 [3,2,7,7,1,2]。第二轮雇佣，我们选择第 1 位工人，因为他们的代价与第 4 位工人一样都是最小代价，而且下标更小，[3,2,7,7,2]。

2025-01-12 23:25:26 689

原创【数据结构-堆】力扣1801. 积压订单中的订单总数

反之亦然，如果该订单是一笔销售订单 sell ，则可以查看积压订单中价格最高的采购订单 buy。如果该采购订单 buy 的价格高于或等于当前销售订单 sell 的价格，则匹配并执行这两笔订单，并将采购订单 buy 从积压订单中删除。如果该销售订单 sell 的价格低于或等于当前采购订单 buy 的价格，则匹配并执行这两笔订单，并将销售订单 sell 从积压订单中删除。输入：orders = [[7,1000000000,1],[15,3,0],[5,999999995,0],[5,1,1]]

2025-01-10 23:43:21 981

原创【数据结构-堆】【哈希+最小堆】力扣1942. 最小未被占据椅子的编号

我们遍历arrival，也就是到达时间，然后我们在处理到达之前，需要先对离开的人进行处理，我们定义一个指针j，所有离开时间小于到达时间的座位都应该被释放，所以我们要将占据的座位加入到q中供arrival选择。给你一个下标从 0 开始的二维整数数组 times ，其中 times[i] = [arrivali, leavingi] 表示第 i 个朋友到达和离开的时刻，同时给你一个整数 targetFriend。比方说，当一个朋友到达时，如果椅子 0 ，1 和 5 被占据了，那么他会占据 2 号椅子。

2025-01-10 00:34:02 1072

原创【数据结构-堆】【二分】力扣3296. 移山所需的最少秒数

这个示例中只有一个工人，所以答案是 workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15 秒。工人 2 将高度降低 3，花费 workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 秒。工人 2 将高度降低 1，花费 workerTimes[2] = 1 秒。

2025-01-08 23:24:40 938

原创【数据结构-堆】2233. K 次增加后的最大乘积

这道题我们要找进行k次操作后的最大乘积是多少，那么我们结合贪心的思路，我们可以知道在和一样的情况下，所有的元素越平均，最后乘积会越大。请你返回至多 k 次操作后，能得到的 nums的最大乘积。那么也就是说我们每次进行+1操作，要对最小的元素操作，我们就可以使用小根堆来找出每一轮最小的元素，然后进行操作。得到 nums = [6, 4, 3, 3] ，乘积为 6 * 4 * 3 * 3 = 216。得到 nums = [5, 4] ，乘积为 5 * 4 = 20。解释：将第一个数增加 5 次。

2025-01-08 21:12:37 442

原创【数据结构-堆】力扣2208. 将数组和减半的最少操作次数

targetSum是原始数组的一半的值，而k是减少的值，当k小于targetSum的时候就不断进行减半操作，然后用ans来记录次数，最后返回ans即可。nums 的和减小了 33 - 14.75 = 18.25 ，减小的部分超过了初始数组和的一半，18.25 >= 33/2 = 16.5。nums 的和减小了 31 - 14.5 = 16.5 ，减小的部分超过了初始数组和的一半， 16.5 >= 31/2 = 15.5。解释：初始 nums 的和为 5 + 19 + 8 + 1 = 33。

2025-01-07 23:07:16 252

原创【数据结构-堆】力扣1845. 座位预约管理系统

/ 可以预约的座位为 [2,3,4,5] ，返回最小编号的座位，也就是 2。// 可以预约的座位为 [2,3,4,5] ，返回最小编号的座位，也就是 2。// 可以预约的座位为 [3,4,5] ，返回最小编号的座位，也就是 3。// 将座位 2 变为可以预约，现在可预约的座位为 [2,3,4,5]。// 可以预约的座位为 [4,5] ，返回最小编号的座位，也就是 4。int reserve() 返回可以预约座位的最小编号，此座位变为不可预约。

2025-01-07 22:41:46 400

原创【数据结构-堆】力扣3275. 第 K 近障碍物查询

我们先定义一个数组g来储存queries的距离，然后我们遍历i，建造障碍物实际上就是将g[i]推入到q中，这时候q会对内部元素进行升序排序，然后如果q大小大于k，那么队头元素被推出。输入：queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2。queries[3] 之后，障碍物距离原点的距离分别为 3，3，5 和 7。输入：queries = [[5,5],[4,4],[3,3]], k = 1。queries[2] 之后，障碍物距离原点的距离分别为 3 ，5 和 7。

2025-01-07 00:54:49 296

原创【数据结构-堆】力扣703. 数据流中的第 K 大元素

这道题目需要我们返回第k大元素，那么我们是不是可以构建一个最小堆，让最小堆的大小最大为k，那么最小堆的队头就是第k大的元素（从尾往头数第k个）。那么我们每次调用add，就push一个数到q中，最小堆q会进行排序，如果q大小超过k，那么就弹出队头元素使得q的大小为k，然后再返回。KthLargest(int k, int[] nums) 使用整数 k 和整数流 nums 初始化对象。输出：[null, 4, 5, 5, 8, 8]输出：[null, 7, 7, 7, 8]

2025-01-06 13:40:21 490

原创【数据结构-堆】力扣1962. 移除石子使总数最小

我们要让最后石子总数最小，那么就要在每一次操作中选择最大石子进行粉碎，所以我们可以使用优先队列来使得piles[i]由大到小排序，每次粉碎队头的石子，然后执行k次，最后统计剩余石子的数量即可。给你一个整数数组 piles ，数组下标从 0 开始，其中 piles[i] 表示第 i 堆石子中的石子数量。选出任一石子堆 piles[i] ，并从中移除 floor(piles[i] / 2) 颗石子。输入：piles = [4,3,6,7], k = 3。返回执行 k 次操作后，剩下石子的最小总数。

2025-01-04 15:55:20 396

原创【数据结构-堆】力扣3066. 超过阈值的最少操作数 II

解释：第一次操作中，我们删除元素 1 和 2 ，然后添加 1 * 2 + 2 到 nums 中，nums 变为 [4, 11, 10, 3]。第二次操作中，我们删除元素 3 和 4 ，然后添加 3 * 2 + 4 到 nums 中，nums 变为 [10, 11, 10]。解释：第一次操作后，nums 变为 [2, 4, 9, 3]。输入：nums = [2,11,10,1,3], k = 10。输入：nums = [1,1,2,4,9], k = 20。第四次操作后，nums 变为 [33]。

2025-01-04 15:31:55 1022

原创【数据结构-堆】力扣2530. 执行 K 次操作后的最大分数

最后分数是 10 + 10 + 10 + 10 + 10 = 50。第 1 步操作：选中 i = 1 ，nums 变为 [1,4,3,3,3]。第 2 步操作：选中 i = 1 ，nums 变为 [1,2,3,3,3]。第 3 步操作：选中 i = 2 ，nums 变为 [1,2,1,3,3]。将 nums[i] 替换为 ceil(nums[i] / 3)。输入：nums = [10,10,10,10,10], k = 5。输入：nums = [1,10,3,3,3], k = 3。

2025-01-04 15:14:50 444

原创【数据结构-堆】力扣2336. 无限集中的最小数字

由于题目还有addBack的插入操作，我们可以定义一个set s，用于存储那些被弹出后再添加回集合的数字，只有当num比k小的时候addBack才会进行操作，否则不操作。所以s中储存的就是比k小的数，当我们s中有元素的时候，我们使用popSmallest操作会返回并且弹出s的头元素，因为set是升序排列。：初始化需要的时间为 O(1)，单次任意操作的时间复杂度为 O(logn)，其中 n 是当前有序集合 s 中的元素个数，它不会超过已经操作的次数。// 且 1 是最小的整数，并将其从集合中移除。

2025-01-04 14:52:51 346

原创【数据结构-堆】力扣2558. 从数量最多的堆取走礼物

这道题的解法类似力扣3264，该题是最大堆，3264是最小堆，可以主页看3264题解。给你一个整数数组 gifts ，表示各堆礼物的数量。输入：gifts = [25,64,9,4,100], k = 4。将堆中的礼物数量减少到堆中原来礼物数量的平方根，向下取整。输入：gifts = [1,1,1,1], k = 4。在本例中，不管选中哪一堆礼物，都必须剩下 1 个礼物。如果不止一堆都符合礼物数量最多，从中选择任一堆即可。也就是说，你无法获取任一堆中的礼物。所以，剩下礼物的总数量是 4。

2025-01-03 01:09:51 205

原创【数据结构-堆】力扣3264. K 次乘运算后的最终数组 I

q的队头总是最小值，所以我们每次更新，只要找到q的队头，让他乘以multiplier，并且记录到nums[idx]中，由于q实际上储存的是nums中的数，作用只是用来排序，所以我们要弹出原本的nums，然后再推入新的{nums[idx],idx}。输入：nums = [2,1,3,5,6], k = 5, multiplier = 2。2 次操作后 [4, 2, 3, 5, 6]3 次操作后 [4, 4, 3, 5, 6]4 次操作后 [4, 4, 6, 5, 6]输出：[8,4,6,5,6]

2025-01-02 23:25:38 249

原创【数据结构-堆（优先队列）】力扣1046. 最后一块石头的重量

我们取出前两块石头，如果a大于b，则将粉碎后的a-b大小石头放到队头，如果a=b，则a和b一起粉碎不见。= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后选出 1 和 1，得到 0，最终数组转换为 [1]，这就是最后剩下那块石头的重量。先选出 7 和 8，得到 1，所以数组转换为 [2,4,1,1,1]，再选出 2 和 4，得到 2，所以数组转换为 [2,1,1,1]，接着是 2 和 1，得到 1，所以数组转换为 [1,1,1]，输入：[2,7,4,1,8,1]

2025-01-02 00:59:44 158

原创【单调队列优化 DP】力扣2944. 购买水果需要的最少金币数

这是因为i是向左遍历的，如果f[i]小于队头元素，并且队头元素会比f[i]先被弹出，也就是说f[i]会始终小于q的队头元素，那么此时比f[i]大的队头元素便没有存在的必要。当你购买了水果i，由于我们要购买所有的水果，那么我们下一个可以购买的水果就是[i+1, 2i+1]，这时候定义一个变量k来储存这个范围内f[j]的最小值，那么f[i]也就可以从k加上当前prices[i-1]转移而来。用 prices[2] = 6 个金币购买第 3 个水果，你可以免费获得第 4，5，6（接下来的三个）水果。

2025-01-01 23:30:24 870

原创【数据结构-单调队列】力扣2762. 不间断子数组

例子：[1, 2]包含[1]，[2]，[1, 2]共1+2=3个有效子数组，新增一个元素得到[1, 2, 1]后，包含[1], [2], [1], [1, 2], [2, 1], [1, 2, 1]共1+2+1=6个有效子数组。推导：长为1的窗口共包含1个不同的子数组，长为2的窗口共包含1+2=3个不同的子数组，长为n的窗口共包含1+2+…首先：对于某个以nums[i]为左端点，nums[j]为右端点的合法不间断子序列(以下称为合法窗口)nums[i:j+1]，窗口内的所有子数组都是合法的。

2025-01-01 01:52:44 626

原创【数据结构-单调队列】力扣1438. 绝对差不超过限制的最长连续子数组

如果发现差大于limit，那么我们此时要做的就是移动left，我们移动left的目的是看nums[left]是否是queMax中的队首或者queMin中的队首，也就是滑块中的最大值或最小值，如果nums[left]的值等于滑块的最大值，那么就弹出queMax的队首，并且继续将left向右移动，继续判断接下来的新的滑块范围的最大值减最小值是否大于limit。输入：nums = [4,2,2,2,4,4,2,2], limit = 0。输入：nums = [10,1,2,4,7,2], limit = 5。

2024-12-31 16:14:25 609

原创【数据结构-单调队列】力扣LCR 184. 设计自助结算系统

这道题难度不大，我们只需要定义一个普通的队列来找到第一个未结算的商品，然后定义一个单调递减的双端序列用队头元素来表示获取结算商品中的最高价格即可。1 <= get_max, add, remove 的总操作数 <= 10000。get_max()：获取结算商品中的最高价格，如果队列为空，则返回 -1。remove()：移除第一个待结算的商品价格，如果队列为空，则返回 -1。输出: [null,null,null,7,4,7]输出: [null,-1,-1]

2024-12-30 23:55:54 402

原创【数据结构-单调队列】【hard】力扣239. 滑动窗口最大值

首先我们先初始化第一个滑块，我们拿滑块的每一个元素和双端队列的末尾比大小，如果比双端队列队尾的元素大，由于拿来和末尾比较的元素的索引肯定在队尾元素的右边，并且大于队尾元素，所以队尾元素已经没用，因为他不可能是最大元素，所以队尾元素弹出。接下来我们开始进行滑动窗口，开始遍历窗口最右边的元素，我们要将他加入到优先队列中，这时候我们要检查优先队列的第一个元素，也就是最大值对应的索引是不是在滑动窗口中，如果不是的话就弹出，直到优先队列最大元素的索引在当前滑动窗口中，然后将优先队列的队首元素推入到答案ans中。

2024-12-30 23:01:45 1185

原创【多维DP】【hard】力扣1223. 掷骰子模拟

因此，最终答案是 36-2 = 34。时间复杂度：O(n m^2 k)，其中 n 是掷骰子的次数，m 是随机数的种类数，在本题中等于 6，k 是 rollMax 数组中的最大值。这道题我们定义一个三维数组dp[i][j][k]表示已经完成了i次投掷，并且第i次投掷的结果是是数字j，然后j已经连续摇到了k次。输入：n = 2, rollMax = [1,1,2,2,2,3]输入：n = 2, rollMax = [1,1,1,1,1,1]输入：n = 3, rollMax = [1,1,1,2,2,3]

2024-12-29 13:20:35 346

原创【多维DP】力扣3366. 最小数组和

这道题我们定义一个三维数组dp[i][j][m]，i代表在前i个数中的,最多能进行j次操作1，m次操作2的最小数组和。接下来我们还要考虑既进行操作1又进行操作2的情况，由于nums[i]一定是非负数，所以我们如果能先除后减最好，我们可以将两个操作的计算都进行放置在。输入： nums = [2,8,3,19,3], k = 3, op1 = 1, op2 = 1。对 nums[1] = 4 应用操作 1，使 nums[1] = 2。对 nums[2] = 3 应用操作 2，使 nums[2] = 0。

2024-12-28 22:25:08 434

原创【多维DP】【hard】力扣403. 青蛙过河

解释：青蛙可以成功过河，按照如下方案跳跃：跳 1 个单位到第 2 块石子, 然后跳 2 个单位到第 3 块石子, 接着跳 2 个单位到第 4 块石子, 然后跳 3 个单位到第 6 块石子, 跳 4 个单位到第 7 块石子, 最后，跳 5 个单位到第 8 个石子（即最后一块石子）。也就是说从第i-1块石头开始可以跳i步，如果第i-1块石头和第i块石头之间的距离大于i步，那么就直接return false。当i为n-1并且dp[i][k]为true的时候，说明可以到最后一块石头，则返回true。

2024-12-25 23:29:29 355

原创【多维DP】力扣576. 出界的路径数

这道题可以定义一个三维数组dp[i][j][k]用来表示走了i步后落在位置(j,k)的路径总数。，count是dp[i][j][k]，j1和k1是第i+1步后落的位置。输入：m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0。输入：m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1。注：由于i+1只由i转移而来，可以压缩dp[i][j][k]为dp[j][k]，进行空间优化。

2024-12-25 16:51:07 529

原创【多维DP】力扣3122. 使矩阵满足条件的最少操作次数

首先我们要初始化第一列的值，我们假设第一列的值可能是0~9之间任何一个值k，然后grid第一列中不等于k则要修改成k，所以有多少个不等于k的值就要操作多少次，记录到cost中，最后dp[0][k] = cost。如果下面相邻格子存在的话，它们的值相等，也就是 grid[i][j] == grid[i + 1][j]（如果存在）。输入：grid = [[1,0,2],[1,0,2]]输入：grid = [[1,1,1],[0,0,0]]输入：grid = [[1],[2],[3]]

2024-12-22 16:41:31 648

原创【贪心】力扣3218. 切蛋糕的最小总开销 I

这道题使用贪心算法是最高效的做法，我们观察题目，假设我们每一次沿着水平线都切到底，那么沿着该水平线切的次数就是垂直方向有多少块蛋糕，那么开销就要乘以垂直方向蛋糕的数量。那么也就是说我们应该优先沿着开销大的水平线切，否则放到后面切的话，可能该水平线切到底的开销就要乘以更多的倍数。horizontalCut 的大小为 m - 1 ，其中 horizontalCut[i] 表示沿着水平线 i 切蛋糕的开销。沿着水平线 1 切开 2 x 1 的蛋糕块，开销为 3。

2024-12-21 17:33:00 555

原创【多维 DP】力扣3250. 单调数组对的数目 I

arr1 是单调非递减的，换句话说 arr1[0] <= arr1[1] <= …<= arr1[n - 1]。arr2 是单调非递增的，换句话说 arr2[0] >= arr2[1] >= …>= arr2[n - 1]。对于所有的 0 <= i <= n - 1 都有 arr1[i] + arr2[i] == nums[i]。给你一个长度为 n 的正整数数组 nums。输入：nums = [5,5,5,5]请你返回所有单调数组对的数目。输入：nums = [2,3,2]

2024-12-21 16:14:54 385

原创【多维DP】【准NOI难度】力扣3251. 单调数组对的数目 II

首先由于arr1是非递减的，那么也就是说arr1[i] >= arr1[i-1]，然后arr2是非递增的，也就是说arr2[i] <= arr2[i-1]。我们假设arr1[i]为j，arr1[i-1]为k，arr2[i] = nums[i] - j而arr2[i-1] = nums[i-1] - k。那么我们知道了最大值k，我们就可以知道当前f[i][j]可以由f[i-1][0],f[i-1][1]…+f[i-1][k]的值，我们可以计算上一个状态的前缀和，当我们知道最大的k的时候就可以直接使用。

2024-12-21 16:12:29 776

原创【记忆化搜索】最小费用最大匹配问题

设有n件工作分配给n个人，将工作i分配给第j个人所需的费用cij。试设计一个算法，为每个人都分配1件不同的工作，并使总费用最小。（c++记忆化搜索）

2024-12-18 16:47:25 243

原创【记忆化搜索】运动员匹配问题

羽毛球队有男女运动员各n人。给定2个nxn矩阵P和Q。P[i][j]是男运动员i和女运动员j配对组成混合双打的男运动员竞赛优势；Q[i][j]是女运动员i和男运动员j配合的女运动员竞赛优势。P[i][j]不一定等于Q[j][i]。男运动员i和女运动员j组成的男女双方竞赛优势为多少？

2024-12-18 00:43:46 253

原创【多维DP】【hard】力扣1269. 停在原地的方案数

由于状态j一直是由上一个状态j-1进行状态转移而来，那么可以定义一个新的一维数组来储存上一轮的j-1状态下的dp[i]是多少，于是我们可以使用滚动数组的方式将二维压缩成一维，最后返回dp[0]即可。最开始想到的办法是定义一个二维数组dp[i][j]，来表示在i的位置的时候，并且以及已经进行了j步，最后所能到达下标0的位置的方案数。最后我们能列出状态转移方程。给你两个整数 steps 和 arrLen ，请你计算并返回：在恰好执行 steps 次操作以后，指针仍然指向索引 0 处的方案数。

2024-12-17 11:45:16 393

原创【多维DP】力扣2370. 最长理想子序列

由于观察状态转移方程i都是由上一个状态i-1状态转移而来，那么我们可以采用滚动的方式进行空间压缩，我们定义dp[c]为以字符c为结尾的最长理想子序列的长度，并且而外定义一个变量maxLen来记录被转移状态的最长理想子序列的长度，所以当前的最长理想子序列长度就是。对于子序列题目，我们通常可以定义一个二维数组dp[i][c]用来表示在s的前i个字符（i从0开始）并且以c字符作为结尾的最长理想子序列。最后假设我们不以s[i]作为结尾，那么当前的状态dp[i][j]则要继承上一个状态的dp[i-1][j]。

2024-12-16 16:59:38 638

空空如也

kali linux apache2服务浏览器中无法访问