zik的博客

其余的操作就是正常的基数排序，就是直接分为十个桶(0-9十位刚好十个桶)。而基数排序可以在 O(N)的时间内完成整数之间的排序。输入：nums = [5,1,1,2,0,0]输入：nums = [5,2,3,1]Out-place: 占用额外内存。输出：[0,0,1,1,2,5]时间复杂度：O(n logn)时间复杂度：O(nlogn)时间复杂度：O(nlogn)空间复杂度：O(logn)空间复杂度：O(logn)输出：[1,2,3,5]时间复杂度：O(n*k)空间复杂度：O(n+k)空间复杂度：O(n)

从0.0001到0.02有linear，cosine，sqrt_linear，sqrtbetas = (else:Adam及其变种：结合动量和自适应学习率，快速稳定收敛，适用于大多数深度学习任务。AdamW 是 Adam 优化器的改进版本，旨在解决 Adam 优化器在某些情况下会导致权重衰减（weight decay）效果不佳的问题。

原创文章，转载告知，盗版必究。

1一小时再20分钟简历然后问了其他自己做的实习论文怎么做的 细细讲。

Word Embedding 是一种将词语表示为低维稠密向量的方法，使得具有相似语义的词在向量空间中距离较近。这种方法通过捕捉词语之间的语义关系，广泛应用于自然语言处理任务中。什么是 Word EmbeddingWord Embedding 是将词语映射到连续向量空间的技术，这些向量通常是低维的（如100维或300维），相比传统的高维稀疏表示（如 one-hot encoding），它们更为紧凑且包含更多语义信息。特点和优势。

给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。输入：nums = [7,8,9,11,12]解释：范围 [1,2] 中的数字都在数组中。输入：nums = [3,4,-1,1]输入：nums = [1,2,0]解释：1 在数组中，但 2 没有。解释：最小的正数 1 没有出现。时间复杂度：O(n)空间复杂度：O(n)时间复杂度：O(n)空间复杂度：O(1)时间复杂度：O(n)空间复杂度：O(1)

我们可以将版本号按照点号分割成修订号，然后从左到右比较两个版本号的相同下标的修订号。注意根据题目要求，如果版本号不存在某个下标处的修订号，则该修订号视为 0。version1 的第二个修订号为 “2”，version2 的第二个修订号为 “10”：2 < 10，所以 version1 < version2。方法一需要存储分割后的修订号，为了优化空间复杂度，我们可以在分割版本号的同时解析出修订号进行比较。version1 有更少的修订号，每个缺失的修订号按 “0” 处理。原创文章，转载告知，盗版必究。

凑足总额为j - coins[i]的最少个数为dp[j - coins[i]]，那么只需要加上一个钱币coins[i]即dp[j - coins[i]] + 1就是dp[j]（考虑coins[i]）考虑到递推公式的特性，dp[j]必须初始化为一个最大的数，否则就会在min(dp[j - coins[i]] + 1, dp[j])比较的过程中被初始值覆盖。递推公式：dp[j] = min(dp[j - coins[i]] + 1, dp[j]);dp[j]：凑足总额为j所需钱币的最少个数为dp[j]

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）输入: preorder = [-1], inorder = [-1]第五步：切割后序数组，切成后序左数组和后序右数组。空间复杂度：O(n)

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。输入: num1 = “2”, num2 = “3”num1 和 num2 只能由数字组成。时间复杂度：O(n)空间复杂度：O(n)时间复杂度：O(n)空间复杂度：O(n)时间复杂度：O(n)空间复杂度：O(n)

在遍历过程中，只要有两个连续索引对应字符可以构成一对括号就出栈，这样栈中存储的都是到当前位置暂时不可以构成括号的索引。当前字符s[i]将会是栈中第一个字符，无法跟之前的字符构成一对括号。其实也就是栈顶元素必须为’(‘，当前字符s[i]必须为’)'，这样才能构成一对括号。因为此时栈可能为空，如果为空就是res = max(res, i - (-1))当前有效括号的长度 = 当前索引i - 栈顶存储的索引stack[-1]解释：最长有效括号子串是 “()()”输入：s = “)()())”时间复杂度：O(n)

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。输入：nums = [1,3,-1,-3,5,3,6,7], k = 3。滑动窗口的位置 最大值。输入：nums = [1], k = 1。输出：[3,3,5,5,6,7]返回 滑动窗口中的最大值。时间复杂度：O(n)空间复杂度：O(k)时间复杂度：O(n)空间复杂度：O(k)时间复杂度：O(n)空间复杂度：O(n)

更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的 下一个排列 就是在这个有序容器中排在它后面的那个排列。第二：如果找到了顺序对，那么在区间 [i+1,n) 中从后向前查找第一个元素 j 满足 a[i]

进阶：你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗。给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表。输入：head = [-1,5,3,4,0]最后进行归并排序：空间复杂度：O(logn)输入：head = [4,2,1,3]输出：[-1,0,3,4,5]时间复杂度：O(nlogn)时间复杂度：O(nlogn)空间复杂度：O(logn)输出：[1,2,3,4]输入：head = []空间复杂度：O(1)时间复杂度：O(n)空间复杂度：O(n)

令 k1 = ( len(nums1) + len(nums2) + 1 ) // 2。令 k2 = ( len(nums1) + len(nums2) + 2 ) // 2。所以我们得到了获得中位数的统一方法：(helper(k1)+helper(k2))/2。解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5。输入：nums1 = [1,2], nums2 = [3,4]输入：nums1 = [1,3], nums2 = [2]时间复杂度：O(log(n+m))

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。输入: nums = [-1,0,3,5,9,12], target = 9。输入: nums = [-1,0,3,5,9,12], target = 2。nums 的每个元素都将在 [-9999, 9999]之间。解释: 2 不存在 nums 中因此返回 -1。空间复杂度：O(1)空间复杂度：O(1)空间复杂度：O(1)

那么对于每一层来说，我们在这层见到的第一个结点一定是最右边的结点。我们可以对二叉树进行层次遍历，那么对于每层来说，最右边的结点一定是最后被遍历到的。给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。输入: [1,2,3,null,5,null,4]二叉树的节点个数的范围是 [0,100]输入: [1,null,3]输出: [1,3,4]时间复杂度：O(n)空间复杂度：O(n)时间复杂度：O(n)空间复杂度：O(n)空间复杂度：O(n)

给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字。输入：head = [1,1,1,2,3]链表中节点数目在范围 [0, 300] 内。原创文章，转载告知，盗版必究。输出：[1,2,5]时间复杂度：O(n)空间复杂度：O(1)时间复杂度：O(n)空间复杂度：O(1)时间复杂度：O(n)空间复杂度：O(n)

如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;即：dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);

给定一个二叉树的根节点 root ，返回 它的 中序 遍历。进阶: 递归算法很简单，你可以通过迭代算法完成吗？输入：root = [1,null,2,3]树中节点数目在范围 [0, 100] 内。输入：root = [1]输入：root = []输出：[1,3,2]时间复杂度：O(n)空间复杂度：O(n)时间复杂度：O(n)空间复杂度：O(n)时间复杂度：O(n)空间复杂度：O(n)

时间复杂度: O(3^4)，IP地址最多包含4个数字，每个数字最多有3种可能的分割方式，则搜索树的最大深度为4，每个节点最多有3个子节点。时间复杂度: O(3^4)，IP地址最多包含4个数字，每个数字最多有3种可能的分割方式，则搜索树的最大深度为4，每个节点最多有3个子节点。时间复杂度: O(3^4)，IP地址最多包含4个数字，每个数字最多有3种可能的分割方式，则搜索树的最大深度为4，每个节点最多有3个子节点。输出：[“255.255.11.135”,“255.255.111.35”]

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。输入：head = [1,2,3,4,5], n = 2。输入：head = [1,2], n = 1。输入：head = [1], n = 1。进阶：你能尝试使用一趟扫描实现吗？输出：[1,2,3,5]链表中结点的数目为 sz。时间复杂度：O(n)空间复杂度：O(1)时间复杂度：O(n)空间复杂度：O(1)时间复杂度：O(n)空间复杂度：O(n)

那么就在回顾上面讲过的dp[i][j]的定义，word1[i - 1] 与 word2[j - 1]相等了，那么就不用编辑了，以下标i-2为结尾的字符串word1和以下标j-2为结尾的字符串word2的最近编辑距离dp[i - 1][j - 1]就是 dp[i][j]了。if (word1[i - 1] == word2[j - 1]) 那么说明不用任何编辑，dp[i][j] 就应该是 dp[i - 1][j - 1]，即dp[i][j] = dp[i - 1][j - 1];

二叉树的 直径 是指树中任意两个节点之间最长路径的 长度。这条路径可能经过也可能不经过根节点 root。解释：3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。给你一棵二叉树的根节点，返回该树的 直径。两节点之间路径的 长度 由它们之间边数表示。输入：root = [1,2,3,4,5]树中节点数目在范围 [1, 10。输入：root = [1,2]时间复杂度：O(n)空间复杂度：O(n)时间复杂度：O(n)空间复杂度：O(n)时间复杂度：O(n)空间复杂度：O(n)

二叉树中的 路径 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。非空节点的最大贡献值等于节点值与其子节点中的最大贡献值之和（对于叶节点而言，最大贡献值等于节点值）。解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42。解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6。输入：root = [-10,9,20,null,null,15,7]时间复杂度：O(n)空间复杂度：O(n)空间复杂度：O(n)空间复杂度：O(n)

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi]。输入：intervals = [[1,3],[2,6],[8,10],[15,18]]解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。输入：intervals = [[1,4],[4,5]]输出：[[1,6],[8,10],[15,18]]空间复杂度：O(logn)快排栈。输出：[[1,5]]

时间复杂度：O(n)，其中 n 是数组 height 的长度。解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。空间复杂度：O(n)，其中 n 是数组 height 的长度。输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]空间复杂度：O(n) 空间复杂度主要取决于栈空间，栈的大小不会超过 n。输入：height = [4,2,0,3,2,5]时间复杂度：O(n)空间复杂度：O(1)

答：如果链表长度为偶数，例如链表由 [1,2,3,4]四个节点组成，那么找中间节点并反转后，我们得到的两个链表分别为 head=[1,2,3] 和 head2=[4,3]。注意它俩都包含节点 3。输入：head = [1,2,3,4,5]输入：head = [1,2,3,4]链表的长度范围为 [1, 5 * 10。输出：[1,5,2,4,3]输出：[1,4,2,3]时间复杂度：O(n)空间复杂度：O(1)时间复杂度：O(n)空间复杂度：O(n)时间复杂度：O(n)空间复杂度：O(n)

你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。输入：num1 = “11”, num2 = “123”输入：num1 = “456”, num2 = “77”输入：num1 = “0”, num2 = “0”时间复杂度：O(n + m)时间复杂度：O(n + m)空间复杂度：O(1)空间复杂度：O(1)时间复杂度：O(n)空间复杂度：O(n)

为什么一定表示 “以nums[i]结尾的最长递增子序” ，因为我们在 做 递增比较的时候，如果比较 nums[j] 和 nums[i] 的大小，那么两个递增子序列一定分别以nums[j]为结尾 和 nums[i]为结尾， 要不然这个比较就没有意义了，不是尾部元素的比较那么 如何算递增呢。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的。所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);空间复杂度：O(n)空间复杂度：O(n)

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。图示两个链表在节点 c1 开始相交：

时间复杂度：O(nlogk) 其中 k 为 lists 的长度，n 为所有链表的节点数之和。每个节点参与链表合并的次数为 O(log⁡k) 次，一共有 n 个节点，所以总的时间复杂度为 O(nlog⁡k)。每个节点参与链表合并的次数为 O(log⁡k) 次，一共有 n 个节点，所以总的时间复杂度为 O(nlog⁡k)。输入：lists = [[1,4,5],[1,3,4],[2,6]]输出：[1,1,2,3,4,4,5,6]输入：lists = [[]]输入：lists = []空间复杂度：O(1)

res = []t += 1r -= 1b -= 1l += 1return res时间复杂度：O(nm)空间复杂度：O(1)

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left

给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。输入：root = [1]输入：root = []时间复杂度：O(n)空间复杂度：O(n)时间复杂度：O(n)空间复杂度：O(n)时间复杂度：O(n)空间复杂度：O(n)

那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。其实这种情况和n为1的时候 效果是一样的，一样可以通过这个方法找到 环形的入口节点，只不过，index1 指针在环里 多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。

为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。输入：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]。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1。输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4。输入：root = [1,2], p = 1, q = 2。空间复杂度：O(n)空间复杂度：O(n)

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。输入：head = [3,2,0,-4], pos = 1。给你一个链表的头节点 head ，判断链表中是否有环。输入：head = [1,2], pos = 0。解释：链表中有一个环，其尾部连接到第二个节点。解释：链表中有一个环，其尾部连接到第一个节点。输入：head = [1], pos = -1。解释：链表中没有环。

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。时间复杂度: O(n * 2^n)时间复杂度: O(n * 2^n)时间复杂度: O(n * 2^n)你可以按 任何顺序 返回答案。输入：n = 4, k = 2。输入：n = 1, k = 1。原创文章，转载告知，盗版必究。空间复杂度: O(n)空间复杂度: O(n)空间复杂度: O(n)