- 博客(893)
- 收藏
- 关注
RSS订阅原创 LeetCode 522.最长特殊序列2
根据题目，我们可以枚举每个字符串的所有子串，然后找出其他字符串中没有出现的子串，然后取最长的长度值。例如，“abc” 是 “aebdc” 的子序列，因为您可以删除"aebdc"中的下划线字符来得到 “abc”。“aebdc"的子序列还包括"aebdc”、 “aeb” 和 “” (空字符串)。特殊序列 定义如下：该序列为某字符串 独有的子序列（即不能是其他字符串的子序列）。输入: strs = [“aba”,“cdc”,“eae”]输入: strs = [“aaa”,“aaa”,“aa”]
2025-09-07 17:30:04
195
原创 LeetCode 3132.找出与数组相加的整数2
移除 nums1 中下标为 [0,4] 的两个元素，并且每个元素与 -2 相加后，nums1 变为 [18,14,10] ，与 nums2 相等。测试用例以这样的方式生成：存在一个整数 x，nums1 中的每个元素都与 x 相加后，再移除两个元素，nums1 可以与 nums2 相等。移除 nums1 中下标为 [0,3] 的两个元素，并且每个元素与 2 相加后，nums1 变为 [7,7] ，与 nums2 相等。输入：nums1 = [4,20,16,12,8], nums2 = [14,18,10]
2025-09-03 20:51:01
257
原创 LeetCode 1023.驼峰式匹配
输入：queries = [“FooBar”,“FooBarTest”,“FootBall”,“FrameBuffer”,“ForceFeedBack”], pattern = “FoBaT”输入：queries = [“FooBar”,“FooBarTest”,“FootBall”,“FrameBuffer”,“ForceFeedBack”], pattern = “FoBa”“FooBarTest” 可以这样生成：“Fo” + “o” + “Ba” + “r” + “T” + “est”.
2025-09-03 20:42:27
394
原创 LeetCode 2825.循环增长使字符串子序列等于另一个字符串
对于选中的每一个下标 i ，你将 str1[i] 循环 递增，变成下一个字符。也就是说 ‘a’ 变成 ‘b’ ，‘b’ 变成 ‘c’ ，以此类推，‘z’ 变成 ‘a’。如果执行以上操作 至多一次 ，可以让 str2 成为 str1 的子序列，请你返回 true ，否则返回 false。因此，str1 变成 “abd” 且 str2 现在是一个子序列。因此，str1 变成 “ad” 且 str2 现在是一个子序列。解释：这个例子中，没法在执行一次操作的前提下，将 str2 变为 str1 的子序列。
2025-09-03 20:29:19
252
原创 LeetCode 2486.追加字符以获得子序列
现在需要通过向 s 末尾追加字符的方式使 t 变成 s 的一个 子序列 ，返回需要追加的最少字符数。解释：向 s 末尾追加字符串 “ding” ，s = “coachingding”。解释：向 s 末尾追加字符串 “abcde” ，s = “zabcde”。输入：s = “coaching”, t = “coding”解释：t 已经是 s (“abcde”) 的一个子序列。输入：s = “abcde”, t = “a”输入：s = “z”, t = “abcde”s 和 t 仅由小写英文字母组成。
2025-09-03 20:24:29
239
原创 LeetCode 524.通过删除字母匹配到字典里最长单词
如果字典的长度为n，s的长度为m，字典中单词的平均长度为l，则此算法时间复杂度为O(n(m+l))，因为需要遍历n个单词，每个单词需要m的时间判断是否匹配，以及最差需要l的时间判断是否是字母序最小的串；输入：s = “abpcplea”, dictionary = [“ale”,“apple”,“monkey”,“plea”]输入：s = “abpcplea”, dictionary = [“a”,“b”,“c”]如果答案不止一个，返回长度最长且字母序最小的字符串。输出：“apple”
2025-09-03 20:20:47
174
原创 LeetCode 392.判断子序列
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。, Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。t的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。给定字符串 s 和 t ，判断 s 是否为 t 的子序列。输入：s = “abc”, t = “ahbgdc”输入：s = “axc”, t = “ahbgdc”两个字符串都只由小写字符组成。
2025-09-03 20:12:39
224
1
原创 LeetCode 1537.最大得分
2,4,5,8,10], [2,4,5,8,9], [2,4,6,8,9], [2,4,6,8,10],（从 nums1 开始遍历）[4,6,8,9], [4,5,8,10], [4,5,8,9], [4,6,8,10] （从 nums2 开始遍历）输入：nums1 = [1,2,3,4,5], nums2 = [6,7,8,9,10]输入：nums1 = [2,4,5,8,10], nums2 = [4,6,8,9]输入：nums1 = [1,3,5,7,9], nums2 = [3,5,100]
2025-09-03 20:05:38
452
原创 LeetCode 面试题 16.06.最小差
如果a的长度为n，b的长度为m，则此算法时间复杂度为O(nlogn + mlogm)，空间复杂度为O(logn + logm)。给定两个整数数组a和b，计算具有最小差绝对值的一对数值（每个数组中取一个值），并返回该对数值的差。输入：{1, 3, 15, 11, 2}, {23, 127, 235, 19, 8}正确结果在区间 [0, 2147483647] 内。输出：3，即数值对(11, 8)
2025-09-03 20:00:11
147
原创 LeetCode 986.区间列表的交集
输入：firstList = [[0,2],[5,10],[13,23],[24,25]], secondList = [[1,5],[8,12],[15,24],[25,26]]输出：[[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]输入：firstList = [], secondList = [[4,8],[10,12]]输入：firstList = [[1,3],[5,9]], secondList = []返回这 两个区间列表的交集。输出：[[3,7]]
2025-09-03 19:54:58
369
原创 LeetCode 844.比较含退格的字符串
给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true。如果s的长度为n，t的长度为m，则此算法时间复杂度为O(n+m)，空间复杂度为O(1)。输入：s = “ab#c”, t = “ad#c”输入：s = “ab##”, t = “c#d#”解释：s 会变成 “c”，但 t 仍然是 “b”。注意：如果对空文本输入退格字符，文本继续为空。输入：s = “a#c”, t = “b”解释：s 和 t 都会变成 “ac”。解释：s 和 t 都会变成 “”。
2025-09-02 23:46:38
210
原创 LeetCode 777.在LR字符串中交换相邻字符
在一个由 ‘L’ , ‘R’ 和 ‘X’ 三个字符组成的字符串（例如"RXXLRXRXL"）中进行移动操作。一次移动操作指用一个 “LX” 替换一个 “XL”，或者用一个 “XR” 替换一个 “RX”。现给定起始字符串 start 和结束字符串 result，请编写代码，当且仅当存在一系列移动操作使得 start 可以转换成 result 时， 返回 True。输入：start = “RXXLRXRXL”, result = “XRLXXRRLX”输入：start = “X”, result = “L”
2025-09-02 22:41:16
303
原创 LeetCode 2337.移动片段得到字符串
字符 ‘L’ 和 ‘R’ 表示片段，其中片段 ‘L’ 只有在其左侧直接存在一个 空位 时才能向 左 移动，而片段 ‘R’ 只有在其右侧直接存在一个 空位 时才能向 右 移动。解释：字符串 start 中的片段只能向右移动，所以无法从字符串 start 得到 target。start 和 target 由字符 ‘L’、‘R’ 和 ‘_’ 组成。字符 ‘_’ 表示可以被 任意 ‘L’ 或 ‘R’ 片段占据的空位。解释：字符串 start 中的 ‘R’ 片段可以向右移动一步得到 “输入：start = “
2025-09-02 22:08:41
360
原创 LeetCode 809.情感丰富的文字
例如，以 “hello” 为例，我们可以对字母组 “o” 扩张得到 “hellooo”，但是无法以同样的方法得到 “helloo” 因为字母组 “oo” 长度小于 3。如果 s = “helllllooo”，那么查询词 “hello” 是可扩张的，因为可以对它执行这两种扩张操作使得 query = “hello” -> “hellooo” -> “helllllooo” = s。我们将相邻字母都相同的一串字符定义为相同字母组，例如：“h”, “eee”, “ll”, “ooo”。
2025-09-02 20:58:21
227
原创 LeetCode 925.长按键入
你的朋友正在使用键盘输入他的名字 name。偶尔，在键入字符 c 时，按键可能会被长按，而字符可能被输入 1 次或多次。如果它对应的可能是你的朋友的名字（其中一些字符可能被长按），那么就返回 True。如果name的长度为n，typed长度为m，则此算法时间复杂度为O(n+m)，空间复杂度为O(1)。解释：‘e’ 一定需要被键入两次，但在 typed 的输出中不是这样。输入：name = “alex”, typed = “aaleex”解释：‘alex’ 中的 ‘a’ 和 ‘e’ 被长按。
2025-09-02 20:42:30
152
原创 LeetCode 1385.两个数组间的距离值
距离值」 定义为符合此距离要求的元素数目：对于元素 arr1[i] ，不存在任何元素 arr2[j] 满足 |arr1[i]-arr2[j]| <= d。输入：arr1 = [1,4,2,3], arr2 = [-4,-3,6,10,20,30], d = 3。输入：arr1 = [2,1,100,3], arr2 = [-5,-2,10,-3,7], d = 6。输入：arr1 = [4,5,8], arr2 = [10,9,1,8], d = 2。所以 arr1[1]=5 也符合距离要求。
2025-09-01 23:48:06
184
原创 LeetCode 1855.下标对中的最大距离
解释：有效下标对是 (0,0), (2,2), (2,3), (2,4), (3,3), (3,4) 和 (4,4)。输入：nums1 = [55,30,5,4,2], nums2 = [100,20,10,10,5]输入：nums1 = [30,29,19,5], nums2 = [25,25,25,25,25]解释：有效下标对是 (2,2), (2,3), (2,4), (3,3) 和 (3,4)。输入：nums1 = [2,2,2], nums2 = [10,10,1]
2025-08-31 20:28:12
284
原创 LeetCode LCP 18.早餐组合
解释：小扣有 8 种购买方案，所选主食与所选饮料在数组中对应的下标分别是： 第 1 种方案：staple[0] + drinks[2] = 2 + 5 = 7；第 5 种方案：staple[1] + drinks[3] = 1 + 1 = 2；解释：小扣有 6 种购买方案，所选主食与所选饮料在数组中对应的下标分别是： 第 1 种方案：staple[0] + drinks[0] = 10 + 5 = 15；输入：staple = [2,1,1], drinks = [8,9,5,1], x = 9。
2025-08-31 18:24:15
240
原创 LeetCode 350.两个数组的交集2
给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。由于进阶1加入了两数组有序的条件，因此排序不算入时间复杂度，如果nums1的长度为n，nums2的长度为m，则此算法时间复杂度为O(n+m)，空间复杂度为O(1)。如果nums1的长度为n，nums2的长度为m，则此算法时间复杂度为O(n+m)，空间复杂度为O(n)。输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]输入：nums1 = [1,2,2,1], nums2 = [2,2]
2025-08-31 13:16:55
167
原创 LeetCode 2570.合并两个二维数组
每个 id 在结果数组中 只能出现一次 ，并且其对应的值等于两个数组中该 id 所对应的值求和。输入：nums1 = [[1,2],[2,3],[4,5]], nums2 = [[1,4],[3,2],[4,1]]输入：nums1 = [[2,4],[3,6],[5,5]], nums2 = [[1,3],[4,3]]输出：[[1,3],[2,4],[3,6],[4,3],[5,5]]只有在两个数组中至少出现过一次的 id 才能包含在结果数组内。输出：[[1,6],[2,3],[3,2],[4,6]]
2025-08-31 12:22:58
175
原创 LeetCode 88.合并两个有序数组
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3。合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。输入：nums1 = [0], m = 0, nums2 = [1], n = 1。输入：nums1 = [1], m = 1, nums2 = [], n = 0。解释：需要合并 [1,2,3] 和 [2,5,6]。解释：需要合并的数组是 [] 和 [1]。输出：[1,2,2,3,5,6]
2025-08-31 12:09:37
320
原创 LeetCode 2540.最小公共值
给你两个整数数组 nums1 和 nums2 ，它们已经按非降序排序，请你返回两个数组的 最小公共整数。如果nums1的大小为n，nums2的大小为m，则此算法时间复杂度为O(n+m)，空间复杂度为O(1)。输入：nums1 = [1,2,3,6], nums2 = [2,3,4,5]解释：两个数组中的公共元素是 2 和 3 ，2 是较小值，所以返回 2。输入：nums1 = [1,2,3], nums2 = [2,4]解释：两个数组的最小公共元素是 2 ，所以我们返回 2。
2025-08-30 22:24:55
239
原创 LeetCode 2109.向字符串添加空格
例如，s = “EnjoyYourCoffee” 且 spaces = [5, 9] ，那么我们需要在 ‘Y’ 和 ‘C’ 之前添加空格，这两个字符分别位于下标 5 和下标 9。数组 spaces 描述原字符串中需要添加空格的下标。输入：s = “LeetcodeHelpsMeLearn”, spaces = [8,13,15]输入：s = “icodeinpython”, spaces = [1,5,7,9]输入：s = “spacing”, spaces = [0,1,2,3,4,5,6]
2025-08-30 19:42:41
308
原创 LeetCode 287.寻找重复数
给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。如果nums的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。假设 nums 只有 一个重复的整数 ，返回 这个重复的数。输入：nums = [1,3,4,2,2]输入：nums = [3,1,3,4,2]输入：nums = [3,3,3,3,3]
2025-08-30 19:35:50
189
原创 LeetCode 142.环形链表2
为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。假设环外的长度为a，slow进入环后，走了b的距离与fast相遇，此时fast已经走了n圈，相遇时，fast走过的距离为。快慢指针法，慢指针slow每走一步，快指针fast走两步，当两者能相遇时，说明链表存在环。给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。解释：链表中有一个环，其尾部连接到第一个节点。
2025-08-30 18:42:36
295
原创 LeetCode 141.环形链表
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果链表的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。否则，返回 false。输入：head = [3,2,0,-4], pos = 1。给你一个链表的头节点 head ，判断链表中是否有环。解释：链表中有一个环，其尾部连接到第二个节点。解释：链表中有一个环，其尾部连接到第一个节点。解释：链表中没有环。
2025-08-26 00:26:57
279
原创 LeetCode 41.缺失的第一个正数
如果nums的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。输入：nums = [7,8,9,11,12]解释：范围 [1,2] 中的数字都在数组中。输入：nums = [3,4,-1,1]输入：nums = [1,2,0]解释：1 在数组中，但 2 没有。解释：最小的正数 1 没有出现。
2025-08-24 02:58:52
198
原创 LeetCode 448.找到所有数组中消失的数字
给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。进阶：你能在不使用额外空间且时间复杂度为 O(n) 的情况下解决这个问题吗?你可以假定返回的数组不算在额外空间内。如果nums的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。输入：nums = [4,3,2,7,8,2,3,1]输入：nums = [1,1]
2025-08-23 19:34:51
190
原创 LeetCode 442.数组中重复的数据
给你一个长度为 n 的整数数组 nums ，其中 nums 的所有整数都在范围 [1, n] 内，且每个整数出现 最多两次。下标处，如果放置时发现该位置的值已经是nums[i]，说明该值是一个重复值。如果nums的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。，因此我们可以将nums中的每个下标为i数字nums[i]放到数组的。输入：nums = [4,3,2,7,8,2,3,1]nums 中的每个元素出现 一次 或 两次。输入：nums = [1,1,2]输入：nums = [1]
2025-08-19 01:16:32
242
原创 LeetCode 75.颜色分类
给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，原地 对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。如果nums的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。必须在不使用库内置的 sort 函数的情况下解决这个问题。输入：nums = [2,0,2,1,1,0]输入：nums = [2,0,1]nums[i] 为 0、1 或 2。输出：[0,0,1,1,2,2]输出：[0,1,2]
2025-08-17 20:47:32
181
原创 LeetCode 1089.复写零
请对输入的数组 就地 进行上述修改，不要从函数返回任何东西。给你一个长度固定的整数数组 arr ，请你将该数组中出现的每个零都复写一遍，并将其余的元素向右平移。如果nums的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。解释：调用函数后，输入的数组将被修改为：[1,0,0,2,3,0,0,4]解释：调用函数后，输入的数组将被修改为：[1,2,3]输入：arr = [1,0,2,3,0,4,5,0]输出：[1,0,0,2,3,0,0,4]输入：arr = [1,2,3]输出：[1,2,3]
2025-08-17 17:49:35
116
原创 LeetCode 2460.对数组执行操作
如果 nums[i] == nums[i + 1] ，则 nums[i] 的值变成原来的 2 倍，nums[i + 1] 的值变成 0。例如，数组 [1,0,2,0,0,1] 将所有 0 移动到末尾后变为 [1,2,1,0,0,0]。给你一个下标从 0 开始的数组 nums ，数组大小为 n ，且由 非负 整数组成。如果nums的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。输入：nums = [1,2,2,1,1,0]输出：[1,4,2,0,0,0]输入：nums = [0,1]
2025-08-16 01:35:28
320
原创 LeetCode 3467.将数组按照奇偶性转化
将偶数（4 和 2）替换为 0，将奇数（1, 5 和 1）替换为 1。现在，nums = [1, 1, 1, 0, 0]。现在，nums = [0, 1, 0, 1]。按非递减顺序排序 nums，得到 nums = [0, 0, 1, 1, 1]。按非递减顺序排序 nums，得到 nums = [0, 0, 1, 1]。输入：nums = [1,5,1,4,2]输入：nums = [4,3,2,1]输出：[0,0,1,1,1]输出：[0,0,1,1]将每个偶数替换为 0。将每个奇数替换为 1。
2025-08-16 00:47:01
287
原创 LeetCode 922.按奇偶排序数组2
是已经排好序的部分，如果右指针指向的值和左指针l的奇偶性相同，就交换左右指针指向的值，然后递增左指针l；对数组进行排序，以便当 nums[i] 为奇数时，i 也是 奇数；当 nums[i] 为偶数时， i 也是 偶数。给定一个非负整数数组 nums， nums 中一半整数是 奇数 ，一半整数是 偶数。解释：[4,7,2,5]，[2,5,4,7]，[2,7,4,5] 也会被接受。输入：nums = [4,2,5,7]输入：nums = [2,3]输出：[4,5,2,7]nums 中一半是偶数。
2025-08-15 22:41:41
180
原创 LeetCode 905.按奇偶排序数组
给你一个整数数组 nums，将 nums 中的的所有偶数元素移动到数组的前面，后跟所有奇数元素。解释：[4,2,3,1]、[2,4,1,3] 和 [4,2,1,3] 也会被视作正确答案。如果nums的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。返回满足此条件的 任一数组 作为答案。输入：nums = [3,1,2,4]输入：nums = [0]输出：[2,4,3,1]
2025-08-15 20:44:33
238
原创 LeetCode 283.移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。如果nums的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。请注意 ，必须在不复制数组的情况下原地对数组进行操作。输入: nums = [0,1,0,3,12]进阶：你能尽量减少完成的操作次数吗？输出: [1,3,12,0,0]输入: nums = [0]
2025-08-15 20:39:23
138
原创 LeetCode 80.删除有序数组中的重复项2
解释：函数应返回新长度 length = 7, 并且原数组的前七个元素被修改为 0, 0, 1, 1, 2, 3, 3。解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3。输入：nums = [0,0,1,1,1,1,2,3,3]输出：7, nums = [0,0,1,1,2,3,3]输出：5, nums = [1,1,2,2,3]// 在函数里修改输入数组对于调用者是可见的。输入：nums = [1,1,1,2,2,3]nums 已按升序排列。
2025-08-14 23:59:18
158
原创 LeetCode 1793.好子数组的最大分数
一个子数组 (i, j) 的 分数 定义为 min(nums[i], nums[i+1], …解释：最优子数组的左右端点下标是 (1, 5) ，分数为 min(4,3,7,4,5) * (5-1+1) = 3 * 5 = 15。解释：最优子数组的左右端点下标是 (0, 4) ，分数为 min(5,5,4,5,4) * (4-0+1) = 4 * 5 = 20。输入：nums = [5,5,4,5,4,1,1,1], k = 0。输入：nums = [1,4,3,7,4,5], k = 3。
2025-08-14 01:20:16
212
原创 LeetCode 581.最短无序连续子数组
我们可以先找出升序的前缀和后缀，找到前缀的最后一个位置maxLeft和后缀的第一个位置minRight，然后找出(maxLeft, minRight)里的最大值maxMid和最小值minMid，然后在前缀里找到第一个大于minMid的位置，这就是需要排序的左起点；解释：你只需要对 [6, 4, 8, 10, 9] 进行升序排序，那么整个表都会变为升序排序。输入：nums = [2,6,4,8,10,9,15]输入：nums = [1,2,3,4]输入：nums = [1]
2025-08-13 01:44:32
222
原创 LeetCode 2234.花园的最大总美丽值
给你一个下标从 0 开始大小为 n 的整数数组 flowers ，其中 flowers[i] 是第 i 个花园里已经种的花的数目。输入：flowers = [1,3,1,1], newFlowers = 7, target = 6, full = 12, partial = 1。输入：flowers = [2,4,5,3], newFlowers = 10, target = 5, full = 2, partial = 6。Alice 是 n 个花园的园丁，她想通过种花，最大化她所有花园的总美丽值。
2025-08-13 00:34:20
270
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人