directory
0.0.0-20240920062246-d0657495930a
Repository: https://github.com/yigmmk/leetcode.git
Documentation: pkg.go.dev
# Packages
@lc code=start*
* Definition for a binary tree node.
@lc code=start*
* Definition for a binary tree node.
@lc code=start*
* Definition for a binary tree node.
* @lc app=leetcode.cn id=125 lang=golang
*
* [125] 验证回文串
*
* https://leetcode.cn/problems/valid-palindrome/description/
*
* algorithms
* Easy (46.90%)
* Likes: 557
* Dislikes: 0
* Total Accepted: 391K
* Total Submissions: 833.9K
* Testcase Example: '"A man, a plan, a canal: Panama"'
*
* 给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
*
* 说明：本题中，我们将空字符串定义为有效的回文串。
*
*
*
* 示例 1:
*
*
* 输入: "A man, a plan, a canal: Panama"
* 输出: true
* 解释："amanaplanacanalpanama" 是回文串
*
*
* 示例 2:
*
*
* 输入: "race a car"
* 输出: false
* 解释："raceacar" 不是回文串
*
*
*
*
* 提示：
*
*
* 1
* 字符串 s 由 ASCII 字符组成
*
*
*/.
No description provided by the author
* @lc app=leetcode.cn id=318 lang=golang
*
* [318] 最大单词长度乘积
*
* https://leetcode.cn/problems/maximum-product-of-word-lengths/description/
*
* algorithms
* Medium (73.66%)
* Likes: 368
* Dislikes: 0
* Total Accepted: 59.3K
* Total Submissions: 80.5K
* Testcase Example: '["abcw","baz","foo","bar","xtfn","abcdef"]'
*
* 给你一个字符串数组 words ，找出并返回 length(words[i]) * length(words[j])
* 的最大值，并且这两个单词不含有公共字母。如果不存在这样的两个单词，返回 0 。
*
*
*
* 示例 1：
*
*
* 输入：words = ["abcw","baz","foo","bar","xtfn","abcdef"]
* 输出：16
* 解释：这两个单词为 "abcw", "xtfn"。
*
* 示例 2：
*
*
* 输入：words = ["a","ab","abc","d","cd","bcd","abcd"]
* 输出：4
* 解释：这两个单词为 "ab", "cd"。
*
* 示例 3：
*
*
* 输入：words = ["a","aa","aaa","aaaa"]
* 输出：0
* 解释：不存在这样的两个单词。
*
*
*
*
* 提示：
*
*
* 2 <= words.length <= 1000
* 1 <= words[i].length <= 1000
* words[i] 仅包含小写字母
*
*
*/.
* @lc app=leetcode.cn id=142 lang=golang
*
* [142] 环形链表 II
*
* https://leetcode.cn/problems/linked-list-cycle-ii/description/
*
* algorithms
* Medium (56.33%)
* Likes: 1734
* Dislikes: 0
* Total Accepted: 525.1K
* Total Submissions: 930.6K
* Testcase Example: '[3,2,0,-4]\n1'
*
* 给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
*
* 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos
* 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos
* 不作为参数进行传递，仅仅是为了标识链表的实际情况。
*
* 不允许修改 链表。
*
*
*
*
*
*
* 示例 1：
*
*
*
*
* 输入：head = [3,2,0,-4], pos = 1
* 输出：返回索引为 1 的链表节点
* 解释：链表中有一个环，其尾部连接到第二个节点。
*
*
* 示例 2：
*
*
*
*
* 输入：head = [1,2], pos = 0
* 输出：返回索引为 0 的链表节点
* 解释：链表中有一个环，其尾部连接到第一个节点。
*
*
* 示例 3：
*
*
*
*
* 输入：head = [1], pos = -1
* 输出：返回 null
* 解释：链表中没有环。
*
*
*
*
* 提示：
*
*
* 链表中节点的数目范围在范围 [0, 10^4] 内
* -10^5 <= Node.val <= 10^5
* pos 的值为 -1 或者链表中的一个有效索引
*
*
*
*
* 进阶：你是否可以使用 O(1) 空间解决此题？
*
*/.
* @lc app=leetcode.cn id=143 lang=golang
*
* [143] 重排链表
*
* https://leetcode.cn/problems/reorder-list/description/
*
* algorithms
* Medium (64.29%)
* Likes: 1018
* Dislikes: 0
* Total Accepted: 208.1K
* Total Submissions: 323.5K
* Testcase Example: '[1,2,3,4]'
*
* 给定一个单链表 L 的头节点 head ，单链表 L 表示为：
*
*
* L0 → L1 → … → Ln - 1 → Ln
*
*
* 请将其重新排列后变为：
*
*
* L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …
*
* 不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
*
*
*
* 示例 1：
*
*
*
*
* 输入：head = [1,2,3,4]
* 输出：[1,4,2,3]
*
* 示例 2：
*
*
*
*
* 输入：head = [1,2,3,4,5]
* 输出：[1,5,2,4,3]
*
*
*
* 提示：
*
*
* 链表的长度范围为 [1, 5 * 10^4]
* 1 <= node.val <= 1000
*
*
*/.
* @lc app=leetcode.cn id=713 lang=golang
*
* [713] 乘积小于 K 的子数组
*
* https://leetcode.cn/problems/subarray-product-less-than-k/description/
*
* algorithms
* Medium (48.82%)
* Likes: 577
* Dislikes: 0
* Total Accepted: 82K
* Total Submissions: 168K
* Testcase Example: '[10,5,2,6]\n100'
*
* 给你一个整数数组 nums 和一个整数 k ，请你返回子数组内所有元素的乘积严格小于 k 的连续子数组的数目。
*
*
* 示例 1：
*
*
* 输入：nums = [10,5,2,6], k = 100
* 输出：8
* 解释：8 个乘积小于 100 的子数组分别为：[10]、[5]、[2],、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。
* 需要注意的是 [10,5,2] 并不是乘积小于 100 的子数组。
*
*
* 示例 2：
*
*
* 输入：nums = [1,2,3], k = 0
* 输出：0
*
*
*
* 提示:
*
*
* 1 <= nums.length <= 3 * 10^4
* 1 <= nums[i] <= 1000
* 0 <= k <= 10^6
*
*
*/.
* @lc app=leetcode.cn id=160 lang=golang
*
* [160] 相交链表
*
* https://leetcode.cn/problems/intersection-of-two-linked-lists/description/
*
* algorithms
* Easy (63.06%)
* Likes: 1829
* Dislikes: 0
* Total Accepted: 542K
* Total Submissions: 858.2K
* Testcase Example: '8\n[4,1,8,4,5]\n[5,6,1,8,4,5]\n2\n3'
*
* 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
*
* 图示两个链表在节点 c1 开始相交：
*
*
*
* 题目数据 保证 整个链式结构中不存在环。
*
* 注意，函数返回结果后，链表必须 保持其原始结构 。
*
* 自定义评测：
*
* 评测系统 的输入如下（你设计的程序 不适用 此输入）：
*
*
* intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
* listA - 第一个链表
* listB - 第二个链表
* skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
* skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数
*
*
* 评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被
* 视作正确答案 。
*
*
*
* 示例 1：
*
*
*
*
* 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2,
* skipB = 3
* 输出：Intersected at '8'
* 解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
* 从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
* 在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
*
*
* 示例 2：
*
*
*
*
* 输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB
* = 1
* 输出：Intersected at '2'
* 解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
* 从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
* 在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
*
*
* 示例 3：
*
*
*
*
* 输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
* 输出：null
* 解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
* 由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
* 这两个链表不相交，因此返回 null 。
*
*
*
*
* 提示：
*
*
* listA 中节点数目为 m
* listB 中节点数目为 n
* 1 <= m, n <= 3 * 10^4
* 1 <= Node.val <= 10^5
* 0 <= skipA <= m
* 0 <= skipB <= n
* 如果 listA 和 listB 没有交点，intersectVal 为 0
* 如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]
*
*
*
*
* 进阶：你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？
*
*/.
* @lc app=leetcode.cn id=1604 lang=golang
*
* [1604] 警告一小时内使用相同员工卡大于等于三次的人
*
* https://leetcode.cn/problems/alert-using-same-key-card-three-or-more-times-in-a-one-hour-period/description/
*
- algorithms
- Medium (42.52%)
- Likes: 45
- Dislikes: 0
- Total Accepted: 12.1K
- Total Submissions: 25K
- Testcase Example: '["daniel","daniel","daniel","luis","luis","luis","luis"]\n' +
'["10:00","10:40","11:00","09:00","11:00","13:00","15:00"]'
*
*
* 力扣公司的员工都使用员工卡来开办公室的门。每当一个员工使用一次他的员工卡，安保系统会记录下员工的名字和使用时间。如果一个员工在一小时时间内使用员工卡的次数大于等于三次，这个系统会自动发布一个
* 警告 。
*
* 给你字符串数组 keyName 和 keyTime ，其中 [keyName[i], keyTime[i]] 对应一个人的名字和他在 某一天
* 内使用员工卡的时间。
*
* 使用时间的格式是 24小时制 ，形如 "HH:MM" ，比方说 "23:51" 和 "09:49" 。
*
* 请你返回去重后的收到系统警告的员工名字，将它们按 字典序升序 排序后返回。
*
* 请注意 "10:00" - "11:00" 视为一个小时时间范围内，而 "23:51" - "00:10"
* 不被视为一小时内，因为系统记录的是某一天内的使用情况。
*
*
*
* 示例 1：
*
*
* 输入：keyName = ["daniel","daniel","daniel","luis","luis","luis","luis"],
* keyTime = ["10:00","10:40","11:00","09:00","11:00","13:00","15:00"]
* 输出：["daniel"]
* 解释："daniel" 在一小时内使用了 3 次员工卡（"10:00"，"10:40"，"11:00"）。
*
*
* 示例 2：
*
*
* 输入：keyName = ["alice","alice","alice","bob","bob","bob","bob"], keyTime =
* ["12:01","12:00","18:00","21:00","21:20","21:30","23:00"]
* 输出：["bob"]
* 解释："bob" 在一小时内使用了 3 次员工卡（"21:00"，"21:20"，"21:30"）。
*
*
* 示例 3：
*
*
* 输入：keyName = ["john","john","john"], keyTime = ["23:58","23:59","00:01"]
* 输出：[]
*
*
* 示例 4：
*
*
* 输入：keyName = ["leslie","leslie","leslie","clare","clare","clare","clare"],
* keyTime = ["13:00","13:20","14:00","18:00","18:51","19:30","19:49"]
* 输出：["clare","leslie"]
*
*
*
*
* 提示：
*
*
* 1
* keyName.length == keyTime.length
* keyTime 格式为 "HH:MM" 。
* 保证 [keyName[i], keyTime[i]] 形成的二元对 互不相同 。
* 1
* keyName[i] 只包含小写英文字母。
*
*
*/.
* @lc app=leetcode.cn id=1664 lang=golang
*
* [1664] 生成平衡数组的方案数
*
* https://leetcode.cn/problems/ways-to-make-a-fair-array/description/
*
* algorithms
* Medium (55.85%)
* Likes: 51
* Dislikes: 0
* Total Accepted: 10.8K
* Total Submissions: 17.6K
* Testcase Example: '[2,1,6,4]'
*
* 给你一个整数数组 nums 。你需要选择 恰好 一个下标（下标从 0 开始）并删除对应的元素。请注意剩下元素的下标可能会因为删除操作而发生改变。
*
* 比方说，如果 nums = [6,1,7,4,1] ，那么：
*
*
* 选择删除下标 1 ，剩下的数组为 nums = [6,7,4,1] 。
* 选择删除下标 2 ，剩下的数组为 nums = [6,1,4,1] 。
* 选择删除下标 4 ，剩下的数组为 nums = [6,1,7,4] 。
*
*
* 如果一个数组满足奇数下标元素的和与偶数下标元素的和相等，该数组就是一个 平衡数组 。
*
* 请你返回删除操作后，剩下的数组 nums 是 平衡数组 的 方案数 。
*
*
*
* 示例 1：
*
*
* 输入：nums = [2,1,6,4]
* 输出：1
* 解释：
* 删除下标 0 ：[1,6,4] -> 偶数元素下标为：1 + 4 = 5 。奇数元素下标为：6 。不平衡。
* 删除下标 1 ：[2,6,4] -> 偶数元素下标为：2 + 4 = 6 。奇数元素下标为：6 。平衡。
* 删除下标 2 ：[2,1,4] -> 偶数元素下标为：2 + 4 = 6 。奇数元素下标为：1 。不平衡。
* 删除下标 3 ：[2,1,6] -> 偶数元素下标为：2 + 6 = 8 。奇数元素下标为：1 。不平衡。
* 只有一种让剩余数组成为平衡数组的方案。
*
*
* 示例 2：
*
*
* 输入：nums = [1,1,1]
* 输出：3
* 解释：你可以删除任意元素，剩余数组都是平衡数组。
*
*
* 示例 3：
*
*
* 输入：nums = [1,2,3]
* 输出：0
* 解释：不管删除哪个元素，剩下数组都不是平衡数组。
*
*
*
*
* 提示：
*
*
* 1
* 1
*
*
*/.
@lc code=start*
* Definition for a binary tree node.
* @lc app=leetcode.cn id=1802 lang=golang
*
* [1802] 有界数组中指定下标处的最大值
*
* https://leetcode.cn/problems/maximum-value-at-a-given-index-in-a-bounded-array/description/
*
* algorithms
* Medium (29.20%)
* Likes: 78
* Dislikes: 0
* Total Accepted: 10.6K
* Total Submissions: 31.5K
* Testcase Example: '4\n2\n6'
*
* 给你三个正整数 n、index 和 maxSum 。你需要构造一个同时满足下述所有条件的数组 nums（下标 从 0 开始 计数）：
*
*
* nums.length == n
* nums[i] 是 正整数 ，其中 0 <= i < n
* abs(nums[i] - nums[i+1]) <= 1 ，其中 0 <= i < n-1
* nums 中所有元素之和不超过 maxSum
* nums[index] 的值被 最大化
*
*
* 返回你所构造的数组中的 nums[index] 。
*
* 注意：abs(x) 等于 x 的前提是 x >= 0 ；否则，abs(x) 等于 -x 。
*
*
*
* 示例 1：
*
* 输入：n = 4, index = 2, maxSum = 6
* 输出：2
* 解释：数组 [1,1,2,1] 和 [1,2,2,1] 满足所有条件。不存在其他在指定下标处具有更大值的有效数组。
*
*
* 示例 2：
*
* 输入：n = 6, index = 1, maxSum = 10
* 输出：3
*
*
*
*
* 提示：
*
*
* 1 <= n <= maxSum <= 10^9
* 0 <= index < n
*
*
*/.
No description provided by the author
No description provided by the author
No description provided by the author
* @lc app=leetcode.cn id=1817 lang=golang
*
* [1817] 查找用户活跃分钟数
*
* https://leetcode.cn/problems/finding-the-users-active-minutes/description/
*
* algorithms
* Medium (70.22%)
* Likes: 59
* Dislikes: 0
* Total Accepted: 21K
* Total Submissions: 26.6K
* Testcase Example: '[[0,5],[1,2],[0,2],[0,5],[1,3]]\n5'
*
* 给你用户在 LeetCode 的操作日志，和一个整数 k 。日志用一个二维整数数组 logs 表示，其中每个 logs[i] = [IDi,
* timei] 表示 ID 为 IDi 的用户在 timei 分钟时执行了某个操作。
*
* 多个用户 可以同时执行操作，单个用户可以在同一分钟内执行 多个操作 。
*
* 指定用户的 用户活跃分钟数（user active minutes，UAM） 定义为用户对 LeetCode 执行操作的 唯一分钟数 。
* 即使一分钟内执行多个操作，也只能按一分钟计数。
*
* 请你统计用户活跃分钟数的分布情况，统计结果是一个长度为 k 且 下标从 1 开始计数 的数组 answer ，对于每个 j（1 ），answer[j]
* 表示 用户活跃分钟数 等于 j 的用户数。
*
* 返回上面描述的答案数组 answer 。
*
*
*
* 示例 1：
*
*
* 输入：logs = [[0,5],[1,2],[0,2],[0,5],[1,3]], k = 5
* 输出：[0,2,0,0,0]
* 解释：
* ID=0 的用户执行操作的分钟分别是：5 、2 和 5 。因此，该用户的用户活跃分钟数为 2（分钟 5 只计数一次）
* ID=1 的用户执行操作的分钟分别是：2 和 3 。因此，该用户的用户活跃分钟数为 2
* 2 个用户的用户活跃分钟数都是 2 ，answer[2] 为 2 ，其余 answer[j] 的值都是 0
*
*
* 示例 2：
*
*
* 输入：logs = [[1,1],[2,2],[2,3]], k = 4
* 输出：[1,1,0,0]
* 解释：
* ID=1 的用户仅在分钟 1 执行单个操作。因此，该用户的用户活跃分钟数为 1
* ID=2 的用户执行操作的分钟分别是：2 和 3 。因此，该用户的用户活跃分钟数为 2
* 1 个用户的用户活跃分钟数是 1 ，1 个用户的用户活跃分钟数是 2
* 因此，answer[1] = 1 ，answer[2] = 1 ，其余的值都是 0
*
*
*
*
* 提示：
*
*
* 1
* 0 i
* 1 i
* k 的取值范围是 [用户的最大用户活跃分钟数, 10^5]
*
*
*/.
* @lc app=leetcode.cn id=1877 lang=golang
*
* [1877] 数组中最大数对和的最小值
*/.
* @lc app=leetcode.cn id=19 lang=golang
*
* [19] 删除链表的倒数第 N 个结点
*
* https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/
*
* algorithms
* Medium (44.42%)
* Likes: 2183
* Dislikes: 0
* Total Accepted: 899.6K
* Total Submissions: 2M
* Testcase Example: '[1,2,3,4,5]\n2'
*
* 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
*
*
*
* 示例 1：
*
*
* 输入：head = [1,2,3,4,5], n = 2
* 输出：[1,2,3,5]
*
*
* 示例 2：
*
*
* 输入：head = [1], n = 1
* 输出：[]
*
*
* 示例 3：
*
*
* 输入：head = [1,2], n = 1
* 输出：[1]
*
*
*
*
* 提示：
*
*
* 链表中结点的数目为 sz
* 1 <= sz <= 30
* 0 <= Node.val <= 100
* 1 <= n <= sz
*
*
*
*
* 进阶：你能尝试使用一趟扫描实现吗？
*
*/.
No description provided by the author
* @lc app=leetcode.cn id=2032 lang=golang
*
* [2032] 至少在两个数组中出现的值
*
* https://leetcode.cn/problems/two-out-of-three/description/
*
* algorithms
* Easy (66.57%)
* Likes: 51
* Dislikes: 0
* Total Accepted: 23.1K
* Total Submissions: 32K
* Testcase Example: '[1,1,3,2]\n[2,3]\n[3]'
*
* 给你三个整数数组 nums1、nums2 和 nums3 ，请你构造并返回一个 元素各不相同的 数组，且由 至少 在 两个
* 数组中出现的所有值组成。数组中的元素可以按 任意 顺序排列。
*
*
* 示例 1：
*
*
* 输入：nums1 = [1,1,3,2], nums2 = [2,3], nums3 = [3]
* 输出：[3,2]
* 解释：至少在两个数组中出现的所有值为：
* - 3 ，在全部三个数组中都出现过。
* - 2 ，在数组 nums1 和 nums2 中出现过。
*
*
* 示例 2：
*
*
* 输入：nums1 = [3,1], nums2 = [2,3], nums3 = [1,2]
* 输出：[2,3,1]
* 解释：至少在两个数组中出现的所有值为：
* - 2 ，在数组 nums2 和 nums3 中出现过。
* - 3 ，在数组 nums1 和 nums2 中出现过。
* - 1 ，在数组 nums1 和 nums3 中出现过。
*
*
* 示例 3：
*
*
* 输入：nums1 = [1,2,2], nums2 = [4,3,3], nums3 = [5]
* 输出：[]
* 解释：不存在至少在两个数组中出现的值。
*
*
*
*
* 提示：
*
*
* 1 <= nums1.length, nums2.length, nums3.length <= 100
* 1 <= nums1[i], nums2[j], nums3[k] <= 100
*
*
*/.
* @lc app=leetcode.cn id=2042 lang=golang
*
* [2042] 检查句子中的数字是否递增
*
* https://leetcode.cn/problems/check-if-numbers-are-ascending-in-a-sentence/description/
*
* algorithms
* Easy (65.92%)
* Likes: 25
* Dislikes: 0
* Total Accepted: 19.3K
* Total Submissions: 27.1K
* Testcase Example: '"1 box has 3 blue 4 red 6 green and 12 yellow marbles"'
*
* 句子是由若干 token 组成的一个列表，token 间用 单个 空格分隔，句子没有前导或尾随空格。每个 token 要么是一个由数字 0-9
* 组成的不含前导零的 正整数 ，要么是一个由小写英文字母组成的 单词 。
*
*
* 示例，"a puppy has 2 eyes 4 legs" 是一个由 7 个 token 组成的句子："2" 和 "4" 是数字，其他像
* "puppy" 这样的 tokens 属于单词。
*
*
* 给你一个表示句子的字符串 s ，你需要检查 s 中的 全部 数字是否从左到右严格递增（即，除了最后一个数字，s 中的 每个 数字都严格小于它 右侧
* 的数字）。
*
* 如果满足题目要求，返回 true ，否则，返回 false 。
*
*
*
* 示例 1：
*
*
*
*
* 输入：s = "1 box has 3 blue 4 red 6 green and 12 yellow marbles"
* 输出：true
* 解释：句子中的数字是：1, 3, 4, 6, 12 。
* 这些数字是按从左到右严格递增的 1 < 3 < 4 < 6 < 12 。
*
*
* 示例 2：
*
*
* 输入：s = "hello world 5 x 5"
* 输出：false
* 解释：句子中的数字是：5, 5 。这些数字不是严格递增的。
*
*
* 示例 3：
*
*
*
*
* 输入：s = "sunset is at 7 51 pm overnight lows will be in the low 50 and 60 s"
* 输出：false
* 解释：s 中的数字是：7, 51, 50, 60 。这些数字不是严格递增的。
*
*
* 示例 4：
*
*
* 输入：s = "4 5 11 26"
* 输出：true
* 解释：s 中的数字是：4, 5, 11, 26 。
* 这些数字是按从左到右严格递增的：4 < 5 < 11 < 26 。
*
*
*
*
* 提示：
*
*
* 3 <= s.length <= 200
* s 由小写英文字母、空格和数字 0 到 9 组成（包含 0 和 9）
* s 中数字 token 的数目在 2 和 100 之间（包含 2 和 100）
* s 中的 token 之间由单个空格分隔
* s 中至少有 两个 数字
* s 中的每个数字都是一个 小于 100 的 正 数，且不含前导零
* s 不含前导或尾随空格
*
*
*/.
No description provided by the author
* @lc app=leetcode.cn id=206 lang=golang
*
* [206] 反转链表
*
* https://leetcode.cn/problems/reverse-linked-list/description/
*
* algorithms
* Easy (73.31%)
* Likes: 2730
* Dislikes: 0
* Total Accepted: 1.2M
* Total Submissions: 1.6M
* Testcase Example: '[1,2,3,4,5]'
*
* 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
*
*
*
*
* 示例 1：
*
*
* 输入：head = [1,2,3,4,5]
* 输出：[5,4,3,2,1]
*
*
* 示例 2：
*
*
* 输入：head = [1,2]
* 输出：[2,1]
*
*
* 示例 3：
*
*
* 输入：head = []
* 输出：[]
*
*
*
*
* 提示：
*
*
* 链表中节点的数目范围是 [0, 5000]
* -5000
*
*
*
*
* 进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？
*
*
*
*/.
* @lc app=leetcode.cn id=208 lang=golang
*
* [208] 实现 Trie (前缀树)
*
* https://leetcode.cn/problems/implement-trie-prefix-tree/description/
*
- algorithms
- Medium (71.91%)
- Likes: 1219
- Dislikes: 0
- Total Accepted: 208.6K
- Total Submissions: 290K
- Testcase Example: '["Trie","insert","search","search","startsWith","insert","search"]\n' +
'[[],["apple"],["apple"],["app"],["app"],["app"],["app"]]'
*
* Trie（发音类似 "try"）或者说 前缀树
* 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。
*
* 请你实现 Trie 类：
*
*
* Trie() 初始化前缀树对象。
* void insert(String word) 向前缀树中插入字符串 word 。
* boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回
* false 。
* boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true
* ；否则，返回 false 。
*
*
*
*
* 示例：
*
*
* 输入
* ["Trie", "insert", "search", "search", "startsWith", "insert", "search"]
* [[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
* 输出
* [null, null, true, false, true, null, true]
*
* 解释
* Trie trie = new Trie();
* trie.insert("apple");
* trie.search("apple"); // 返回 True
* trie.search("app"); // 返回 False
* trie.startsWith("app"); // 返回 True
* trie.insert("app");
* trie.search("app"); // 返回 True
*
*
*
*
* 提示：
*
*
* 1
* word 和 prefix 仅由小写英文字母组成
* insert、search 和 startsWith 调用次数 总计 不超过 3 * 10^4 次
*
*
*/.
* @Author: yiGmMk [email protected]
* @Date: 2022-07-27 18:19:52
* @LastEditors: yiGmMk [email protected]
* @LastEditTime: 2022-07-27 18:19:53
* @FilePath: /go-tool/home/admin/code/coding-practicing/golang/209/209.长度最小的子数组.go
* @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
*/
* @lc app=leetcode.cn id=209 lang=golang
*
* [209] 长度最小的子数组
*
* https://leetcode.cn/problems/minimum-size-subarray-sum/description/
*
* algorithms
* Medium (48.58%)
* Likes: 1270
* Dislikes: 0
* Total Accepted: 380.1K
* Total Submissions: 782.9K
* Testcase Example: '7\n[2,3,1,2,4,3]'
*
* 给定一个含有 n 个正整数的数组和一个正整数 target 。
*
* 找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr]
* ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
*
*
*
* 示例 1：
*
*
* 输入：target = 7, nums = [2,3,1,2,4,3]
* 输出：2
* 解释：子数组 [4,3] 是该条件下的长度最小的子数组。
*
*
* 示例 2：
*
*
* 输入：target = 4, nums = [1,4,4]
* 输出：1
*
*
* 示例 3：
*
*
* 输入：target = 11, nums = [1,1,1,1,1,1,1,1]
* 输出：0
*
*
*
*
* 提示：
*
*
* 1
* 1
* 1
*
*
*
*
* 进阶：
*
*
* 如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。
*
*
*/.
No description provided by the author
* @lc app=leetcode.cn id=218 lang=golang
*
* [218] 天际线问题
*
* https://leetcode.cn/problems/the-skyline-problem/description/
*
* algorithms
* Hard (55.15%)
* Likes: 727
* Dislikes: 0
* Total Accepted: 44.2K
* Total Submissions: 80.1K
* Testcase Example: '[[2,9,10],[3,7,15],[5,12,12],[15,20,10],[19,24,8]]'
*
* 城市的 天际线 是从远处观看该城市中所有建筑物形成的轮廓的外部轮廓。给你所有建筑物的位置和高度，请返回 由这些建筑物形成的 天际线 。
*
* 每个建筑物的几何信息由数组 buildings 表示，其中三元组 buildings[i] = [lefti, righti, heighti]
* 表示：
*
*
* lefti 是第 i 座建筑物左边缘的 x 坐标。
* righti 是第 i 座建筑物右边缘的 x 坐标。
* heighti 是第 i 座建筑物的高度。
*
*
* 你可以假设所有的建筑都是完美的长方形，在高度为 0 的绝对平坦的表面上。
*
* 天际线 应该表示为由 “关键点” 组成的列表，格式 [[x1,y1],[x2,y2],...] ，并按 x 坐标 进行 排序
* 。关键点是水平线段的左端点。列表中最后一个点是最右侧建筑物的终点，y 坐标始终为 0
* ，仅用于标记天际线的终点。此外，任何两个相邻建筑物之间的地面都应被视为天际线轮廓的一部分。
*
* 注意：输出天际线中不得有连续的相同高度的水平线。例如 [...[2 3], [4 5], [7 5], [11 5], [12 7]...]
* 是不正确的答案；三条高度为 5 的线应该在最终输出中合并为一个：[...[2 3], [4 5], [12 7], ...]
*
*
*
* 示例 1：
*
*
* 输入：buildings = [[2,9,10],[3,7,15],[5,12,12],[15,20,10],[19,24,8]]
* 输出：[[2,10],[3,15],[7,12],[12,0],[15,10],[20,8],[24,0]]
* 解释：
* 图 A 显示输入的所有建筑物的位置和高度，
* 图 B 显示由这些建筑物形成的天际线。图 B 中的红点表示输出列表中的关键点。
*
* 示例 2：
*
*
* 输入：buildings = [[0,2,3],[2,5,3]]
* 输出：[[0,3],[5,0]]
*
*
*
*
* 提示：
*
*
* 1 <= buildings.length <= 10^4
* 0 <= lefti < righti <= 2^31 - 1
* 1 <= heighti <= 2^31 - 1
* buildings 按 lefti 非递减排序
*
*
*/.
* @lc app=leetcode.cn id=2180 lang=golang
*
* [2180] 统计各位数字之和为偶数的整数个数
*
* https://leetcode.cn/problems/count-integers-with-even-digit-sum/description/
*
* algorithms
* Easy (64.86%)
* Likes: 47
* Dislikes: 0
* Total Accepted: 23.7K
* Total Submissions: 34.6K
* Testcase Example: '4'
*
* 给你一个正整数 num ，请你统计并返回 小于或等于 num 且各位数字之和为 偶数 的正整数的数目。
*
* 正整数的 各位数字之和 是其所有位上的对应数字相加的结果。
*
*
*
* 示例 1：
*
*
* 输入：num = 4
* 输出：2
* 解释：
* 只有 2 和 4 满足小于等于 4 且各位数字之和为偶数。
*
*
* 示例 2：
*
*
* 输入：num = 30
* 输出：14
* 解释：
* 只有 14 个整数满足小于等于 30 且各位数字之和为偶数，分别是：
* 2、4、6、8、11、13、15、17、19、20、22、24、26 和 28 。
*
*
*
*
* 提示：
*
*
* 1 <= num <= 1000
*
*
*/.
No description provided by the author
No description provided by the author
* @lc app=leetcode.cn id=2283 lang=golang
*
* [2283] 判断一个数的数字计数是否等于数位的值
*
* https://leetcode.cn/problems/check-if-number-has-equal-digit-count-and-digit-value/description/
*
* algorithms
* Easy (77.94%)
* Likes: 38
* Dislikes: 0
* Total Accepted: 20.7K
* Total Submissions: 25.7K
* Testcase Example: '"1210"'
*
* 给你一个下标从 0 开始长度为 n 的字符串 num ，它只包含数字。
*
* 如果对于 每个 0 <= i < n 的下标 i ，都满足数位 i 在 num 中出现了 num[i]次，那么请你返回 true ，否则返回 false
* 。
*
*
*
* 示例 1：
*
* 输入：num = "1210"
* 输出：true
* 解释：
* num[0] = '1' 。数字 0 在 num 中出现了一次。
* num[1] = '2' 。数字 1 在 num 中出现了两次。
* num[2] = '1' 。数字 2 在 num 中出现了一次。
* num[3] = '0' 。数字 3 在 num 中出现了零次。
* "1210" 满足题目要求条件，所以返回 true 。
*
*
* 示例 2：
*
* 输入：num = "030"
* 输出：false
* 解释：
* num[0] = '0' 。数字 0 应该出现 0 次，但是在 num 中出现了一次。
* num[1] = '3' 。数字 1 应该出现 3 次，但是在 num 中出现了零次。
* num[2] = '0' 。数字 2 在 num 中出现了 0 次。
* 下标 0 和 1 都违反了题目要求，所以返回 false 。
*
*
*
*
* 提示：
*
*
* n == num.length
* 1 <= n <= 10
* num 只包含数字。
*
*
*/.
* @lc app=leetcode.cn id=2287 lang=golang
*
* [2287] 重排字符形成目标字符串
*
* https://leetcode.cn/problems/rearrange-characters-to-make-target-string/description/
*
* algorithms
* Easy (60.34%)
* Likes: 29
* Dislikes: 0
* Total Accepted: 17.5K
* Total Submissions: 27.2K
* Testcase Example: '"ilovecodingonleetcode"\n"code"'
*
* 给你两个下标从 0 开始的字符串 s 和 target 。你可以从 s 取出一些字符并将其重排，得到若干新的字符串。
*
* 从 s 中取出字符并重新排列，返回可以形成 target 的 最大 副本数。
*
*
*
* 示例 1：
*
* 输入：s = "ilovecodingonleetcode", target = "code"
* 输出：2
* 解释：
* 对于 "code" 的第 1 个副本，选取下标为 4 、5 、6 和 7 的字符。
* 对于 "code" 的第 2 个副本，选取下标为 17 、18 、19 和 20 的字符。
* 形成的字符串分别是 "ecod" 和 "code" ，都可以重排为 "code" 。
* 可以形成最多 2 个 "code" 的副本，所以返回 2 。
*
*
* 示例 2：
*
* 输入：s = "abcba", target = "abc"
* 输出：1
* 解释：
* 选取下标为 0 、1 和 2 的字符，可以形成 "abc" 的 1 个副本。
* 可以形成最多 1 个 "abc" 的副本，所以返回 1 。
* 注意，尽管下标 3 和 4 分别有额外的 'a' 和 'b' ，但不能重用下标 2 处的 'c' ，所以无法形成 "abc" 的第 2 个副本。
*
*
* 示例 3：
*
* 输入：s = "abbaccaddaeea", target = "aaaaa"
* 输出：1
* 解释：
* 选取下标为 0 、3 、6 、9 和 12 的字符，可以形成 "aaaaa" 的 1 个副本。
* 可以形成最多 1 个 "aaaaa" 的副本，所以返回 1 。
*
*
*
*
* 提示：
*
*
* 1 <= s.length <= 100
* 1 <= target.length <= 10
* s 和 target 由小写英文字母组成
*
*
*/.
* @lc app=leetcode.cn id=2299 lang=golang
*
* [2299] 强密码检验器 II
*
* https://leetcode.cn/problems/strong-password-checker-ii/description/
*
* algorithms
* Easy (61.36%)
* Likes: 39
* Dislikes: 0
* Total Accepted: 21.5K
* Total Submissions: 32.9K
* Testcase Example: '"IloveLe3tcode!"'
*
* 如果一个密码满足以下所有条件，我们称它是一个 强 密码：
*
*
* 它有至少 8 个字符。
* 至少包含 一个小写英文 字母。
* 至少包含 一个大写英文 字母。
* 至少包含 一个数字 。
* 至少包含 一个特殊字符 。特殊字符为："!@#$%^&*()-+" 中的一个。
* 它 不 包含 2 个连续相同的字符（比方说 "aab" 不符合该条件，但是 "aba" 符合该条件）。
*
*
* 给你一个字符串 password ，如果它是一个 强 密码，返回 true，否则返回 false 。
*
*
*
* 示例 1：
*
* 输入：password = "IloveLe3tcode!"
* 输出：true
* 解释：密码满足所有的要求，所以我们返回 true 。
*
*
* 示例 2：
*
* 输入：password = "Me+You--IsMyDream"
* 输出：false
* 解释：密码不包含数字，且包含 2 个连续相同的字符。所以我们返回 false 。
*
*
* 示例 3：
*
* 输入：password = "1aB!"
* 输出：false
* 解释：密码不符合长度要求。所以我们返回 false 。
*
*
*
* 提示：
*
*
* 1 <= password.length <= 100
* password 包含字母，数字和 "!@#$%^&*()-+" 这些特殊字符。
*
*
*/.
* @lc app=leetcode.cn id=2309 lang=golang
*
* [2309] 兼具大小写的最好英文字母
*
* https://leetcode.cn/problems/greatest-english-letter-in-upper-and-lower-case/description/
*
* algorithms
* Easy (67.23%)
* Likes: 36
* Dislikes: 0
* Total Accepted: 24.8K
* Total Submissions: 34.5K
* Testcase Example: '"lEeTcOdE"'
*
* 给你一个由英文字母组成的字符串 s ，请你找出并返回 s 中的 最好
* 英文字母。返回的字母必须为大写形式。如果不存在满足条件的字母，则返回一个空字符串。
*
* 最好 英文字母的大写和小写形式必须 都 在 s 中出现。
*
* 英文字母 b 比另一个英文字母 a 更好 的前提是：英文字母表中，b 在 a 之 后 出现。
*
*
*
* 示例 1：
*
*
* 输入：s = "lEeTcOdE"
* 输出："E"
* 解释：
* 字母 'E' 是唯一一个大写和小写形式都出现的字母。
*
* 示例 2：
*
*
* 输入：s = "arRAzFif"
* 输出："R"
* 解释：
* 字母 'R' 是大写和小写形式都出现的最好英文字母。
* 注意 'A' 和 'F' 的大写和小写形式也都出现了，但是 'R' 比 'F' 和 'A' 更好。
*
*
* 示例 3：
*
*
* 输入：s = "AbCdEfGhIjK"
* 输出：""
* 解释：
* 不存在大写和小写形式都出现的字母。
*
*
*
*
* 提示：
*
*
* 1 <= s.length <= 1000
* s 由小写和大写英文字母组成
*
*
*/.
* @lc app=leetcode.cn id=2319 lang=golang
*
* [2319] 判断矩阵是否是一个 X 矩阵
*
* https://leetcode.cn/problems/check-if-matrix-is-x-matrix/description/
*
* algorithms
* Easy (73.19%)
* Likes: 31
* Dislikes: 0
* Total Accepted: 23.9K
* Total Submissions: 31.1K
* Testcase Example: '[[2,0,0,1],[0,3,1,0],[0,5,2,0],[4,0,0,2]]'
*
* 如果一个正方形矩阵满足下述 全部 条件，则称之为一个 X 矩阵 ：
*
*
* 矩阵对角线上的所有元素都 不是 0
* 矩阵中所有其他元素都是 0
*
*
* 给你一个大小为 n x n 的二维整数数组 grid ，表示一个正方形矩阵。如果 grid 是一个 X 矩阵 ，返回 true ；否则，返回 false
* 。
*
*
*
* 示例 1：
*
* 输入：grid = [[2,0,0,1],[0,3,1,0],[0,5,2,0],[4,0,0,2]]
* 输出：true
* 解释：矩阵如上图所示。
* X 矩阵应该满足：绿色元素（对角线上）都不是 0 ，红色元素都是 0 。
* 因此，grid 是一个 X 矩阵。
*
*
* 示例 2：
*
* 输入：grid = [[5,7,0],[0,3,1],[0,5,0]]
* 输出：false
* 解释：矩阵如上图所示。
* X 矩阵应该满足：绿色元素（对角线上）都不是 0 ，红色元素都是 0 。
* 因此，grid 不是一个 X 矩阵。
*
*
*
*
* 提示：
*
*
* n == grid.length == grid[i].length
* 3 <= n <= 100
* 0 <= grid[i][j] <= 10^5
*
*
*/.
* @lc app=leetcode.cn id=234 lang=golang
*
* [234] 回文链表
*
* https://leetcode.cn/problems/palindrome-linked-list/description/
*
* algorithms
* Easy (52.39%)
* Likes: 1495
* Dislikes: 0
* Total Accepted: 496.3K
* Total Submissions: 946.8K
* Testcase Example: '[1,2,2,1]'
*
* 给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。
*
*
*
* 示例 1：
*
*
* 输入：head = [1,2,2,1]
* 输出：true
*
*
* 示例 2：
*
*
* 输入：head = [1,2]
* 输出：false
*
*
*
*
* 提示：
*
*
* 链表中节点数目在范围[1, 10^5] 内
* 0 <= Node.val <= 9
*
*
*
*
* 进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？
*
*/.
* @lc app=leetcode.cn id=2347 lang=golang
*
* [2347] 最好的扑克手牌
*
* https://leetcode.cn/problems/best-poker-hand/description/
*
* algorithms
* Easy (58.93%)
* Likes: 23
* Dislikes: 0
* Total Accepted: 12.1K
* Total Submissions: 20.5K
* Testcase Example: '[13,2,3,1,9]\n["a","a","a","a","a"]'
*
* 给你一个整数数组 ranks 和一个字符数组 suit 。你有 5 张扑克牌，第 i 张牌大小为 ranks[i] ，花色为 suits[i] 。
*
* 下述是从好到坏你可能持有的 手牌类型 ：
*
*
* "Flush"：同花，五张相同花色的扑克牌。
* "Three of a Kind"：三条，有 3 张大小相同的扑克牌。
* "Pair"：对子，两张大小一样的扑克牌。
* "High Card"：高牌，五张大小互不相同的扑克牌。
*
*
* 请你返回一个字符串，表示给定的 5 张牌中，你能组成的 最好手牌类型 。
*
* 注意：返回的字符串 大小写 需与题目描述相同。
*
*
*
* 示例 1：
*
* 输入：ranks = [13,2,3,1,9], suits = ["a","a","a","a","a"]
* 输出："Flush"
* 解释：5 张扑克牌的花色相同，所以返回 "Flush" 。
*
*
* 示例 2：
*
* 输入：ranks = [4,4,2,4,4], suits = ["d","a","a","b","c"]
* 输出："Three of a Kind"
* 解释：第一、二和四张牌组成三张相同大小的扑克牌，所以得到 "Three of a Kind" 。
* 注意我们也可以得到 "Pair" ，但是 "Three of a Kind" 是更好的手牌类型。
* 有其他的 3 张牌也可以组成 "Three of a Kind" 手牌类型。
*
* 示例 3：
*
* 输入：ranks = [10,10,2,12,9], suits = ["a","b","c","a","d"]
* 输出："Pair"
* 解释：第一和第二张牌大小相同，所以得到 "Pair" 。
* 我们无法得到 "Flush" 或者 "Three of a Kind" 。
*
*
*
*
* 提示：
*
*
* ranks.length == suits.length == 5
* 1 <= ranks[i] <= 13
* 'a' <= suits[i] <= 'd'
* 任意两张扑克牌不会同时有相同的大小和花色。
*
*
*/.
* @lc app=leetcode.cn id=2357 lang=golang
*
* [2357] 使数组中所有元素都等于零
*
* https://leetcode.cn/problems/make-array-zero-by-subtracting-equal-amounts/description/
*
* algorithms
* Easy (74.22%)
* Likes: 87
* Dislikes: 0
* Total Accepted: 37.6K
* Total Submissions: 49.3K
* Testcase Example: '[1,5,0,3,5]'
*
* 给你一个非负整数数组 nums 。在一步操作中，你必须：
*
*
* 选出一个正整数 x ，x 需要小于或等于 nums 中 最小 的 非零 元素。
* nums 中的每个正整数都减去 x。
*
*
* 返回使 nums 中所有元素都等于 0 需要的 最少 操作数。
*
*
*
* 示例 1：
*
*
* 输入：nums = [1,5,0,3,5]
* 输出：3
* 解释：
* 第一步操作：选出 x = 1 ，之后 nums = [0,4,0,2,4] 。
* 第二步操作：选出 x = 2 ，之后 nums = [0,2,0,0,2] 。
* 第三步操作：选出 x = 2 ，之后 nums = [0,0,0,0,0] 。
*
* 示例 2：
*
*
* 输入：nums = [0]
* 输出：0
* 解释：nums 中的每个元素都已经是 0 ，所以不需要执行任何操作。
*
*
*
*
* 提示：
*
*
* 1 <= nums.length <= 100
* 0 <= nums[i] <= 100
*
*
*/.
No description provided by the author
* @lc app=leetcode.cn id=2486 lang=golang
*
* [2486] 追加字符以获得子序列
*
* https://leetcode.cn/problems/append-characters-to-string-to-make-subsequence/description/
*
* algorithms
* Medium (64.36%)
* Likes: 7
* Dislikes: 0
* Total Accepted: 6.2K
* Total Submissions: 9.6K
* Testcase Example: '"coaching"\n"coding"'
*
* 给你两个仅由小写英文字母组成的字符串 s 和 t 。
*
* 现在需要通过向 s 末尾追加字符的方式使 t 变成 s 的一个 子序列 ，返回需要追加的最少字符数。
*
* 子序列是一个可以由其他字符串删除部分（或不删除）字符但不改变剩下字符顺序得到的字符串。
*
*
*
* 示例 1：
*
*
* 输入：s = "coaching", t = "coding"
* 输出：4
* 解释：向 s 末尾追加字符串 "ding" ，s = "coachingding" 。
* 现在，t 是 s ("coachingding") 的一个子序列。
* 可以证明向 s 末尾追加任何 3 个字符都无法使 t 成为 s 的一个子序列。
*
*
* 示例 2：
*
*
* 输入：s = "abcde", t = "a"
* 输出：0
* 解释：t 已经是 s ("abcde") 的一个子序列。
*
*
* 示例 3：
*
*
* 输入：s = "z", t = "abcde"
* 输出：5
* 解释：向 s 末尾追加字符串 "abcde" ，s = "zabcde" 。
* 现在，t 是 s ("zabcde") 的一个子序列。
* 可以证明向 s 末尾追加任何 4 个字符都无法使 t 成为 s 的一个子序列。
*
*
*
*
* 提示：
*
*
* 1 <= s.length, t.length <= 10^5
* s 和 t 仅由小写英文字母组成
*
*
*/.
No description provided by the author
No description provided by the author
* @lc app=leetcode.cn id=67 lang=golang
*
* [67] 二进制求和
*
* https://leetcode.cn/problems/add-binary/description/
*
* algorithms
* Easy (53.78%)
* Likes: 850
* Dislikes: 0
* Total Accepted: 262.4K
* Total Submissions: 488K
* Testcase Example: '"11"\n"1"'
*
* 给你两个二进制字符串，返回它们的和（用二进制表示）。
*
* 输入为 非空 字符串且只包含数字 1 和 0。
*
*
*
* 示例 1:
*
* 输入: a = "11", b = "1"
* 输出: "100"
*
* 示例 2:
*
* 输入: a = "1010", b = "1011"
* 输出: "10101"
*
*
*
* 提示：
*
*
* 每个字符串仅由字符 '0' 或 '1' 组成。
* 1 <= a.length, b.length <= 10^4
* 字符串如果不是 "0" ，就都不含前导零。
*
*
*/.
No description provided by the author
* @lc app=leetcode.cn id=3 lang=golang
*
* [3] 无重复字符的最长子串
*
* https://leetcode.cn/problems/longest-substring-without-repeating-characters/description/
*
* algorithms
* Medium (38.93%)
* Likes: 7969
* Dislikes: 0
* Total Accepted: 1.9M
* Total Submissions: 4.9M
* Testcase Example: '"abcabcbb"'
*
* 给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
*
*
*
* 示例 1:
*
*
* 输入: s = "abcabcbb"
* 输出: 3
* 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
*
*
* 示例 2:
*
*
* 输入: s = "bbbbb"
* 输出: 1
* 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
*
*
* 示例 3:
*
*
* 输入: s = "pwwkew"
* 输出: 3
* 解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
* 请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
*
*
*
*
* 提示：
*
*
* 0 <= s.length <= 5 * 10^4
* s 由英文字母、数字、符号和空格组成
*
*
*/.
* @lc app=leetcode.cn id=304 lang=golang
*
* [304] 二维区域和检索 - 矩阵不可变
*
* https://leetcode.cn/problems/range-sum-query-2d-immutable/description/
*
- algorithms
- Medium (59.62%)
- Likes: 419
- Dislikes: 0
- Total Accepted: 99.7K
- Total Submissions: 167K
- Testcase Example: '["NumMatrix","sumRegion","sumRegion","sumRegion"]\n' +
'[[[[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]]],[2,1,4,3],[1,1,2,2],[1,2,2,4]]'
*
* 给定一个二维矩阵 matrix，以下类型的多个请求：
*
*
* 计算其子矩形范围内元素的总和，该子矩阵的 左上角 为 (row1, col1) ，右下角 为 (row2, col2) 。
*
*
* 实现 NumMatrix 类：
*
*
* NumMatrix(int[][] matrix) 给定整数矩阵 matrix 进行初始化
* int sumRegion(int row1, int col1, int row2, int col2) 返回 左上角 (row1, col1)
* 、右下角 (row2, col2) 所描述的子矩阵的元素 总和 。
*
*
*
*
* 示例 1：
*
*
*
*
* 输入:
* ["NumMatrix","sumRegion","sumRegion","sumRegion"]
*
* [[[[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]]],[2,1,4,3],[1,1,2,2],[1,2,2,4]]
* 输出:
* [null, 8, 11, 12]
*
* 解释:
* NumMatrix numMatrix = new
* NumMatrix([[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]]);
* numMatrix.sumRegion(2, 1, 4, 3); // return 8 (红色矩形框的元素总和)
* numMatrix.sumRegion(1, 1, 2, 2); // return 11 (绿色矩形框的元素总和)
* numMatrix.sumRegion(1, 2, 2, 4); // return 12 (蓝色矩形框的元素总和)
*
*
*
*
* 提示：
*
*
* m == matrix.length
* n == matrix[i].length
* 1 <= m, n <= 200
* -10^5 <= matrix[i][j] <= 10^5
* 0 <= row1 <= row2 < m
* 0 <= col1 <= col2 < n
* 最多调用 10^4 次 sumRegion 方法
*
*
*/.
* @lc app=leetcode.cn id=34 lang=golang
*
* [34] 在排序数组中查找元素的第一个和最后一个位置
*
* https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/description/
*
* algorithms
* Medium (42.34%)
* Likes: 2025
* Dislikes: 0
* Total Accepted: 688.7K
* Total Submissions: 1.6M
* Testcase Example: '[5,7,7,8,8,10]\n8'
*
* 给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
*
* 如果数组中不存在目标值 target，返回 [-1, -1]。
*
* 你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
*
*
*
* 示例 1：
*
*
* 输入：nums = [5,7,7,8,8,10], target = 8
* 输出：[3,4]
*
* 示例 2：
*
*
* 输入：nums = [5,7,7,8,8,10], target = 6
* 输出：[-1,-1]
*
* 示例 3：
*
*
* 输入：nums = [], target = 0
* 输出：[-1,-1]
*
*
*
* 提示：
*
*
* 0 <= nums.length <= 10^5
* -10^9 <= nums[i] <= 10^9
* nums 是一个非递减数组
* -10^9 <= target <= 10^9
*
*
*/.
top k的问题首先应该想到用堆解决.
* @lc app=leetcode.cn id=380 lang=golang
*
* [380] O(1) 时间插入、删除和获取随机元素
*
* https://leetcode.cn/problems/insert-delete-getrandom-o1/description/
*
- algorithms
- Medium (52.81%)
- Likes: 596
- Dislikes: 0
- Total Accepted: 90K
- Total Submissions: 170.4K
- Testcase Example: '["RandomizedSet","insert","remove","insert","getRandom","remove","insert","getRandom"]\n' +
'[[],[1],[2],[2],[],[1],[2],[]]'
*
* 实现RandomizedSet 类：
*
*
*
*
* RandomizedSet() 初始化 RandomizedSet 对象
* bool insert(int val) 当元素 val 不存在时，向集合中插入该项，并返回 true ；否则，返回 false 。
* bool remove(int val) 当元素 val 存在时，从集合中移除该项，并返回 true ；否则，返回 false 。
* int getRandom() 随机返回现有集合中的一项（测试用例保证调用此方法时集合中至少存在一个元素）。每个元素应该有 相同的概率 被返回。
*
*
* 你必须实现类的所有函数，并满足每个函数的 平均 时间复杂度为 O(1) 。
*
*
*
* 示例：
*
*
* 输入
* ["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove",
* "insert", "getRandom"]
* [[], [1], [2], [2], [], [1], [2], []]
* 输出
* [null, true, false, true, 2, true, false, 2]
*
* 解释
* RandomizedSet randomizedSet = new RandomizedSet();
* randomizedSet.insert(1); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。
* randomizedSet.remove(2); // 返回 false ，表示集合中不存在 2 。
* randomizedSet.insert(2); // 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。
* randomizedSet.getRandom(); // getRandom 应随机返回 1 或 2 。
* randomizedSet.remove(1); // 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。
* randomizedSet.insert(2); // 2 已在集合中，所以返回 false 。
* randomizedSet.getRandom(); // 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。
*
*
*
*
* 提示：
*
*
* -2^31 <= val <= 2^31 - 1
* 最多调用 insert、remove 和 getRandom 函数 2 * 10^5 次
* 在调用 getRandom 方法时，数据结构中 至少存在一个 元素。
*
*
*
*
*/.
* @lc app=leetcode.cn id=412 lang=golang
*
* [412] Fizz Buzz
*
* https://leetcode.cn/problems/fizz-buzz/description/
*
* algorithms
* Easy (71.24%)
* Likes: 198
* Dislikes: 0
* Total Accepted: 135K
* Total Submissions: 190.5K
* Testcase Example: '3'
*
* 给你一个整数 n ，找出从 1 到 n 各个整数的 Fizz Buzz 表示，并用字符串数组 answer（下标从 1
* 开始）返回结果，其中：
*
*
* answer[i] == "FizzBuzz" 如果 i 同时是 3 和 5 的倍数。
* answer[i] == "Fizz" 如果 i 是 3 的倍数。
* answer[i] == "Buzz" 如果 i 是 5 的倍数。
* answer[i] == i （以字符串形式）如果上述条件全不满足。
*
*
*
*
* 示例 1：
*
*
* 输入：n = 3
* 输出：["1","2","Fizz"]
*
*
* 示例 2：
*
*
* 输入：n = 5
* 输出：["1","2","Fizz","4","Buzz"]
*
*
* 示例 3：
*
*
* 输入：n = 15
*
* 输出：["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]
*
*
*
* 提示：
*
*
* 1 <= n <= 10^4
*
*
*/.
* @lc app=leetcode.cn id=677 lang=golang
*
* [677] 键值映射
*
* https://leetcode.cn/problems/map-sum-pairs/description/
*
- algorithms
- Medium (66.38%)
- Likes: 214
- Dislikes: 0
- Total Accepted: 42.4K
- Total Submissions: 64K
- Testcase Example: '["MapSum","insert","sum","insert","sum"]\n' +
'[[],["apple",3],["ap"],["app",2],["ap"]]'
*
* 设计一个 map ，满足以下几点:
*
*
* 字符串表示键，整数表示值
* 返回具有前缀等于给定字符串的键的值的总和
*
*
* 实现一个 MapSum 类：
*
*
* MapSum() 初始化 MapSum 对象
* void insert(String key, int val) 插入 key-val 键值对，字符串表示键 key ，整数表示值 val 。如果键
* key 已经存在，那么原来的键值对 key-value 将被替代成新的键值对。
* int sum(string prefix) 返回所有以该前缀 prefix 开头的键 key 的值的总和。
*
*
*
*
* 示例 1：
*
*
* 输入：
* ["MapSum", "insert", "sum", "insert", "sum"]
* [[], ["apple", 3], ["ap"], ["app", 2], ["ap"]]
* 输出：
* [null, null, 3, null, 5]
*
* 解释：
* MapSum mapSum = new MapSum();
* mapSum.insert("apple", 3);
* mapSum.sum("ap"); // 返回 3 (apple = 3)
* mapSum.insert("app", 2);
* mapSum.sum("ap"); // 返回 5 (apple + app = 3 + 2 = 5)
*
*
*
*
* 提示：
*
*
* 1 <= key.length, prefix.length <= 50
* key 和 prefix 仅由小写英文字母组成
* 1 <= val <= 1000
* 最多调用 50 次 insert 和 sum
*
*
*/.
* @lc app=leetcode.cn id=430 lang=golang
*
* [430] 扁平化多级双向链表
*
* https://leetcode.cn/problems/flatten-a-multilevel-doubly-linked-list/description/
*
* algorithms
* Medium (59.22%)
* Likes: 371
* Dislikes: 0
* Total Accepted: 55.3K
* Total Submissions: 93.4K
* Testcase Example: '[1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]'
*
* 你会得到一个双链表，其中包含的节点有一个下一个指针、一个前一个指针和一个额外的 子指针
* 。这个子指针可能指向一个单独的双向链表，也包含这些特殊的节点。这些子列表可以有一个或多个自己的子列表，以此类推，以生成如下面的示例所示的 多层数据结构
* 。
*
* 给定链表的头节点 head ，将链表 扁平化 ，以便所有节点都出现在单层双链表中。让 curr
* 是一个带有子列表的节点。子列表中的节点应该出现在扁平化列表中的 curr 之后 和 curr.next 之前 。
*
* 返回 扁平列表的 head 。列表中的节点必须将其 所有 子指针设置为 null 。
*
*
*
* 示例 1：
*
*
*
*
* 输入：head = [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]
* 输出：[1,2,3,7,8,11,12,9,10,4,5,6]
* 解释：输入的多级列表如上图所示。
* 扁平化后的链表如下图：
*
*
*
* 示例 2：
*
*
*
*
* 输入：head = [1,2,null,3]
* 输出：[1,3,2]
* 解释：输入的多级列表如上图所示。
* 扁平化后的链表如下图：
*
*
*
* 示例 3：
*
*
* 输入：head = []
* 输出：[]
* 说明：输入中可能存在空列表。
*
*
*
*
* 提示：
*
*
* 节点数目不超过 1000
* 1 <= Node.val <= 10^5
*
*
*
*
* 如何表示测试用例中的多级链表？
*
* 以 示例 1 为例：
*
*
* 1---2---3---4---5---6--NULL
* |
* 7---8---9---10--NULL
* |
* 11--12--NULL
*
* 序列化其中的每一级之后：
*
*
* [1,2,3,4,5,6,null]
* [7,8,9,10,null]
* [11,12,null]
*
*
* 为了将每一级都序列化到一起，我们需要每一级中添加值为 null 的元素，以表示没有节点连接到上一级的上级节点。
*
*
* [1,2,3,4,5,6,null]
* [null,null,7,8,9,10,null]
* [null,11,12,null]
*
*
* 合并所有序列化结果，并去除末尾的 null 。
*
*
* [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]
*
*
*
*
*
*/.
* @lc app=leetcode.cn id=435 lang=golang
*
* [435] 无重叠区间
*
* https://leetcode.cn/problems/non-overlapping-intervals/description/
*
* algorithms
* Medium (51.10%)
* Likes: 810
* Dislikes: 0
* Total Accepted: 178.4K
* Total Submissions: 349.1K
* Testcase Example: '[[1,2],[2,3],[3,4],[1,3]]'
*
* 给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回
* 需要移除区间的最小数量，使剩余区间互不重叠 。
*
*
*
* 示例 1:
*
*
* 输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
* 输出: 1
* 解释: 移除 [1,3] 后，剩下的区间没有重叠。
*
*
* 示例 2:
*
*
* 输入: intervals = [ [1,2], [1,2], [1,2] ]
* 输出: 2
* 解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。
*
*
* 示例 3:
*
*
* 输入: intervals = [ [1,2], [2,3] ]
* 输出: 0
* 解释: 你不需要移除任何区间，因为它们已经是无重叠的了。
*
*
*
*
* 提示:
*
*
* 1 <= intervals.length <= 10^5
* intervals[i].length == 2
* -5 * 10^4 <= starti < endi <= 5 * 10^4
*
*
*/.
No description provided by the author
* @lc app=leetcode.cn id=438 lang=golang
*
* [438] 找到字符串中所有字母异位词
*
* https://leetcode.cn/problems/find-all-anagrams-in-a-string/description/
*
* algorithms
* Medium (54.69%)
* Likes: 962
* Dislikes: 0
* Total Accepted: 213.9K
* Total Submissions: 390.9K
* Testcase Example: '"cbaebabacd"\n"abc"'
*
* 给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。
*
* 异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。
*
*
*
* 示例 1:
*
*
* 输入: s = "cbaebabacd", p = "abc"
* 输出: [0,6]
* 解释:
* 起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
* 起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。
*
*
* 示例 2:
*
*
* 输入: s = "abab", p = "ab"
* 输出: [0,1,2]
* 解释:
* 起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
* 起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
* 起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。
*
*
*
*
* 提示:
*
*
* 1 <= s.length, p.length <= 3 * 10^4
* s 和 p 仅包含小写字母
*
*
*/.
* @lc app=leetcode.cn id=445 lang=golang
*
* [445] 两数相加 II
*
* https://leetcode.cn/problems/add-two-numbers-ii/description/
*
* algorithms
* Medium (60.07%)
* Likes: 550
* Dislikes: 0
* Total Accepted: 109.8K
* Total Submissions: 182.8K
* Testcase Example: '[7,2,4,3]\n[5,6,4]'
*
* 给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。
*
* 你可以假设除了数字 0 之外，这两个数字都不会以零开头。
*
*
*
* 示例1：
*
*
*
*
* 输入：l1 = [7,2,4,3], l2 = [5,6,4]
* 输出：[7,8,0,7]
*
*
* 示例2：
*
*
* 输入：l1 = [2,4,3], l2 = [5,6,4]
* 输出：[8,0,7]
*
*
* 示例3：
*
*
* 输入：l1 = [0], l2 = [0]
* 输出：[0]
*
*
*
*
* 提示：
*
*
* 链表的长度范围为 [1, 100]
* 0 <= node.val <= 9
* 输入数据保证链表代表的数字无前导 0
*
*
*
*
* 进阶：如果输入链表不能翻转该如何解决？
*
*/.
@lc code=start*
* Definition for a binary tree node.
* @lc app=leetcode.cn id=525 lang=golang
*
* [525] 连续数组
*
* https://leetcode.cn/problems/contiguous-array/description/
*
* algorithms
* Medium (54.47%)
* Likes: 573
* Dislikes: 0
* Total Accepted: 58.7K
* Total Submissions: 107.7K
* Testcase Example: '[0,1]'
*
* 给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。
*
*
*
* 示例 1:
*
*
* 输入: nums = [0,1]
* 输出: 2
* 说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。
*
* 示例 2:
*
*
* 输入: nums = [0,1,0]
* 输出: 2
* 说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。
*
*
*
* 提示：
*
*
* 1
* nums[i] 不是 0 就是 1
*
*
*/.
* @lc app=leetcode.cn id=724 lang=golang
*
* [724] 寻找数组的中心下标
*
* https://leetcode.cn/problems/find-pivot-index/description/
*
* algorithms
* Easy (49.73%)
* Likes: 445
* Dislikes: 0
* Total Accepted: 209.1K
* Total Submissions: 420K
* Testcase Example: '[1,7,3,6,5,6]'
*
* 给你一个整数数组 nums ，请计算数组的 中心下标 。
*
* 数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。
*
* 如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。
*
* 如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 -1 。
*
*
*
* 示例 1：
*
*
* 输入：nums = [1, 7, 3, 6, 5, 6]
* 输出：3
* 解释：
* 中心下标是 3 。
* 左侧数之和 sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 ，
* 右侧数之和 sum = nums[4] + nums[5] = 5 + 6 = 11 ，二者相等。
*
*
* 示例 2：
*
*
* 输入：nums = [1, 2, 3]
* 输出：-1
* 解释：
* 数组中不存在满足此条件的中心下标。
*
* 示例 3：
*
*
* 输入：nums = [2, 1, -1]
* 输出：0
* 解释：
* 中心下标是 0 。
* 左侧数之和 sum = 0 ，（下标 0 左侧不存在元素），
* 右侧数之和 sum = nums[1] + nums[2] = 1 + -1 = 0 。
*
*
*
* 提示：
*
*
* 1 <= nums.length <= 10^4
* -1000 <= nums[i] <= 1000
*
*
*
*
* 注意：本题与主站 1991
* 题相同：https://leetcode-cn.com/problems/find-the-middle-index-in-array/
*
*/.
* @lc app=leetcode.cn id=567 lang=golang
*
* [567] 字符串的排列
*
* https://leetcode.cn/problems/permutation-in-string/description/
*
* algorithms
* Medium (44.10%)
* Likes: 735
* Dislikes: 0
* Total Accepted: 211.1K
* Total Submissions: 478.6K
* Testcase Example: '"ab"\n"eidbaooo"'
*
* 给你两个字符串 s1 和 s2 ，写一个函数来判断 s2 是否包含 s1 的排列。如果是，返回 true ；否则，返回 false 。
*
* 换句话说，s1 的排列之一是 s2 的 子串 。
*
*
*
* 示例 1：
*
*
* 输入：s1 = "ab" s2 = "eidbaooo"
* 输出：true
* 解释：s2 包含 s1 的排列之一 ("ba").
No description provided by the author
* @lc app=leetcode.cn id=6258 lang=golang
*
* [6258] 数组中最长的方波
*
* https://leetcode.cn/problems/longest-square-streak-in-an-array/description/
*
* algorithms
* Medium (39.68%)
* Likes: 3
* Dislikes: 0
* Total Accepted: 4.1K
* Total Submissions: 10.2K
* Testcase Example: '[4,3,6,16,8,2]'
*
* 给你一个整数数组 nums 。如果 nums 的子序列满足下述条件，则认为该子序列是一个 方波 ：
*
*
* 子序列的长度至少为 2 ，并且
* 将子序列从小到大排序 之后 ，除第一个元素外，每个元素都是前一个元素的 平方 。
*
*
* 返回 nums 中 最长方波 的长度，如果不存在 方波 则返回 -1 。
*
* 子序列 也是一个数组，可以由另一个数组删除一些或不删除元素且不改变剩余元素的顺序得到。
*
*
*
* 示例 1 ：
*
* 输入：nums = [4,3,6,16,8,2]
* 输出：3
* 解释：选出子序列 [4,16,2] 。排序后，得到 [2,4,16] 。
* - 4 = 2 * 2.
* @lc app=leetcode.cn id=647 lang=golang
*
* [647] 回文子串
*
* https://leetcode.cn/problems/palindromic-substrings/description/
*
* algorithms
* Medium (66.58%)
* Likes: 952
* Dislikes: 0
* Total Accepted: 215.9K
* Total Submissions: 324K
* Testcase Example: '"abc"'
*
* 给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。
*
* 回文字符串 是正着读和倒过来读一样的字符串。
*
* 子字符串 是字符串中的由连续字符组成的一个序列。
*
* 具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。
*
*
*
* 示例 1：
*
*
* 输入：s = "abc"
* 输出：3
* 解释：三个回文子串: "a", "b", "c"
*
*
* 示例 2：
*
*
* 输入：s = "aaa"
* 输出：6
* 解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"
*
*
*
* 提示：
*
*
* 1 <= s.length <= 1000
* s 由小写英文字母组成
*
*
*/.
* @lc app=leetcode.cn id=648 lang=golang
*
* [648] 单词替换
*
* https://leetcode.cn/problems/replace-words/description/
*
* algorithms
* Medium (59.98%)
* Likes: 241
* Dislikes: 0
* Total Accepted: 57.4K
* Total Submissions: 89K
* Testcase Example: '["cat","bat","rat"]\n"the cattle was rattled by the battery"'
*
* 在英语中，我们有一个叫做 词根(root) 的概念，可以词根后面添加其他一些词组成另一个较长的单词——我们称这个词为
* 继承词(successor)。例如，词根an，跟随着单词 other(其他)，可以形成新的单词 another(另一个)。
*
* 现在，给定一个由许多词根组成的词典 dictionary 和一个用空格分隔单词形成的句子
* sentence。你需要将句子中的所有继承词用词根替换掉。如果继承词有许多可以形成它的词根，则用最短的词根替换它。
*
* 你需要输出替换之后的句子。
*
*
*
* 示例 1：
*
*
* 输入：dictionary = ["cat","bat","rat"], sentence = "the cattle was rattled by
* the battery"
* 输出："the cat was rat by the bat"
*
*
* 示例 2：
*
*
* 输入：dictionary = ["a","b","c"], sentence = "aadsfasf absbs bbab cadsfafs"
* 输出："a a b c"
*
*
*
*
* 提示：
*
*
* 1 <= dictionary.length <= 1000
* 1 <= dictionary[i].length <= 100
* dictionary[i] 仅由小写字母组成。
* 1 <= sentence.length <= 10^6
* sentence 仅由小写字母和空格组成。
* sentence 中单词的总量在范围 [1, 1000] 内。
* sentence 中每个单词的长度在范围 [1, 1000] 内。
* sentence 中单词之间由一个空格隔开。
* sentence 没有前导或尾随空格。
*
*
*
*
*/.
@lc code=start*
* Definition for a binary tree node.
* @lc app=leetcode.cn id=66 lang=golang
*
* [66] 加一
*/.
* @lc app=leetcode.cn id=680 lang=golang
*
* [680] 验证回文字符串 Ⅱ
*
* https://leetcode.cn/problems/valid-palindrome-ii/description/
*
* algorithms
* Easy (40.10%)
* Likes: 524
* Dislikes: 0
* Total Accepted: 116.9K
* Total Submissions: 291.7K
* Testcase Example: '"aba"'
*
* 给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。
*
*
*
* 示例 1:
*
*
* 输入: s = "aba"
* 输出: true
*
*
* 示例 2:
*
*
* 输入: s = "abca"
* 输出: true
* 解释: 你可以删除c字符。
*
*
* 示例 3:
*
*
* 输入: s = "abc"
* 输出: false
*
*
*
* 提示:
*
*
* 1
* s 由小写英文字母组成
*
*
*/.
* @lc app=leetcode.cn id=689 lang=golang
*
* [689] 三个无重叠子数组的最大和
*
* https://leetcode.cn/problems/maximum-sum-of-3-non-overlapping-subarrays/description/
*
* algorithms
* Hard (56.31%)
* Likes: 330
* Dislikes: 0
* Total Accepted: 21.8K
* Total Submissions: 38.7K
* Testcase Example: '[1,2,1,2,6,7,5,1]\n2'
*
* 给你一个整数数组 nums 和一个整数 k ，找出三个长度为 k 、互不重叠、且全部数字和（3 * k 项）最大的子数组，并返回这三个子数组。
*
* 以下标的数组形式返回结果，数组中的每一项分别指示每个子数组的起始位置（下标从 0 开始）。如果有多个结果，返回字典序最小的一个。
*
*
*
* 示例 1：
*
*
* 输入：nums = [1,2,1,2,6,7,5,1], k = 2
* 输出：[0,3,5]
* 解释：子数组 [1, 2], [2, 6], [7, 5] 对应的起始下标为 [0, 3, 5]。
* 也可以取 [2, 1], 但是结果 [1, 3, 5] 在字典序上更大。
*
*
* 示例 2：
*
*
* 输入：nums = [1,2,1,2,1,2,1,2,1], k = 2
* 输出：[0,2,4]
*
*
*
*
* 提示：
*
*
* 1 <= nums.length <= 2 * 10^4
* 1 <= nums[i] < 2^16
* 1 <= k <= floor(nums.length / 3)
*
*
*/.
*
* Definition for a Node.
* @lc app=leetcode.cn id=724 lang=golang
*
* [724] 寻找数组的中心下标
*
* https://leetcode.cn/problems/find-pivot-index/description/
*
* algorithms
* Easy (49.73%)
* Likes: 445
* Dislikes: 0
* Total Accepted: 209.1K
* Total Submissions: 420K
* Testcase Example: '[1,7,3,6,5,6]'
*
* 给你一个整数数组 nums ，请计算数组的 中心下标 。
*
* 数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。
*
* 如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。
*
* 如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 -1 。
*
*
*
* 示例 1：
*
*
* 输入：nums = [1, 7, 3, 6, 5, 6]
* 输出：3
* 解释：
* 中心下标是 3 。
* 左侧数之和 sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 ，
* 右侧数之和 sum = nums[4] + nums[5] = 5 + 6 = 11 ，二者相等。
*
*
* 示例 2：
*
*
* 输入：nums = [1, 2, 3]
* 输出：-1
* 解释：
* 数组中不存在满足此条件的中心下标。
*
* 示例 3：
*
*
* 输入：nums = [2, 1, -1]
* 输出：0
* 解释：
* 中心下标是 0 。
* 左侧数之和 sum = 0 ，（下标 0 左侧不存在元素），
* 右侧数之和 sum = nums[1] + nums[2] = 1 + -1 = 0 。
*
*
*
* 提示：
*
*
* 1 <= nums.length <= 10^4
* -1000 <= nums[i] <= 1000
*
*
*
*
* 注意：本题与主站 1991
* 题相同：https://leetcode-cn.com/problems/find-the-middle-index-in-array/
*
*/.
* @lc app=leetcode.cn id=729 lang=golang
*
* [729] 我的日程安排表 I
*
* https://leetcode.cn/problems/my-calendar-i/description/
*
* algorithms
* Medium (53.95%)
* Likes: 123
* Dislikes: 0
* Total Accepted: 14.5K
* Total Submissions: 26.8K
* Testcase Example: '["MyCalendar","book","book","book"]\n[[],[10,20],[15,25],[20,30]]'
*
* 实现一个 MyCalendar 类来存放你的日程安排。如果要添加的日程安排不会造成 重复预订 ，则可以存储这个新的日程安排。
*
* 当两个日程安排有一些时间上的交叉时（例如两个日程安排都在同一时间内），就会产生 重复预订 。
*
* 日程可以用一对整数 start 和 end 表示，这里的时间是半开区间，即 [start, end), 实数 x 的范围为， start <= x <
* end 。
*
* 实现 MyCalendar 类：
*
*
* MyCalendar() 初始化日历对象。
* boolean book(int start, int end) 如果可以将日程安排成功添加到日历中而不会导致重复预订，返回 true 。否则，返回
* false 并且不要将该日程安排添加到日历中。
*
*
*
*
* 示例：
*
*
* 输入：
* ["MyCalendar", "book", "book", "book"]
* [[], [10, 20], [15, 25], [20, 30]]
* 输出：
* [null, true, false, true]
*
* 解释：
* MyCalendar myCalendar = new MyCalendar();
* myCalendar.book(10, 20); // return True
* myCalendar.book(15, 25); // return False ，这个日程安排不能添加到日历中，因为时间 15
* 已经被另一个日程安排预订了。
* myCalendar.book(20, 30); // return True ，这个日程安排可以添加到日历中，因为第一个日程安排预订的每个时间都小于
* 20 ，且不包含时间 20 。
*
*
*
* 提示：
*
*
* 0 <= start < end <= 10^9
* 每个测试用例，调用 book 方法的次数最多不超过 1000 次。
*
*
*/
.
* @lc app=leetcode.cn id=76 lang=golang
*
* [76] 最小覆盖子串
*
* https://leetcode.cn/problems/minimum-window-substring/description/
*
* algorithms
* Hard (44.58%)
* Likes: 2052
* Dislikes: 0
* Total Accepted: 326.8K
* Total Submissions: 732.1K
* Testcase Example: '"ADOBECODEBANC"\n"ABC"'
*
* 给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 ""
* 。
*
*
*
* 注意：
*
*
* 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
* 如果 s 中存在这样的子串，我们保证它是唯一的答案。
*
*
*
*
* 示例 1：
*
*
* 输入：s = "ADOBECODEBANC", t = "ABC"
* 输出："BANC"
*
*
* 示例 2：
*
*
* 输入：s = "a", t = "a"
* 输出："a"
*
*
* 示例 3:
*
*
* 输入: s = "a", t = "aa"
* 输出: ""
* 解释: t 中两个字符 'a' 均应包含在 s 的子串中，
* 因此没有符合条件的子字符串，返回空字符串。
*
*
*
* 提示：
*
*
* 1
* s 和 t 由英文字母组成
*
*
*
* 进阶：你能设计一个在 o(n) 时间内解决此问题的算法吗？
*/.
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author