weixin_51418895的博客

其中 m 和 n 分别是两个链表的长度。这种方法的时间复杂度是。

递归遍历的解法，每当遍历到一条树枝的叶子节点，就会更新最小深度，当遍历完整棵树后，就能算出整棵树的最小深度。按照 BFS 从上到下逐层遍历二叉树的特点，当遍历到第一个叶子节点时，就能得到最小深度。

由于矩阵每一行和每一列都是有序的，我们可以利用这个特性，避免暴力遍历所有元素。这样我们就能像“走楼梯”一样，逐步逼近目标值。

这两个步骤组合起来，就等价于整个矩阵顺时针旋转了 90 度。对每一行进行翻转，从左到右变成从右到左。把矩阵的行和列交换，即。

然后向内收缩边界，继续遍历下一层，直到所有元素都被访问完为止。

但需要注意的是，第一行和第一列本身也可能被置零，所以我们需要用两个布尔变量来单独记录它们的状态。利用矩阵的第一行和第一列来标记对应的列和行是否需要置零，这样就不需要额外的空间了。同理，对每一个需要置零的列 j，我们从第 0 行到第 m-1 行依次设置为 0。对每一个需要置零的行 i，我们从第 0 列到第 n-1 列依次设置为 0。如果当前元素是 0，就把该行首和列首置零，表示这一行/列后续都需要置零。同理，只要第一行中有 0，就说明整行要置零。只要第一列中有一个 0，说明整列都要置零。

这种思想的核心在于：将原始数组作为隐式的哈希表来使用，把每个数字放到它应该出现的位置上（如数字 x 放到索引 x - 1 处），这样就能通过一次遍历找到缺失的最小正整数。我们可以使用一个哈希集合（set）来记录nums中所有存在的整数，然后从 1 开始依次检查这些数字是否存在于集合中，一旦发现某个数字不存在，就返回它。这种方法虽然没有达到最优的空间复杂度（O(1)），但它的实现简单、逻辑清晰，适用于大多数场景，特别是对时间和思维成本有限制的情况下。：O(n)，因为使用了一个哈希集合保存所有不重复的元素。

改进一下代码，不再使用两个数组存储前缀乘积和后缀乘积，而是先用answer数组存储前缀乘积，然后用一个变量遍历后缀乘积，并实时地更新answer，这样可以只使用输出数组和一个变量，实现 O(1) 的额外空间复杂度。就表示了从 nums[0] 到 nums[i-1] 的乘积，即当前元素左边所有数的乘积。就等于 “左边乘积 × 右边乘积”，也就是题目要求的 “除自己外其余元素的乘积”。表示从 nums[i+1] 到 nums[-1] 的乘积。表示从 nums[0] 到 nums[i-1] 的乘积。

这个写法会直接替换 nums 列表的内容，而不是创建一个新的列表对象。这样就能确保外部看到的是我们修改后的结果。这行代码只是让变量 nums 指向了一个新的列表对象，而原来的列表没有被修改。因为当 k 大于数组长度 n 时，旋转 k 次和旋转 k % n 次的结果是一样的。这个技巧不仅适用于数组旋转问题，也广泛用于循环类题目中，用来简化逻辑、提高效率。的题目来说，这样的写法会导致函数外部看不到任何变化。这是本题最容易出错的地方！🔍 为什么要这么做？

为了能顺利合并区间，首先我们要对所有区间按照起始点从小到大排序。这样我们可以确保在遍历时，所有可能重合的区间都排列在一起，方便处理。遍历结束后，我们还需要把最后合并的那个区间也加入结果集中。

使用经典的动态规划算法——

【代码】Leetcode刷题记录23——最小覆盖子串。

【代码】Leetcode刷题记录22——滑动窗口最大值。

用与字符串p相同长度的滑动窗口遍历字符串s，将窗口内的字符串排序，并与排序后的字符串p做对比，如果两者相同，就记录下当前的index，遍历结束后，返回索引列表。的方法来降低时间复杂度。具体来说，可以使用两个长度为26的数组（假设只包含小写字母）分别记录p中每个字符的出现次数以及当前考察的s子串中对应字符的出现次数。搜了一下，字符串排序操作的时间复杂度是O(nlogn)，对每一个字符串进行这个操作时间复杂度较高，得换思路。好吧确实快多了，算法学习之路还很漫长啊。快了不少啊，应该能过。

通过两个指针，第一个指针指向字串的开头，第二个指针向后找，直到找到重复的字符或者到达字符的末尾，第二个指针每向后移动一位，当前的子串长度加一，然后与最大长度作比较，留下更大的那个作为最长子串长度。

然后减去该木板的高度得到水量，那么指针的方法就是进一步简化了这个过程，在移动指针时，优先移动值较小的指针，假设值较小的指针是左指针，那么即便右指针所指数并不是严格的。此处最难想明白的可能是为什么这样移动指针是正确的，其实很简单，回想一下思路二，每到一块木板处，计算水量的方法都是找到这块木板。（1）通过i遍历数组，遍历到一个位置时，就找一遍左右两边的最高柱子left_max 和 right_max。（3）把每一次计算的结果累加在总数中，遍历完成后return即可。，所以用这个值计算水量是正确的。

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i!= k ，同时还满足 nums[i] + nums[j] + nums[k] == 0。（4）计算三个指针所指数字的和，如果大于0，说明此时数字大了，由于nums数组是升序排序好的，可以将right指针向左移一位，这样三个指针所指数字的和会变小。不同的三元组是 [-1,0,1] 和 [-1,-1,2]。输出：[[-1,-1,2],[-1,0,1]]输入：nums = [0,1,1]

由于水量的计算方式为：两个指针指向的数字中较小值∗指针之间的距离，如果我们移动数字较大的那个指针，那么前者「两个指针指向的数字中较小值」不会增加，后者「指针之间的距离」会减小，那么这个乘积会减小。还是得看题解，题解的思路是，设定两个指针，分别从数组的最左和最右向中间遍历数组，每一次遍历计算水量后，要考虑移动哪个指针。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。好吧，不给你偷懒的机会，思路肯定是能得出正确结果的，但还是换思路吧。返回容器可以储存的最大水量。说明：你不能倾斜容器。

（3）通过left找到第一个0后，将right设为left+1，也就是左指针的后一位，通过移动right，找到第一个不为0的数，如果找不到，说明数组的顺序不需要调整，不需要任何操作，因为。nums[left]不为0，nums[right]为0，或者nums[left]不为0，nums[right]不为0，此时要让慢指针去找到下一个0移动，慢指针向前移动一位。nums[left]为0，nums[right]也为0，此时要让right去找到下一个不为0的数移动，快指针向前移一位；输入: nums = [0]

（3）如果num-1不在哈希表中，说明当前的键是候选最长序列数组的开头元素，此时，将候选最长序列数组长度置为1，并从num+1开始递增查找哈希表，每递增并查找到一次，就在候选最长序列数组长度上加一，直到查不到为止。（2）开始遍历哈希表的键，对于当前的键num，寻找num-1是否在哈希表中，如果存在，则不做任何操作，继续循环，因为当前的键不是候选最长序列数组的开头元素。输入：nums = [0,3,7,2,5,8,4,6,0,1]输入：nums = [100,4,200,1,3,2]

（3）查询哈希表，如果排好序的字符串已经存储在了哈希表中，就把当前字符串存在这个Key所对应的Value列表中，如果没有存储过，那就创建一个新的Key-Value对，新的Key-Value对中，Key是排好序的字符串，Value是当前字符串。输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]输出: [[“a”]]输出: [[“”]]

因为每个人都可以在第 k 个人买完票之前轮到他们购买票，所以他们的购票次数受限于他们自身需要的票数和 tickets[k] 中较小的那个值。第二种：tickets[0]为零，同时k为0，这说明买完票的这个人就是我们关注的人，他已经买完票了，所用的时间即为所求，return time即可；第三种：tickets[0]为零，同时k不为0，这说明买完票的这个人不是我们关注的人，他已经买完票了，可以离开队伍了，不用再入队。在最前面的人买完票后，队伍在第 1 秒变成 [1,1,1,4]。

（2）使用num遍历nums，如果num不在targets中，则将num作为key存入targets，并将value设为1（表示nums中num的出现次数为1），否则，对num的value加一；（3）遍历完成后，再对targets遍历，找到value为1的key，并return这个key，即为所求。（1）设定一个空的字典，用来存储nums中的元素（key）及其出现次数（value）；输入：nums = [4,1,2,1,2]输入：nums = [2,2,1]输入：nums = [1]首先需要明确，什么是。

还有一个大佬的思路特别好，就是利用了set( )方法可以对集合内的重复元素自动去重的特性，直接把nums转换成一个集合num_set，去重之后，比较nums和num_set的长度，如果不相等，说明nums中一定存在重复元素，绝妙的思路╰(（3）每遍历一个num，就去寻找集合中是否有相同的元素，若有，则返回True，若没有，则将num存储在集合中，进入下一轮循环遍历，直到遍历完成时还没有重复，则返回False。输入：nums = [1,1,1,3,3,4,3,2,4,2]元素 1 在下标 0 和 3 出现。

（3）对于haystack长度等于needle的情况，再分两种情况，如果haystack不等于needle，直接返回-1，如果相等，直接返回0。（4）对于haystack长度大于needle的情况，对haystack进行遍历，找到第一个与needle相同的字符段，并返回索引。（2）对于haystack长度小于needle的情况，needle 一定不是 haystack 的一部分，直接返回 -1。解释：“leeto” 没有在 “leetcode” 中出现，所以返回 -1。

后一位置**，通过一个快指针遍历数组中的所有元素，将快指针找到的与val不等的元素赋值给慢指针定位的元素，并将慢指针移动一位，遍历后即为所求。其中，“移除数组”是指已经将与val相等元素移除出去的部分。解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。输入：nums = [0,1,2,2,3,0,4,2], val = 2。输入：nums = [3,2,2,3], val = 3。输出：5, nums = [0,1,4,0,3,输出：2, nums = [2,2,

给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2。输入：nums = [0,0,1,1,1,2,2,3,3,4]

思路一：通过递归的方式，每一次递归都由两个链表元素最小的的节点作为前置节点，连接其它节点的递归结果，由于每一次都是选择最小节点，可以保证最终链表的升序排列。（2）遍历两个链表，把较小的节点作为下一个节点，循环遍历直到一个链表被查询完。新链表是通过拼接给定的两个链表的所有节点组成的。输入：l1 = [1,2,4], l2 = [1,3,4]（3）把另一个链表剩余的部分接到新链表后，返回。输入：l1 = [], l2 = [0]输入：l1 = [], l2 = []输出：[1,1,2,3,4,4]

（3）为了避免对类似于’)))(((‘和’}}{{'的括号左右顺序错误情况误判为正确，在每一次做完加减法后都需要加一个判断，如果small、mid、large三个变量中出现一个负值，代表该字符串一定出现了左右顺序错误，直接返回False。（2）遍历字符串，遇到左边的括号就压入栈，遇到右边的括号就查看栈顶的元素，如果匹配，就pop出，如果不匹配，把右边的括号也压入栈。给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。（1）建立括号之间的匹配字典，以及空的栈。

（1）首先找到字符串数组中“最大”和“最小”的两个字符串（此处我直接用的python中的min和max函数，我觉得应该是比较ASCII码）。（5）如果在此过程中发现最长公共前缀为空，可以直接退出循环，以节省算力资源。输入：strs = [“flower”,“flow”,“flight”]输入：strs = [“dog”,“racecar”,“car”]（4）将两个字符一致的部分更新为新的最长公共前缀，重新进入。（2）找到这两个字符串的最长公共前缀即为所求。如果不存在公共前缀，返回空字符串 “”。

通常情况下，罗马数字中小的数字在大的数字的右边。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4。例如， 罗马数字 2 写做 II ，即为两个并列的 1。否则，将其加到总和中。X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。解释: M = 1000, CM = 900, XC = 90, IV = 4.I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

PS：之后我又看了下比我快的和比我慢的题解，似乎也都局限于这两种算法，可能这两种算法的时间消耗跟算法选择关系不大，可能跟硬件有关？给你一个整数 x ，如果 x 是一个回文整数，返回 true；否则，返回 false。解释：从左向右读, 为 -121。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。解释：从右向左读, 为 01。（3）x>0，通过取余10的方式一步步翻转x。例如，121 是回文，而 123 不是。（1）x<0，返回False；（2）x=0，返回True；

记录leetcode刷题中的解题思路