directory
0.0.0-20240920062246-d0657495930a
Repository: https://github.com/yigmmk/leetcode.git
Documentation: pkg.go.dev
# Packages
* @lc app=leetcode.cn id=1004 lang=golang
*
* [1004] 最大连续1的个数 III
*
* https://leetcode.cn/problems/max-consecutive-ones-iii/description/
*
* algorithms
* Medium (59.30%)
* Likes: 639
* Dislikes: 0
* Total Accepted: 139.3K
* Total Submissions: 234.9K
* Testcase Example: '[1,1,1,0,0,0,1,1,1,1,0]\n2'
*
* 给定一个二进制数组 nums 和一个整数 k，如果可以翻转最多 k 个 0 ，则返回 数组中连续 1 的最大个数 。
*
*
*
* 示例 1：
*
*
* 输入：nums = [1,1,1,0,0,0,1,1,1,1,0], K = 2
* 输出：6
* 解释：[1,1,1,0,0,1,1,1,1,1,1]
* 粗体数字从 0 翻转到 1，最长的子数组长度为 6。
*
* 示例 2：
*
*
* 输入：nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
* 输出：10
* 解释：[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
* 粗体数字从 0 翻转到 1，最长的子数组长度为 10。
*
*
*
* 提示：
*
*
* 1 <= nums.length <= 10^5
* nums[i] 不是 0 就是 1
* 0 <= k <= nums.length
*
*
*/.
No description provided by the author
* @lc app=leetcode.cn id=1071 lang=golang
*
* [1071] 字符串的最大公因子
*
* https://leetcode.cn/problems/greatest-common-divisor-of-strings/description/
*
* algorithms
* Easy (57.78%)
* Likes: 353
* Dislikes: 0
* Total Accepted: 62.4K
* Total Submissions: 108K
* Testcase Example: '"ABCABC"\n"ABC"'
*
* 对于字符串 s 和 t，只有在 s = t + ..
* @lc app=leetcode.cn id=11 lang=golang
*
* [11] 盛最多水的容器
*
* https://leetcode.cn/problems/container-with-most-water/description/
*
* algorithms
* Medium (60.08%)
* Likes: 4599
* Dislikes: 0
* Total Accepted: 1.1M
* Total Submissions: 1.8M
* Testcase Example: '[1,8,6,2,5,4,8,3,7]'
*
* 给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
*
* 找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
*
* 返回容器可以储存的最大水量。
*
* 说明：你不能倾斜容器。
*
*
*
* 示例 1：
*
*
*
*
* 输入：[1,8,6,2,5,4,8,3,7]
* 输出：49
* 解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
*
* 示例 2：
*
*
* 输入：height = [1,1]
* 输出：1
*
*
*
*
* 提示：
*
*
* n == height.length
* 2 <= n <= 10^5
* 0 <= height[i] <= 10^4
*
*
*/.
* @lc app=leetcode.cn id=1207 lang=golang
*
* [1207] 独一无二的出现次数
*
* https://leetcode.cn/problems/unique-number-of-occurrences/description/
*
* algorithms
* Easy (72.96%)
* Likes: 207
* Dislikes: 0
* Total Accepted: 93.2K
* Total Submissions: 127.7K
* Testcase Example: '[1,2,2,1,1,3]'
*
* 给你一个整数数组 arr，请你帮忙统计数组中每个数的出现次数。
*
* 如果每个数的出现次数都是独一无二的，就返回 true；否则返回 false。
*
*
*
* 示例 1：
*
* 输入：arr = [1,2,2,1,1,3]
* 输出：true
* 解释：在该数组中，1 出现了 3 次，2 出现了 2 次，3 只出现了 1 次。没有两个数的出现次数相同。
*
* 示例 2：
*
* 输入：arr = [1,2]
* 输出：false
*
*
* 示例 3：
*
* 输入：arr = [-3,0,1,-3,1,1,1,-3,10,0]
* 输出：true
*
*
*
*
* 提示：
*
*
* 1 <= arr.length <= 1000
* -1000 <= arr[i] <= 1000
*
*
*/.
* @lc app=leetcode.cn id=1431 lang=golang
*
* [1431] 拥有最多糖果的孩子
*
* https://leetcode.cn/problems/kids-with-the-greatest-number-of-candies/description/
*
* algorithms
* Easy (84.56%)
* Likes: 173
* Dislikes: 0
* Total Accepted: 107.2K
* Total Submissions: 126.8K
* Testcase Example: '[2,3,5,1,3]\n3'
*
* 给你一个数组 candies 和一个整数 extraCandies ，其中 candies[i] 代表第 i 个孩子拥有的糖果数目。
*
* 对每一个孩子，检查是否存在一种方案，将额外的 extraCandies 个糖果分配给孩子们之后，此孩子有 最多 的糖果。注意，允许有多个孩子同时拥有
* 最多 的糖果数目。
*
*
*
* 示例 1：
*
* 输入：candies = [2,3,5,1,3], extraCandies = 3
* 输出：[true,true,true,false,true]
* 解释：
* 孩子 1 有 2 个糖果，如果他得到所有额外的糖果（3个），那么他总共有 5 个糖果，他将成为拥有最多糖果的孩子。
* 孩子 2 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。
* 孩子 3 有 5 个糖果，他已经是拥有最多糖果的孩子。
* 孩子 4 有 1 个糖果，即使他得到所有额外的糖果，他也只有 4 个糖果，无法成为拥有糖果最多的孩子。
* 孩子 5 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。
*
*
* 示例 2：
*
* 输入：candies = [4,2,1,1,2], extraCandies = 1
* 输出：[true,false,false,false,false]
* 解释：只有 1 个额外糖果，所以不管额外糖果给谁，只有孩子 1 可以成为拥有糖果最多的孩子。
*
*
* 示例 3：
*
* 输入：candies = [12,1,12], extraCandies = 10
* 输出：[true,false,true]
*
*
*
*
* 提示：
*
*
* 2 <= candies.length <= 100
* 1 <= candies[i] <= 100
* 1 <= extraCandies <= 50
*
*
*/.
* @lc app=leetcode.cn id=1448 lang=golang
*
* [1448] 统计二叉树中好节点的数目
*
* https://leetcode.cn/problems/count-good-nodes-in-binary-tree/description/
*
* algorithms
* Medium (73.91%)
* Likes: 150
* Dislikes: 0
* Total Accepted: 47.9K
* Total Submissions: 64.8K
* Testcase Example: '[3,1,4,3,null,1,5]'
*
* 给你一棵根为 root 的二叉树，请你返回二叉树中好节点的数目。
*
* 「好节点」X 定义为：从根到该节点 X 所经过的节点中，没有任何节点的值大于 X 的值。
*
*
*
* 示例 1：
*
*
*
* 输入：root = [3,1,4,3,null,1,5]
* 输出：4
* 解释：图中蓝色节点为好节点。
* 根节点 (3) 永远是个好节点。
* 节点 4 -> (3,4) 是路径中的最大值。
* 节点 5 -> (3,4,5) 是路径中的最大值。
* 节点 3 -> (3,1,3) 是路径中的最大值。
*
* 示例 2：
*
*
*
* 输入：root = [3,3,null,4,2]
* 输出：3
* 解释：节点 2 -> (3, 3, 2) 不是好节点，因为 "3" 比它大。
*
* 示例 3：
*
* 输入：root = [1]
* 输出：1
* 解释：根节点是好节点。
*
*
*
* 提示：
*
*
* 二叉树中节点数目范围是 [1, 10^5] 。
* 每个节点权值的范围是 [-10^4, 10^4] 。
*
*
*/.
* @lc app=leetcode.cn id=1456 lang=golang
*
* [1456] 定长子串中元音的最大数目
*
* https://leetcode.cn/problems/maximum-number-of-vowels-in-a-substring-of-given-length/description/
*
* algorithms
* Medium (55.89%)
* Likes: 80
* Dislikes: 0
* Total Accepted: 38.3K
* Total Submissions: 68.4K
* Testcase Example: '"abciiidef"\n3'
*
* 给你字符串 s 和整数 k 。
*
* 请返回字符串 s 中长度为 k 的单个子字符串中可能包含的最大元音字母数。
*
* 英文中的 元音字母 为（a, e, i, o, u）。
*
*
*
* 示例 1：
*
* 输入：s = "abciiidef", k = 3
* 输出：3
* 解释：子字符串 "iii" 包含 3 个元音字母。
*
*
* 示例 2：
*
* 输入：s = "aeiou", k = 2
* 输出：2
* 解释：任意长度为 2 的子字符串都包含 2 个元音字母。
*
*
* 示例 3：
*
* 输入：s = "leetcode", k = 3
* 输出：2
* 解释："lee"、"eet" 和 "ode" 都包含 2 个元音字母。
*
*
* 示例 4：
*
* 输入：s = "rhythms", k = 4
* 输出：0
* 解释：字符串 s 中不含任何元音字母。
*
*
* 示例 5：
*
* 输入：s = "tryhard", k = 4
* 输出：1
*
*
*
*
* 提示：
*
*
* 1 <= s.length <= 10^5
* s 由小写英文字母组成
* 1 <= k <= s.length
*
*
*/.
No description provided by the author
* @lc app=leetcode.cn id=1657 lang=golang
*
* [1657] 确定两个字符串是否接近
*
* https://leetcode.cn/problems/determine-if-two-strings-are-close/description/
*
* algorithms
* Medium (47.66%)
* Likes: 73
* Dislikes: 0
* Total Accepted: 17.8K
* Total Submissions: 37.3K
* Testcase Example: '"abc"\n"bca"'
*
* 如果可以使用以下操作从一个字符串得到另一个字符串，则认为两个字符串 接近 ：
*
*
* 操作 1：交换任意两个 现有 字符。
*
*
* 例如，abcde -> aecdb
*
*
* 操作 2：将一个 现有 字符的每次出现转换为另一个 现有 字符，并对另一个字符执行相同的操作。
*
* 例如，aacabb -> bbcbaa（所有 a 转化为 b ，而所有的 b 转换为 a ）
*
*
*
*
* 你可以根据需要对任意一个字符串多次使用这两种操作。
*
* 给你两个字符串，word1 和 word2 。如果 word1 和 word2 接近 ，就返回 true ；否则，返回 false 。
*
*
*
* 示例 1：
*
*
* 输入：word1 = "abc", word2 = "bca"
* 输出：true
* 解释：2 次操作从 word1 获得 word2 。
* 执行操作 1："abc" -> "acb"
* 执行操作 1："acb" -> "bca"
*
*
* 示例 2：
*
*
* 输入：word1 = "a", word2 = "aa"
* 输出：false
* 解释：不管执行多少次操作，都无法从 word1 得到 word2 ，反之亦然。
*
* 示例 3：
*
*
* 输入：word1 = "cabbba", word2 = "abbccc"
* 输出：true
* 解释：3 次操作从 word1 获得 word2 。
* 执行操作 1："cabbba" -> "caabbb"
* 执行操作 2："caabbb" -> "baaccc"
* 执行操作 2："baaccc" -> "abbccc"
*
*
* 示例 4：
*
*
* 输入：word1 = "cabbba", word2 = "aabbss"
* 输出：false
* 解释：不管执行多少次操作，都无法从 word1 得到 word2 ，反之亦然。
*
*
*
* 提示：
*
*
* 1
* word1 和 word2 仅包含小写英文字母
*
*
*/.
* @lc app=leetcode.cn id=1679 lang=golang
*
* [1679] K 和数对的最大数目
*
* https://leetcode.cn/problems/max-number-of-k-sum-pairs/description/
*
* algorithms
* Medium (55.60%)
* Likes: 64
* Dislikes: 0
* Total Accepted: 23.4K
* Total Submissions: 42K
* Testcase Example: '[1,2,3,4]\n5'
*
* 给你一个整数数组 nums 和一个整数 k 。
*
* 每一步操作中，你需要从数组中选出和为 k 的两个整数，并将它们移出数组。
*
* 返回你可以对数组执行的最大操作数。
*
*
*
* 示例 1：
*
*
* 输入：nums = [1,2,3,4], k = 5
* 输出：2
* 解释：开始时 nums = [1,2,3,4]：
* - 移出 1 和 4 ，之后 nums = [2,3]
* - 移出 2 和 3 ，之后 nums = []
* 不再有和为 5 的数对，因此最多执行 2 次操作。
*
* 示例 2：
*
*
* 输入：nums = [3,1,3,4,3], k = 6
* 输出：1
* 解释：开始时 nums = [3,1,3,4,3]：
* - 移出前两个 3 ，之后nums = [1,4,3]
* 不再有和为 6 的数对，因此最多执行 1 次操作。
*
*
*
* 提示：
*
*
* 1
* 1
* 1
*
*
*/.
* @lc app=leetcode.cn id=1732 lang=golang
*
* [1732] 找到最高海拔
*
* https://leetcode.cn/problems/find-the-highest-altitude/description/
*
* algorithms
* Easy (81.35%)
* Likes: 90
* Dislikes: 0
* Total Accepted: 55.9K
* Total Submissions: 68.7K
* Testcase Example: '[-5,1,5,0,-7]'
*
* 有一个自行车手打算进行一场公路骑行，这条路线总共由 n + 1 个不同海拔的点组成。自行车手从海拔为 0 的点 0 开始骑行。
*
* 给你一个长度为 n 的整数数组 gain ，其中 gain[i] 是点 i 和点 i + 1 的 净海拔高度差（0 ）。请你返回 最高点的海拔
* 。
*
*
*
* 示例 1：
*
*
* 输入：gain = [-5,1,5,0,-7]
* 输出：1
* 解释：海拔高度依次为 [0,-5,-4,1,1,-6] 。最高海拔为 1 。
*
*
* 示例 2：
*
*
* 输入：gain = [-4,-3,-2,-1,4,3,2]
* 输出：0
* 解释：海拔高度依次为 [0,-4,-7,-9,-10,-6,-3,-1] 。最高海拔为 0 。
*
*
*
*
* 提示：
*
*
* n == gain.length
* 1
* -100
*
*
*/.
* @lc app=leetcode.cn id=1814 lang=golang
*
* [1814] 统计一个数组中好对子的数目
*
* https://leetcode.cn/problems/count-nice-pairs-in-an-array/description/
*
* algorithms
* Medium (36.99%)
* Likes: 91
* Dislikes: 0
* Total Accepted: 20.8K
* Total Submissions: 45.3K
* Testcase Example: '[42,11,1,97]'
*
* 给你一个数组 nums ，数组中只包含非负整数。定义 rev(x) 的值为将整数 x 各个数字位反转得到的结果。比方说 rev(123) = 321 ，
* rev(120) = 21 。我们称满足下面条件的下标对 (i, j) 是 好的 ：
*
*
* 0 <= i < j < nums.length
* nums[i] + rev(nums[j]) == nums[j] + rev(nums[i])
*
*
* 请你返回好下标对的数目。由于结果可能会很大，请将结果对 10^9 + 7 取余 后返回。
*
*
*
* 示例 1：
*
* 输入：nums = [42,11,1,97]
* 输出：2
* 解释：两个坐标对为：
* - (0,3)：42 + rev(97) = 42 + 79 = 121, 97 + rev(42) = 97 + 24 = 121 。
* - (1,2)：11 + rev(1) = 11 + 1 = 12, 1 + rev(11) = 1 + 11 = 12 。
*
*
* 示例 2：
*
* 输入：nums = [13,10,35,24,76]
* 输出：4
*
*
*
*
* 提示：
*
*
* 1 <= nums.length <= 10^5
* 0 <= nums[i] <= 10^9
*
*
*/.
* @lc app=leetcode.cn id=21 lang=golang
*
* [21] 合并两个有序链表
*
* https://leetcode.cn/problems/merge-two-sorted-lists/description/
*
* algorithms
* Easy (66.53%)
* Likes: 2898
* Dislikes: 0
* Total Accepted: 1.3M
* Total Submissions: 1.9M
* Testcase Example: '[1,2,4]\n[1,3,4]'
*
* 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
*
*
*
* 示例 1：
*
*
* 输入：l1 = [1,2,4], l2 = [1,3,4]
* 输出：[1,1,2,3,4,4]
*
*
* 示例 2：
*
*
* 输入：l1 = [], l2 = []
* 输出：[]
*
*
* 示例 3：
*
*
* 输入：l1 = [], l2 = [0]
* 输出：[0]
*
*
*
*
* 提示：
*
*
* 两个链表的节点数目范围是 [0, 50]
* -100
* l1 和 l2 均按 非递减顺序 排列
*
*
*/.
* @lc app=leetcode.cn id=2215 lang=golang
*
* [2215] 找出两数组的不同
*
* https://leetcode.cn/problems/find-the-difference-of-two-arrays/description/
*
* algorithms
* Easy (68.69%)
* Likes: 36
* Dislikes: 0
* Total Accepted: 25.1K
* Total Submissions: 36.5K
* Testcase Example: '[1,2,3]\n[2,4,6]'
*
* 给你两个下标从 0 开始的整数数组 nums1 和 nums2 ，请你返回一个长度为 2 的列表 answer ，其中：
*
*
* answer[0] 是 nums1 中所有 不 存在于 nums2 中的 不同 整数组成的列表。
* answer[1] 是 nums2 中所有 不 存在于 nums1 中的 不同 整数组成的列表。
*
*
* 注意：列表中的整数可以按 任意 顺序返回。
*
*
*
* 示例 1：
*
*
* 输入：nums1 = [1,2,3], nums2 = [2,4,6]
* 输出：[[1,3],[4,6]]
* 解释：
* 对于 nums1 ，nums1[1] = 2 出现在 nums2 中下标 0 处，然而 nums1[0] = 1 和 nums1[2] = 3
* 没有出现在 nums2 中。因此，answer[0] = [1,3]。
* 对于 nums2 ，nums2[0] = 2 出现在 nums1 中下标 1 处，然而 nums2[1] = 4 和 nums2[2] = 6
* 没有出现在 nums2 中。因此，answer[1] = [4,6]。
*
* 示例 2：
*
*
* 输入：nums1 = [1,2,3,3], nums2 = [1,1,2,2]
* 输出：[[3],[]]
* 解释：
* 对于 nums1 ，nums1[2] 和 nums1[3] 没有出现在 nums2 中。由于 nums1[2] == nums1[3]
* ，二者的值只需要在 answer[0] 中出现一次，故 answer[0] = [3]。
* nums2 中的每个整数都在 nums1 中出现，因此，answer[1] = [] 。
*
*
*
*
* 提示：
*
*
* 1 <= nums1.length, nums2.length <= 1000
* -1000 <= nums1[i], nums2[i] <= 1000
*
*
*/.
No description provided by the author
* @lc app=leetcode.cn id=2352 lang=golang
*
* [2352] 相等行列对
*
* https://leetcode.cn/problems/equal-row-and-column-pairs/description/
*
* algorithms
* Medium (73.35%)
* Likes: 84
* Dislikes: 0
* Total Accepted: 39.7K
* Total Submissions: 54.2K
* Testcase Example: '[[3,2,1],[1,7,6],[2,7,7]]'
*
* 给你一个下标从 0 开始、大小为 n x n 的整数矩阵 grid ，返回满足 Ri 行和 Cj 列相等的行列对 (Ri, Cj) 的数目。
*
* 如果行和列以相同的顺序包含相同的元素（即相等的数组），则认为二者是相等的。
*
*
*
* 示例 1：
*
*
*
*
* 输入：grid = [[3,2,1],[1,7,6],[2,7,7]]
* 输出：1
* 解释：存在一对相等行列对：
* - (第 2 行，第 1 列)：[2,7,7]
*
*
* 示例 2：
*
*
*
*
* 输入：grid = [[3,1,2,2],[1,4,4,5],[2,4,2,2],[2,4,2,2]]
* 输出：3
* 解释：存在三对相等行列对：
* - (第 0 行，第 0 列)：[3,1,2,2]
* - (第 2 行, 第 2 列)：[2,4,2,2]
* - (第 3 行, 第 2 列)：[2,4,2,2]
*
*
*
*
* 提示：
*
*
* n == grid.length == grid[i].length
* 1 <= n <= 200
* 1 <= grid[i][j] <= 10^5
*
*
*/.
* @lc app=leetcode.cn id=238 lang=golang
*
* [238] 除自身以外数组的乘积
*
* https://leetcode.cn/problems/product-of-array-except-self/description/
*
* algorithms
* Medium (74.83%)
* Likes: 1585
* Dislikes: 0
* Total Accepted: 313.6K
* Total Submissions: 419.1K
* Testcase Example: '[1,2,3,4]'
*
* 给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。
*
* 题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。
*
* 请不要使用除法，且在 O(n) 时间复杂度内完成此题。
*
*
*
* 示例 1:
*
*
* 输入: nums = [1,2,3,4]
* 输出: [24,12,8,6]
*
*
* 示例 2:
*
*
* 输入: nums = [-1,1,0,-3,3]
* 输出: [0,0,9,0,0]
*
*
*
*
* 提示：
*
*
* 2 <= nums.length <= 10^5
* -30 <= nums[i] <= 30
* 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内
*
*
*
*
* 进阶：你可以在 O(1) 的额外空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组不被视为额外空间。）
*
*/.
* @lc app=leetcode.cn id=2390 lang=golang
*
* [2390] 从字符串中移除星号
*
* https://leetcode.cn/problems/removing-stars-from-a-string/description/
*
* algorithms
* Medium (70.83%)
* Likes: 32
* Dislikes: 0
* Total Accepted: 23.2K
* Total Submissions: 32.7K
* Testcase Example: '"leet**cod*e"'
*
* 给你一个包含若干星号 * 的字符串 s 。
*
* 在一步操作中，你可以：
*
*
* 选中 s 中的一个星号。
* 移除星号 左侧 最近的那个 非星号 字符，并移除该星号自身。
*
*
* 返回移除 所有 星号之后的字符串。
*
* 注意：
*
*
* 生成的输入保证总是可以执行题面中描述的操作。
* 可以证明结果字符串是唯一的。
*
*
*
*
* 示例 1：
*
*
* 输入：s = "leet**cod*e"
* 输出："lecoe"
* 解释：从左到右执行移除操作：
* - 距离第 1 个星号最近的字符是 "leet**cod*e" 中的 't' ，s 变为 "lee*cod*e" 。
* - 距离第 2 个星号最近的字符是 "lee*cod*e" 中的 'e' ，s 变为 "lecod*e" 。
* - 距离第 3 个星号最近的字符是 "lecod*e" 中的 'd' ，s 变为 "lecoe" 。
* 不存在其他星号，返回 "lecoe" 。
*
* 示例 2：
*
*
* 输入：s = "erase*****"
* 输出：""
* 解释：整个字符串都会被移除，所以返回空字符串。
*
*
*
*
* 提示：
*
*
* 1 <= s.length <= 10^5
* s 由小写英文字母和星号 * 组成
* s 可以执行上述操作
*
*
*/.
* @lc app=leetcode.cn id=283 lang=golang
*
* [283] 移动零
*
* https://leetcode.cn/problems/move-zeroes/description/
*
* algorithms
* Easy (63.65%)
* Likes: 2181
* Dislikes: 0
* Total Accepted: 1.2M
* Total Submissions: 1.8M
* Testcase Example: '[0,1,0,3,12]'
*
* 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
*
* 请注意 ，必须在不复制数组的情况下原地对数组进行操作。
*
*
*
* 示例 1:
*
*
* 输入: nums = [0,1,0,3,12]
* 输出: [1,3,12,0,0]
*
*
* 示例 2:
*
*
* 输入: nums = [0]
* 输出: [0]
*
*
*
* 提示:
*
*
*
* 1 <= nums.length <= 10^4
* -2^31 <= nums[i] <= 2^31 - 1
*
*
*
*
* 进阶：你能尽量减少完成的操作次数吗？
*
*/.
* @lc app=leetcode.cn id=334 lang=golang
*
* [334] 递增的三元子序列
*
* https://leetcode.cn/problems/increasing-triplet-subsequence/description/
*
* algorithms
* Medium (42.83%)
* Likes: 764
* Dislikes: 0
* Total Accepted: 136.7K
* Total Submissions: 319.3K
* Testcase Example: '[1,2,3,4,5]'
*
* 给你一个整数数组 nums ，判断这个数组中是否存在长度为 3 的递增子序列。
*
* 如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ，使得 nums[i] < nums[j] < nums[k] ，返回
* true ；否则，返回 false 。
*
*
*
* 示例 1：
*
*
* 输入：nums = [1,2,3,4,5]
* 输出：true
* 解释：任何 i < j < k 的三元组都满足题意
*
*
* 示例 2：
*
*
* 输入：nums = [5,4,3,2,1]
* 输出：false
* 解释：不存在满足题意的三元组
*
* 示例 3：
*
*
* 输入：nums = [2,1,5,0,4,6]
* 输出：true
* 解释：三元组 (3, 4, 5) 满足题意，因为 nums[3] == 0 < nums[4] == 4 < nums[5] == 6
*
*
*
*
* 提示：
*
*
* 1 <= nums.length <= 5 * 10^5
* -2^31 <= nums[i] <= 2^31 - 1
*
*
*
*
* 进阶：你能实现时间复杂度为 O(n) ，空间复杂度为 O(1) 的解决方案吗？
*
*/.
* @lc app=leetcode.cn id=345 lang=golang
*
* [345] 反转字符串中的元音字母
*
* https://leetcode.cn/problems/reverse-vowels-of-a-string/description/
*
* algorithms
* Easy (54.53%)
* Likes: 326
* Dislikes: 0
* Total Accepted: 177.4K
* Total Submissions: 325.4K
* Testcase Example: '"hello"'
*
* 给你一个字符串 s ，仅反转字符串中的所有元音字母，并返回结果字符串。
*
* 元音字母包括 'a'、'e'、'i'、'o'、'u'，且可能以大小写两种形式出现不止一次。
*
*
*
* 示例 1：
*
*
* 输入：s = "hello"
* 输出："holle"
*
*
* 示例 2：
*
*
* 输入：s = "leetcode"
* 输出："leotcede"
*
*
*
* 提示：
*
*
* 1 <= s.length <= 3 * 10^5
* s 由 可打印的 ASCII 字符组成
*
*
*/.
* @lc app=leetcode.cn id=392 lang=golang
*
* [392] 判断子序列
*
* https://leetcode.cn/problems/is-subsequence/description/
*
* algorithms
* Easy (52.37%)
* Likes: 943
* Dislikes: 0
* Total Accepted: 341.7K
* Total Submissions: 652.6K
* Testcase Example: '"abc"\n"ahbgdc"'
*
* 给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
*
*
* 字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
*
* 进阶：
*
* 如果有大量输入的 S，称作 S1, S2, ..
* @lc app=leetcode.cn id=394 lang=golang
*
* [394] 字符串解码
*
* https://leetcode.cn/problems/decode-string/description/
*
* algorithms
* Medium (56.91%)
* Likes: 1625
* Dislikes: 0
* Total Accepted: 270.6K
* Total Submissions: 475.2K
* Testcase Example: '"3[a]2[bc]"'
*
* 给定一个经过编码的字符串，返回它解码后的字符串。
*
* 编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。
*
* 你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。
*
* 此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。
*
*
*
* 示例 1：
*
*
* 输入：s = "3[a]2[bc]"
* 输出："aaabcbc"
*
*
* 示例 2：
*
*
* 输入：s = "3[a2[c]]"
* 输出："accaccacc"
*
*
* 示例 3：
*
*
* 输入：s = "2[abc]3[cd]ef"
* 输出："abcabccdcdcdef"
*
*
* 示例 4：
*
*
* 输入：s = "abc3[cd]xyz"
* 输出："abccdcdcdxyz"
*
*
*
*
* 提示：
*
*
* 1 <= s.length <= 30
* s 由小写英文字母、数字和方括号 '[]' 组成
* s 保证是一个 有效 的输入。
* s 中所有整数的取值范围为 [1, 300]
*
*
*/.
* @lc app=leetcode.cn id=443 lang=golang
*
* [443] 压缩字符串
*
* https://leetcode.cn/problems/string-compression/description/
*
* algorithms
* Medium (48.06%)
* Likes: 377
* Dislikes: 0
* Total Accepted: 90.7K
* Total Submissions: 188.6K
* Testcase Example: '["a","a","b","b","c","c","c"]'
*
* 给你一个字符数组 chars ，请使用下述算法压缩：
*
* 从一个空字符串 s 开始。对于 chars 中的每组 连续重复字符 ：
*
*
* 如果这一组长度为 1 ，则将字符追加到 s 中。
* 否则，需要向 s 追加字符，后跟这一组的长度。
*
*
* 压缩后得到的字符串 s 不应该直接返回 ，需要转储到字符数组 chars 中。需要注意的是，如果组长度为 10 或 10 以上，则在 chars
* 数组中会被拆分为多个字符。
*
* 请在 修改完输入数组后 ，返回该数组的新长度。
*
* 你必须设计并实现一个只使用常量额外空间的算法来解决此问题。
*
*
*
* 示例 1：
*
*
* 输入：chars = ["a","a","b","b","c","c","c"]
* 输出：返回 6 ，输入数组的前 6 个字符应该是：["a","2","b","2","c","3"]
* 解释："aa" 被 "a2" 替代。"bb" 被 "b2" 替代。"ccc" 被 "c3" 替代。
*
*
* 示例 2：
*
*
* 输入：chars = ["a"]
* 输出：返回 1 ，输入数组的前 1 个字符应该是：["a"]
* 解释：唯一的组是“a”，它保持未压缩，因为它是一个字符。
*
*
* 示例 3：
*
*
* 输入：chars = ["a","b","b","b","b","b","b","b","b","b","b","b","b"]
* 输出：返回 4 ，输入数组的前 4 个字符应该是：["a","b","1","2"]。
* 解释：由于字符 "a" 不重复，所以不会被压缩。"bbbbbbbbbbbb" 被 “b12” 替代。
*
*
*
*
* 提示：
*
*
* 1 <= chars.length <= 2000
* chars[i] 可以是小写英文字母、大写英文字母、数字或符号
*
*
*/.
No description provided by the author
* @lc app=leetcode.cn id=605 lang=golang
*
* [605] 种花问题
*
* https://leetcode.cn/problems/can-place-flowers/description/
*
* algorithms
* Easy (32.03%)
* Likes: 625
* Dislikes: 0
* Total Accepted: 186.9K
* Total Submissions: 583.9K
* Testcase Example: '[1,0,0,0,1]\n1'
*
* 假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。
*
* 给你一个整数数组 flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花，1 表示种植了花。另有一个数 n
* ，能否在不打破种植规则的情况下种入 n 朵花？能则返回 true ，不能则返回 false 。
*
*
*
* 示例 1：
*
*
* 输入：flowerbed = [1,0,0,0,1], n = 1
* 输出：true
*
*
* 示例 2：
*
*
* 输入：flowerbed = [1,0,0,0,1], n = 2
* 输出：false
*
*
*
*
* 提示：
*
*
* 1 <= flowerbed.length <= 2 * 10^4
* flowerbed[i] 为 0 或 1
* flowerbed 中不存在相邻的两朵花
* 0 <= n <= flowerbed.length
*
*/.
* @lc app=leetcode.cn id=643 lang=golang
*
* [643] 子数组最大平均数 I
*
* https://leetcode.cn/problems/maximum-average-subarray-i/description/
*
* algorithms
* Easy (43.14%)
* Likes: 324
* Dislikes: 0
* Total Accepted: 119.9K
* Total Submissions: 277.9K
* Testcase Example: '[1,12,-5,-6,50,3]\n4'
*
* 给你一个由 n 个元素组成的整数数组 nums 和一个整数 k 。
*
* 请你找出平均数最大且 长度为 k 的连续子数组，并输出该最大平均数。
*
* 任何误差小于 10^-5 的答案都将被视为正确答案。
*
*
*
* 示例 1：
*
*
* 输入：nums = [1,12,-5,-6,50,3], k = 4
* 输出：12.75
* 解释：最大平均数 (12-5-6+50)/4 = 51/4 = 12.75
*
*
* 示例 2：
*
*
* 输入：nums = [5], k = 1
* 输出：5.00000
*
*
*
*
* 提示：
*
*
* n == nums.length
* 1 <= k <= n <= 10^5
* -10^4 <= nums[i] <= 10^4
*
*
*/.
* @lc app=leetcode.cn id=649 lang=golang
*
* [649] Dota2 参议院
*
* https://leetcode.cn/problems/dota2-senate/description/
*
* algorithms
* Medium (48.47%)
* Likes: 327
* Dislikes: 0
* Total Accepted: 47.6K
* Total Submissions: 98.1K
* Testcase Example: '"RD"'
*
* Dota2 的世界里有两个阵营：Radiant（天辉）和 Dire（夜魇）
*
* Dota2 参议院由来自两派的参议员组成。现在参议院希望对一个 Dota2
* 游戏里的改变作出决定。他们以一个基于轮为过程的投票进行。在每一轮中，每一位参议员都可以行使两项权利中的 一 项：
*
*
* 禁止一名参议员的权利：参议员可以让另一位参议员在这一轮和随后的几轮中丧失 所有的权利 。
* 宣布胜利：如果参议员发现有权利投票的参议员都是 同一个阵营的 ，他可以宣布胜利并决定在游戏中的有关变化。
*
*
* 给你一个字符串 senate 代表每个参议员的阵营。字母 'R' 和 'D'分别代表了 Radiant（天辉）和 Dire（夜魇）。然后，如果有 n
* 个参议员，给定字符串的大小将是 n。
*
* 以轮为基础的过程从给定顺序的第一个参议员开始到最后一个参议员结束。这一过程将持续到投票结束。所有失去权利的参议员将在过程中被跳过。
*
* 假设每一位参议员都足够聪明，会为自己的政党做出最好的策略，你需要预测哪一方最终会宣布胜利并在 Dota2 游戏中决定改变。输出应该是 "Radiant"
* 或 "Dire" 。
*
*
*
* 示例 1：
*
*
* 输入：senate = "RD"
* 输出："Radiant"
* 解释：
* 第 1 轮时，第一个参议员来自 Radiant 阵营，他可以使用第一项权利让第二个参议员失去所有权利。
* 这一轮中，第二个参议员将会被跳过，因为他的权利被禁止了。
* 第 2 轮时，第一个参议员可以宣布胜利，因为他是唯一一个有投票权的人。
*
*
* 示例 2：
*
*
* 输入：senate = "RDD"
* 输出："Dire"
* 解释：
* 第 1 轮时，第一个来自 Radiant 阵营的参议员可以使用第一项权利禁止第二个参议员的权利。
* 这一轮中，第二个来自 Dire 阵营的参议员会将被跳过，因为他的权利被禁止了。
* 这一轮中，第三个来自 Dire 阵营的参议员可以使用他的第一项权利禁止第一个参议员的权利。
* 因此在第二轮只剩下第三个参议员拥有投票的权利,于是他可以宣布胜利
*
*
*
*
* 提示：
*
*
* n == senate.length
* 1 <= n <= 10^4
* senate[i] 为 'R' 或 'D'
*
*
*/.
* @lc app=leetcode.cn id=724 lang=golang
*
* [724] 寻找数组的中心下标
*
* https://leetcode.cn/problems/find-pivot-index/description/
*
* algorithms
* Easy (52.06%)
* Likes: 589
* Dislikes: 0
* Total Accepted: 315.7K
* Total Submissions: 606K
* 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=735 lang=golang
*
* [735] 小行星碰撞
*
* https://leetcode.cn/problems/asteroid-collision/description/
*
* algorithms
* Medium (42.50%)
* Likes: 452
* Dislikes: 0
* Total Accepted: 84K
* Total Submissions: 197.8K
* Testcase Example: '[5,10,-5]'
*
* 给定一个整数数组 asteroids，表示在同一行的小行星。
*
* 对于数组中的每一个元素，其绝对值表示小行星的大小，正负表示小行星的移动方向（正表示向右移动，负表示向左移动）。每一颗小行星以相同的速度移动。
*
*
* 找出碰撞后剩下的所有小行星。碰撞规则：两个小行星相互碰撞，较小的小行星会爆炸。如果两颗小行星大小相同，则两颗小行星都会爆炸。两颗移动方向相同的小行星，永远不会发生碰撞。
*
*
*
* 示例 1：
*
*
* 输入：asteroids = [5,10,-5]
* 输出：[5,10]
* 解释：10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。
*
* 示例 2：
*
*
* 输入：asteroids = [8,-8]
* 输出：[]
* 解释：8 和 -8 碰撞后，两者都发生爆炸。
*
* 示例 3：
*
*
* 输入：asteroids = [10,2,-5]
* 输出：[10]
* 解释：2 和 -5 发生碰撞后剩下 -5 。10 和 -5 发生碰撞后剩下 10 。
*
*
*
* 提示：
*
*
* 2 <= asteroids.length <= 10^4
* -1000 <= asteroids[i] <= 1000
* asteroids[i] != 0
*
*
*/.
* @lc app=leetcode.cn id=77 lang=golang
*
* [77] 组合
*
* https://leetcode.cn/problems/combinations/description/
*
* algorithms
* Medium (77.31%)
* Likes: 1276
* Dislikes: 0
* Total Accepted: 479.3K
* Total Submissions: 620K
* Testcase Example: '4\n2'
*
* 给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
*
* 你可以按 任何顺序 返回答案。
*
*
*
* 示例 1：
*
*
* 输入：n = 4, k = 2
* 输出：
* [
* [2,4],
* [3,4],
* [2,3],
* [1,2],
* [1,3],
* [1,4],
* ]
*
* 示例 2：
*
*
* 输入：n = 1, k = 1
* 输出：[[1]]
*
*
*
* 提示：
*
*
* 1
* 1
*
*
*/.
* @lc app=leetcode.cn id=872 lang=golang
*
* [872] 叶子相似的树
*
* https://leetcode.cn/problems/leaf-similar-trees/description/
*
- algorithms
- Easy (65.01%)
- Likes: 224
- Dislikes: 0
- Total Accepted: 81.6K
- Total Submissions: 125.4K
- Testcase Example: '[3,5,1,6,2,9,8,null,null,7,4]\n' +
'[3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]'
*
* 请考虑一棵二叉树上所有的叶子，这些叶子的值按从左到右的顺序排列形成一个 叶值序列 。
*
*
*
* 举个例子，如上图所示，给定一棵叶值序列为 (6, 7, 4, 9, 8) 的树。
*
* 如果有两棵二叉树的叶值序列是相同，那么我们就认为它们是 叶相似 的。
*
* 如果给定的两个根结点分别为 root1 和 root2 的树是叶相似的，则返回 true；否则返回 false 。
*
*
*
* 示例 1：
*
*
*
*
* 输入：root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 =
* [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]
* 输出：true
*
*
* 示例 2：
*
*
*
*
* 输入：root1 = [1,2,3], root2 = [1,3,2]
* 输出：false
*
*
*
*
* 提示：
*
*
* 给定的两棵树结点数在 [1, 200] 范围内
* 给定的两棵树上的值在 [0, 200] 范围内
*
*
*/.
* @lc app=leetcode.cn id=933 lang=golang
*
* [933] 最近的请求次数
*
* https://leetcode.cn/problems/number-of-recent-calls/description/
*
* algorithms
* Easy (76.80%)
* Likes: 240
* Dislikes: 0
* Total Accepted: 108.4K
* Total Submissions: 141.2K
* Testcase Example: '["RecentCounter","ping","ping","ping","ping"]\n[[],[1],[100],[3001],[3002]]'
*
* 写一个 RecentCounter 类来计算特定时间范围内最近的请求。
*
* 请你实现 RecentCounter 类：
*
*
* RecentCounter() 初始化计数器，请求数为 0 。
* int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000
* 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。
*
*
* 保证 每次对 ping 的调用都使用比之前更大的 t 值。
*
*
*
* 示例 1：
*
*
* 输入：
* ["RecentCounter", "ping", "ping", "ping", "ping"]
* [[], [1], [100], [3001], [3002]]
* 输出：
* [null, 1, 2, 3, 3]
*
* 解释：
* RecentCounter recentCounter = new RecentCounter();
* recentCounter.ping(1); // requests = [1]，范围是 [-2999,1]，返回 1
* recentCounter.ping(100); // requests = [1, 100]，范围是 [-2900,100]，返回 2
* recentCounter.ping(3001); // requests = [1, 100, 3001]，范围是 [1,3001]，返回 3
* recentCounter.ping(3002); // requests = [1, 100, 3001, 3002]，范围是
* [2,3002]，返回 3
*
*
*
*
* 提示：
*
*
* 1 <= t <= 10^9
* 保证每次对 ping 调用所使用的 t 值都 严格递增
* 至多调用 ping 方法 10^4 次
*
*
*/.
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
* @lc app=leetcode.cn id=面试题 16.25 lang=golang
* @lcpr version=30204
*
* [面试题 16.25] LRU 缓存
*/.
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