k {
+ return -1
+ }
+ }
+ orders := []int{}
+ for i := range counts {
+ orders = append(orders, i)
+ }
+ sort.Ints(orders)
+ res := math.MaxInt32
+ generatePermutation1681(nums, counts, orders, 0, 0, eachSize, &res, []int{})
+ if res == math.MaxInt32 {
+ return -1
+ }
+ return res
+}
+
+func generatePermutation1681(nums, counts, order []int, index, sum, eachSize int, res *int, current []int) {
+ if len(current) > 0 && len(current)%eachSize == 0 {
+ sum += current[len(current)-1] - current[len(current)-eachSize]
+ index = 0
+ }
+ if sum >= *res {
+ return
+ }
+ if len(current) == len(nums) {
+ if sum < *res {
+ *res = sum
+ }
+ return
+ }
+ for i := index; i < len(counts); i++ {
+ if counts[order[i]] == 0 {
+ continue
+ }
+ counts[order[i]]--
+ current = append(current, order[i])
+ generatePermutation1681(nums, counts, order, i+1, sum, eachSize, res, current)
+ current = current[:len(current)-1]
+ counts[order[i]]++
+ // 这里是关键的剪枝
+ if index == 0 {
+ break
+ }
+ }
+}
+```
+# [1684. Count the Number of Consistent Strings](https://leetcode.com/problems/count-the-number-of-consistent-strings/)
+
+
+## 题目
+
+You are given a string `allowed` consisting of **distinct** characters and an array of strings `words`. A string is **consistent** if all characters in the string appear in the string `allowed`.
+
+Return *the number of **consistent** strings in the array* `words`.
+
+**Example 1**:
+
+```
+Input: allowed = "ab", words = ["ad","bd","aaab","baa","badab"]
+Output: 2
+Explanation: Strings "aaab" and "baa" are consistent since they only contain characters 'a' and 'b'.
+
+```
+
+**Example 2**:
+
+```
+Input: allowed = "abc", words = ["a","b","c","ab","ac","bc","abc"]
+Output: 7
+Explanation: All strings are consistent.
+
+```
+
+**Example 3**:
+
+```
+Input: allowed = "cad", words = ["cc","acd","b","ba","bac","bad","ac","d"]
+Output: 4
+Explanation: Strings "cc", "acd", "ac", and "d" are consistent.
+
+```
+
+**Constraints**:
+
+- `1 <= words.length <= 104`
+- `1 <= allowed.length <= 26`
+- `1 <= words[i].length <= 10`
+- The characters in `allowed` are **distinct**.
+- `words[i]` and `allowed` contain only lowercase English letters.
+
+## 题目大意
+
+给你一个由不同字符组成的字符串 `allowed` 和一个字符串数组 `words` 。如果一个字符串的每一个字符都在 `allowed` 中，就称这个字符串是 一致字符串 。
+
+请你返回 `words` 数组中 一致字符串 的数目。
+
+## 解题思路
+
+- 简单题。先将 `allowed` 转化成 map。将 `words` 数组中每个单词的字符都在 map 中查找一遍，如果都存在就累加 res。如果有不存在的字母，不累加。最终输出 res 即可。
+
+## 代码
+
+```go
+package leetcode
+
+func countConsistentStrings(allowed string, words []string) int {
+ allowedMap, res, flag := map[rune]int{}, 0, true
+ for _, str := range allowed {
+ allowedMap[str]++
+ }
+ for i := 0; i < len(words); i++ {
+ flag = true
+ for j := 0; j < len(words[i]); j++ {
+ if _, ok := allowedMap[rune(words[i][j])]; !ok {
+ flag = false
+ break
+ }
+ }
+ if flag {
+ res++
+ }
+ }
+ return res
+}
+```
+# [1685. Sum of Absolute Differences in a Sorted Array](https://leetcode.com/problems/sum-of-absolute-differences-in-a-sorted-array/)
+
+
+## 题目
+
+You are given an integer array `nums` sorted in **non-decreasing** order.
+
+Build and return *an integer array* `result` *with the same length as* `nums` *such that* `result[i]` *is equal to the **summation of absolute differences** between* `nums[i]` *and all the other elements in the array.*
+
+In other words, `result[i]` is equal to `sum(|nums[i]-nums[j]|)` where `0 <= j < nums.length` and `j != i` (**0-indexed**).
+
+**Example 1**:
+
+```
+Input: nums = [2,3,5]
+Output: [4,3,5]
+Explanation: Assuming the arrays are 0-indexed, then
+result[0] = |2-2| + |2-3| + |2-5| = 0 + 1 + 3 = 4,
+result[1] = |3-2| + |3-3| + |3-5| = 1 + 0 + 2 = 3,
+result[2] = |5-2| + |5-3| + |5-5| = 3 + 2 + 0 = 5.
+```
+
+**Example 2**:
+
+```
+Input: nums = [1,4,6,8,10]
+Output: [24,15,13,15,21]
+```
+
+**Constraints**:
+
+- `2 <= nums.length <= 105`
+- `1 <= nums[i] <= nums[i + 1] <= 104`
+
+## 题目大意
+
+给你一个 非递减 有序整数数组 `nums` 。请你建立并返回一个整数数组 `result`，它跟 `nums` 长度相同，且`result[i]` 等于 `nums[i]` 与数组中所有其他元素差的绝对值之和。换句话说， `result[i]` 等于 `sum(|nums[i]-nums[j]|)` ，其中 `0 <= j < nums.length` 且 `j != i` （下标从 0 开始）。
+
+## 解题思路
+
+- 利用前缀和思路解题。题目中说明了是有序数组，所以在计算绝对值的时候可以拆开绝对值符号。假设要计算当前 `result[i]`，以 `i` 为界，把原数组 `nums` 分成了 3 段。`nums[0 ~ i-1]` 和 `nums[i+1 ~ n]`，前面一段 `nums[0 ~ i-1]` 中的每个元素都比 `nums[i]` 小，拆掉绝对值以后，`sum(|nums[i]-nums[j]|) = nums[i] * i - prefixSum[0 ~ i-1]`，后面一段 `nums[i+1 ~ n]` 中的每个元素都比 `nums[i]` 大，拆掉绝对值以后，`sum(|nums[i]-nums[j]|) = prefixSum[i+1 ~ n] - nums[i] * (n - 1 - i)`。特殊的情况，`i = 0` 和 `i = n` 的情况特殊处理一下就行。
+
+## 代码
+
+```go
+package leetcode
+
+//解法一 优化版 prefixSum + sufixSum
+func getSumAbsoluteDifferences(nums []int) []int {
+ size := len(nums)
+ sufixSum := make([]int, size)
+ sufixSum[size-1] = nums[size-1]
+ for i := size - 2; i >= 0; i-- {
+ sufixSum[i] = sufixSum[i+1] + nums[i]
+ }
+ ans, preSum := make([]int, size), 0
+ for i := 0; i < size; i++ {
+ // 后面可以加到的值
+ res, sum := 0, sufixSum[i]-nums[i]
+ res += (sum - (size-i-1)*nums[i])
+ // 前面可以加到的值
+ res += (i*nums[i] - preSum)
+ ans[i] = res
+ preSum += nums[i]
+ }
+ return ans
+}
+
+// 解法二 prefixSum
+func getSumAbsoluteDifferences1(nums []int) []int {
+ preSum, res, sum := []int{}, []int{}, nums[0]
+ preSum = append(preSum, nums[0])
+ for i := 1; i < len(nums); i++ {
+ sum += nums[i]
+ preSum = append(preSum, sum)
+ }
+ for i := 0; i < len(nums); i++ {
+ if i == 0 {
+ res = append(res, preSum[len(nums)-1]-preSum[0]-nums[i]*(len(nums)-1))
+ } else if i > 0 && i < len(nums)-1 {
+ res = append(res, preSum[len(nums)-1]-preSum[i]-preSum[i-1]+nums[i]*i-nums[i]*(len(nums)-1-i))
+ } else {
+ res = append(res, nums[i]*len(nums)-preSum[len(nums)-1])
+ }
+ }
+ return res
+}
+```
+# [1688. Count of Matches in Tournament](https://leetcode.com/problems/count-of-matches-in-tournament/)
+
+
+## 题目
+
+You are given an integer `n`, the number of teams in a tournament that has strange rules:
+
+- If the current number of teams is **even**, each team gets paired with another team. A total of `n / 2` matches are played, and `n / 2` teams advance to the next round.
+- If the current number of teams is **odd**, one team randomly advances in the tournament, and the rest gets paired. A total of `(n - 1) / 2` matches are played, and `(n - 1) / 2 + 1` teams advance to the next round.
+
+Return *the number of matches played in the tournament until a winner is decided.*
+
+**Example 1**:
+
+```
+Input: n = 7
+Output: 6
+Explanation: Details of the tournament:
+- 1st Round: Teams = 7, Matches = 3, and 4 teams advance.
+- 2nd Round: Teams = 4, Matches = 2, and 2 teams advance.
+- 3rd Round: Teams = 2, Matches = 1, and 1 team is declared the winner.
+Total number of matches = 3 + 2 + 1 = 6.
+```
+
+**Example 2**:
+
+```
+Input: n = 14
+Output: 13
+Explanation: Details of the tournament:
+- 1st Round: Teams = 14, Matches = 7, and 7 teams advance.
+- 2nd Round: Teams = 7, Matches = 3, and 4 teams advance.
+- 3rd Round: Teams = 4, Matches = 2, and 2 teams advance.
+- 4th Round: Teams = 2, Matches = 1, and 1 team is declared the winner.
+Total number of matches = 7 + 3 + 2 + 1 = 13.
+```
+
+**Constraints**:
+
+- `1 <= n <= 200`
+
+## 题目大意
+
+给你一个整数 n ，表示比赛中的队伍数。比赛遵循一种独特的赛制：
+
+- 如果当前队伍数是 偶数 ，那么每支队伍都会与另一支队伍配对。总共进行 n / 2 场比赛，且产生 n / 2 支队伍进入下一轮。
+- 如果当前队伍数为 奇数 ，那么将会随机轮空并晋级一支队伍，其余的队伍配对。总共进行 (n - 1) / 2 场比赛，且产生 (n - 1) / 2 + 1 支队伍进入下一轮。
+
+返回在比赛中进行的配对次数，直到决出获胜队伍为止。
+
+## 解题思路
+
+- 简单题，按照题目的规则模拟。
+- 这一题还有更加简洁的代码，见解法一。n 个队伍，一个冠军，需要淘汰 n-1 个队伍。每一场比赛淘汰一个队伍，因此进行了 n-1 场比赛。所以共有 n-1 个配对。
+
+## 代码
+
+```go
+package leetcode
+
+// 解法一
+func numberOfMatches(n int) int {
+ return n - 1
+}
+
+// 解法二 模拟
+func numberOfMatches1(n int) int {
+ sum := 0
+ for n != 1 {
+ if n&1 == 0 {
+ sum += n / 2
+ n = n / 2
+ } else {
+ sum += (n - 1) / 2
+ n = (n-1)/2 + 1
+ }
+ }
+ return sum
+}
+```
+# [1689. Partitioning Into Minimum Number Of Deci-Binary Numbers](https://leetcode.com/problems/partitioning-into-minimum-number-of-deci-binary-numbers/)
+
+## 题目
+
+A decimal number is called **deci-binary** if each of its digits is either `0` or `1` without any leading zeros. For example, `101` and `1100` are **deci-binary**, while `112` and `3001` are not.
+
+Given a string `n` that represents a positive decimal integer, return *the **minimum** number of positive **deci-binary** numbers needed so that they sum up to* `n`*.*
+
+**Example 1**:
+
+```
+Input: n = "32"
+Output: 3
+Explanation: 10 + 11 + 11 = 32
+```
+
+**Example 2**:
+
+```
+Input: n = "82734"
+Output: 8
+```
+
+**Example 3**:
+
+```
+Input: n = "27346209830709182346"
+Output: 9
+```
+
+**Constraints**:
+
+- `1 <= n.length <= 105`
+- `n` consists of only digits.
+- `n` does not contain any leading zeros and represents a positive integer.
+
+## 题目大意
+
+如果一个十进制数字不含任何前导零，且每一位上的数字不是 0 就是 1 ，那么该数字就是一个 十-二进制数 。例如，101 和 1100 都是 十-二进制数，而 112 和 3001 不是。给你一个表示十进制整数的字符串 n ，返回和为 n 的 十-二进制数 的最少数目。
+
+## 解题思路
+
+- 这一题也算是简单题，相通了以后，代码就 3 行。
+- 要想由 01 组成的十进制数组成 n，只需要在 n 这个数的各个数位上依次排上 0 和 1 即可。例如 n = 23423723，这是一个 8 位数。最大数字是 7，所以至少需要 7 个数累加能得到这个 n。这 7 个数的百位都为 1，其他数位按需求取 0 和 1 即可。例如万位是 2，那么这 7 个数中任找 2 个数的万位是 1 ，其他 5 个数的万位是 0 即可。
+
+## 代码
+
+```go
+package leetcode
+
+func minPartitions(n string) int {
+ res := 0
+ for i := 0; i < len(n); i++ {
+ if int(n[i]-'0') > res {
+ res = int(n[i] - '0')
+ }
+ }
+ return res
+}
+```
+# [1690. Stone Game VII](https://leetcode.com/problems/stone-game-vii/)
+
+## 题目
+
+Alice and Bob take turns playing a game, with **Alice starting first**.
+
+There are `n` stones arranged in a row. On each player's turn, they can **remove** either the leftmost stone or the rightmost stone from the row and receive points equal to the **sum** of the remaining stones' values in the row. The winner is the one with the higher score when there are no stones left to remove.
+
+Bob found that he will always lose this game (poor Bob, he always loses), so he decided to **minimize the score's difference**. Alice's goal is to **maximize the difference** in the score.
+
+Given an array of integers `stones` where `stones[i]` represents the value of the `ith` stone **from the left**, return *the **difference** in Alice and Bob's score if they both play **optimally**.*
+
+**Example 1**:
+
+```
+Input: stones = [5,3,1,4,2]
+Output: 6
+Explanation:
+- Alice removes 2 and gets 5 + 3 + 1 + 4 = 13 points. Alice = 13, Bob = 0, stones = [5,3,1,4].
+- Bob removes 5 and gets 3 + 1 + 4 = 8 points. Alice = 13, Bob = 8, stones = [3,1,4].
+- Alice removes 3 and gets 1 + 4 = 5 points. Alice = 18, Bob = 8, stones = [1,4].
+- Bob removes 1 and gets 4 points. Alice = 18, Bob = 12, stones = [4].
+- Alice removes 4 and gets 0 points. Alice = 18, Bob = 12, stones = [].
+The score difference is 18 - 12 = 6.
+```
+
+**Example 2**:
+
+```
+Input: stones = [7,90,5,1,100,10,10,2]
+Output: 122
+```
+
+**Constraints**:
+
+- `n == stones.length`
+- `2 <= n <= 1000`
+- `1 <= stones[i] <= 1000`
+
+## 题目大意
+
+石子游戏中，爱丽丝和鲍勃轮流进行自己的回合，爱丽丝先开始 。有 n 块石子排成一排。每个玩家的回合中，可以从行中 移除 最左边的石头或最右边的石头，并获得与该行中剩余石头值之 和 相等的得分。当没有石头可移除时，得分较高者获胜。鲍勃发现他总是输掉游戏（可怜的鲍勃，他总是输），所以他决定尽力 减小得分的差值 。爱丽丝的目标是最大限度地 扩大得分的差值 。
+
+给你一个整数数组 stones ，其中 stones[i] 表示 从左边开始 的第 i 个石头的值，如果爱丽丝和鲍勃都 发挥出最佳水平 ，请返回他们 得分的差值 。
+
+## 解题思路
+
+- 首先考虑 Bob 缩小分值差距意味着什么，意味着他想让他和 Alice 相对分数最小。Bob 已经明确肯定是输，所以他的分数一定比 Alice 小，那么 Bob - Alice 分数相减一定是负数。相对分数越小，意味着差值越大。负数越大，差值越小。-50 和 -10，-10 数值大，相差小。所以 Bob 的操作是让相对分数越大。Alice 的目的也是这样，要让 Alice - Bob 的相对分数越大，这里是正数的越大。综上，两者的目的相同，都是让相对分数最大化。
+- 定义 `dp[i][j]` 代表在当前 `stone[i ~ j]` 区间内能获得的最大分差。状态转移方程为：
+
+ ```go
+ dp[i][j] = max(
+ sum(i + 1, j) - dp[i + 1][j], // 这一局取走 `stone[i]`，获得 sum(i + 1, j) 分数，再减去剩下对手能获得的分数，即是此局能获得的最大分差。
+ sum(i, j - 1) - dp[i][j - 1] // 这一局取走 `stone[j]`，获得 sum(i, j - 1) 分数，再减去剩下对手能获得的分数，即是此局能获得的最大分差。
+ )
+ ```
+
+ 计算 `sum(i + 1, j) = stone[i + 1] + stone[i + 2] + …… + stone[j]` 利用前缀和计算区间和。
+
+- 解法二是正常思路解答出来的代码。解法一是压缩了 DP 数组，在 DP 状态转移的时候，生成下一个 `dp[j]` 实际上是有规律的。利用这个规律可以少存一维数据，压缩空间。解法一的代码直接写出来，比较难想。先写出解法二的代码，然后找到递推规律，优化空间压缩一维，再写出解法一的代码。
+
+## 代码
+
+```go
+package leetcode
+
+// 解法一 优化空间版 DP
+func stoneGameVII(stones []int) int {
+ n := len(stones)
+ sum := make([]int, n)
+ dp := make([]int, n)
+ for i, d := range stones {
+ sum[i] = d
+ }
+ for i := 1; i < n; i++ {
+ for j := 0; j+i < n; j++ {
+ if (n-i)%2 == 1 {
+ d0 := dp[j] + sum[j]
+ d1 := dp[j+1] + sum[j+1]
+ if d0 > d1 {
+ dp[j] = d0
+ } else {
+ dp[j] = d1
+ }
+ } else {
+ d0 := dp[j] - sum[j]
+ d1 := dp[j+1] - sum[j+1]
+ if d0 < d1 {
+ dp[j] = d0
+ } else {
+ dp[j] = d1
+ }
+ }
+ sum[j] = sum[j] + stones[i+j]
+ }
+ }
+ return dp[0]
+}
+
+// 解法二 常规 DP
+func stoneGameVII1(stones []int) int {
+ prefixSum := make([]int, len(stones))
+ for i := 0; i < len(stones); i++ {
+ if i == 0 {
+ prefixSum[i] = stones[i]
+ } else {
+ prefixSum[i] = prefixSum[i-1] + stones[i]
+ }
+ }
+ dp := make([][]int, len(stones))
+ for i := range dp {
+ dp[i] = make([]int, len(stones))
+ dp[i][i] = 0
+ }
+ n := len(stones)
+ for l := 2; l <= n; l++ {
+ for i := 0; i+l <= n; i++ {
+ dp[i][i+l-1] = max(prefixSum[i+l-1]-prefixSum[i+1]+stones[i+1]-dp[i+1][i+l-1], prefixSum[i+l-2]-prefixSum[i]+stones[i]-dp[i][i+l-2])
+ }
+ }
+ return dp[0][n-1]
+}
+
+func max(a, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+}
+```
+# [1691. Maximum Height by Stacking Cuboids](https://leetcode.com/problems/maximum-height-by-stacking-cuboids/)
+
+## 题目
+
+Given `n` `cuboids` where the dimensions of the `ith` cuboid is `cuboids[i] = [widthi, lengthi, heighti]` (**0-indexed**). Choose a **subset** of `cuboids` and place them on each other.
+
+You can place cuboid `i` on cuboid `j` if `widthi <= widthj` and `lengthi <= lengthj` and `heighti <= heightj`. You can rearrange any cuboid's dimensions by rotating it to put it on another cuboid.
+
+Return *the **maximum height** of the stacked* `cuboids`.
+
+**Example 1:**
+
+
+
+```
+Input: cuboids = [[50,45,20],[95,37,53],[45,23,12]]
+Output: 190
+Explanation:
+Cuboid 1 is placed on the bottom with the 53x37 side facing down with height 95.
+Cuboid 0 is placed next with the 45x20 side facing down with height 50.
+Cuboid 2 is placed next with the 23x12 side facing down with height 45.
+The total height is 95 + 50 + 45 = 190.
+```
+
+**Example 2:**
+
+```
+Input: cuboids = [[38,25,45],[76,35,3]]
+Output: 76
+Explanation:
+You can't place any of the cuboids on the other.
+We choose cuboid 1 and rotate it so that the 35x3 side is facing down and its height is 76.
+```
+
+**Example 3:**
+
+```
+Input: cuboids = [[7,11,17],[7,17,11],[11,7,17],[11,17,7],[17,7,11],[17,11,7]]
+Output: 102
+Explanation:
+After rearranging the cuboids, you can see that all cuboids have the same dimension.
+You can place the 11x7 side down on all cuboids so their heights are 17.
+The maximum height of stacked cuboids is 6 * 17 = 102.
+```
+
+**Constraints:**
+
+- `n == cuboids.length`
+- `1 <= n <= 100`
+- `1 <= widthi, lengthi, heighti <= 100`
+
+## 题目大意
+
+给你 n 个长方体 cuboids ，其中第 i 个长方体的长宽高表示为 cuboids[i] = [widthi, lengthi, heighti]（下标从 0 开始）。请你从 cuboids 选出一个 子集 ，并将它们堆叠起来。如果 widthi <= widthj 且 lengthi <= lengthj 且 heighti <= heightj ，你就可以将长方体 i 堆叠在长方体 j 上。你可以通过旋转把长方体的长宽高重新排列，以将它放在另一个长方体上。返回 堆叠长方体 cuboids 可以得到的 最大高度 。
+
+## 解题思路
+
+- 这一题是 LIS 最长递增子序列系列问题的延续。一维 LIS 问题是第 300 题。二维 LIS 问题是 354 题。这一题是三维的 LIS 问题。
+- 题目要求最终摞起来的长方体尽可能的高，那么把长宽高中最大的值旋转为高。这是针对单个方块的排序。多个方块间还要排序，因为他们摞起来有要求，大的方块必须放在下面。所以针对多个方块，按照长，宽，高的顺序进行排序。两次排序完成以后，可以用动态规划找出最大值了。定义 `dp[i]` 为以 `i` 为最后一块砖块所能堆叠的最高高度。由于长和宽已经排好序了。所以只需要在 [0, i - 1] 这个区间内动态更新 dp 最大值。
+
+## 代码
+
+```go
+package leetcode
+
+import "sort"
+
+func maxHeight(cuboids [][]int) int {
+ n := len(cuboids)
+ for i := 0; i < n; i++ {
+ sort.Ints(cuboids[i]) // 立方体三边内部排序
+ }
+ // 立方体排序，先按最短边，再到最长边
+ sort.Slice(cuboids, func(i, j int) bool {
+ if cuboids[i][0] != cuboids[j][0] {
+ return cuboids[i][0] < cuboids[j][0]
+ }
+ if cuboids[i][1] != cuboids[j][1] {
+ return cuboids[i][1] < cuboids[j][1]
+ }
+ return cuboids[i][2] < cuboids[j][2]
+ })
+ res := 0
+ dp := make([]int, n)
+ for i := 0; i < n; i++ {
+ dp[i] = cuboids[i][2]
+ res = max(res, dp[i])
+ }
+ for i := 1; i < n; i++ {
+ for j := 0; j < i; j++ {
+ if cuboids[j][0] <= cuboids[i][0] && cuboids[j][1] <= cuboids[i][1] && cuboids[j][2] <= cuboids[i][2] {
+ dp[i] = max(dp[i], dp[j]+cuboids[i][2])
+ }
+ }
+ res = max(res, dp[i])
+ }
+ return res
+}
+
+func max(x, y int) int {
+ if x > y {
+ return x
+ }
+ return y
+}
+```
+# [1694. Reformat Phone Number](https://leetcode.com/problems/reformat-phone-number/)
+
+
+## 题目
+
+You are given a phone number as a string `number`. `number` consists of digits, spaces `' '`, and/or dashes `'-'`.
+
+You would like to reformat the phone number in a certain manner. Firstly, **remove** all spaces and dashes. Then, **group** the digits from left to right into blocks of length 3 **until** there are 4 or fewer digits. The final digits are then grouped as follows:
+
+- 2 digits: A single block of length 2.
+- 3 digits: A single block of length 3.
+- 4 digits: Two blocks of length 2 each.
+
+The blocks are then joined by dashes. Notice that the reformatting process should **never** produce any blocks of length 1 and produce **at most** two blocks of length 2.
+
+Return *the phone number after formatting.*
+
+**Example 1**:
+
+```
+Input: number = "1-23-45 6"
+Output: "123-456"
+Explanation: The digits are "123456".
+Step 1: There are more than 4 digits, so group the next 3 digits. The 1st block is "123".
+Step 2: There are 3 digits remaining, so put them in a single block of length 3. The 2nd block is "456".
+Joining the blocks gives "123-456".
+
+```
+
+**Example 2**:
+
+```
+Input: number = "123 4-567"
+Output: "123-45-67"
+Explanation: The digits are "1234567".
+Step 1: There are more than 4 digits, so group the next 3 digits. The 1st block is "123".
+Step 2: There are 4 digits left, so split them into two blocks of length 2. The blocks are "45" and "67".
+Joining the blocks gives "123-45-67".
+
+```
+
+**Example 3**:
+
+```
+Input: number = "123 4-5678"
+Output: "123-456-78"
+Explanation: The digits are "12345678".
+Step 1: The 1st block is "123".
+Step 2: The 2nd block is "456".
+Step 3: There are 2 digits left, so put them in a single block of length 2. The 3rd block is "78".
+Joining the blocks gives "123-456-78".
+
+```
+
+**Example 4**:
+
+```
+Input: number = "12"
+Output: "12"
+
+```
+
+**Example 5**:
+
+```
+Input: number = "--17-5 229 35-39475 "
+Output: "175-229-353-94-75"
+
+```
+
+**Constraints**:
+
+- `2 <= number.length <= 100`
+- `number` consists of digits and the characters `'-'` and `' '`.
+- There are at least **two** digits in `number`.
+
+## 题目大意
+
+给你一个字符串形式的电话号码 number 。number 由数字、空格 ' '、和破折号 '-' 组成。
+
+请你按下述方式重新格式化电话号码。
+
+- 首先，删除 所有的空格和破折号。
+- 其次，将数组从左到右 每 3 个一组 分块，直到 剩下 4 个或更少数字。剩下的数字将按下述规定再分块：
+ - 2 个数字：单个含 2 个数字的块。
+ - 3 个数字：单个含 3 个数字的块。
+ - 4 个数字：两个分别含 2 个数字的块。
+
+最后用破折号将这些块连接起来。注意，重新格式化过程中 不应该 生成仅含 1 个数字的块，并且 最多 生成两个含 2 个数字的块。返回格式化后的电话号码。
+
+## 解题思路
+
+- 简单题。先判断号码是不是 2 位和 4 位，如果是，单独输出这 2 种情况。剩下的都是 3 位以上了，取余，判断剩余的数字是 2 个还是 4 个。这时不可能存在剩 1 位数的情况。除 3 余 1，即剩 4 位的情况，末尾 4 位需要 2 个一组输出。除 3 余 2，即剩 2 位的情况。处理好末尾，再逆序每 3 个一组连接 "-" 即可。可能需要注意的 case 见 test 文件。
+
+## 代码
+
+```go
+package leetcode
+
+import (
+ "strings"
+)
+
+func reformatNumber(number string) string {
+ parts, nums := []string{}, []rune{}
+ for _, r := range number {
+ if r != '-' && r != ' ' {
+ nums = append(nums, r)
+ }
+ }
+ threeDigits, twoDigits := len(nums)/3, 0
+ switch len(nums) % 3 {
+ case 1:
+ threeDigits--
+ twoDigits = 2
+ case 2:
+ twoDigits = 1
+ default:
+ twoDigits = 0
+ }
+ for i := 0; i < threeDigits; i++ {
+ s := ""
+ s += string(nums[0:3])
+ nums = nums[3:]
+ parts = append(parts, s)
+ }
+ for i := 0; i < twoDigits; i++ {
+ s := ""
+ s += string(nums[0:2])
+ nums = nums[2:]
+ parts = append(parts, s)
+ }
+ return strings.Join(parts, "-")
+}
+```
+# [1695. Maximum Erasure Value](https://leetcode.com/problems/maximum-erasure-value/)
+
+
+## 题目
+
+You are given an array of positive integers `nums` and want to erase a subarray containing **unique elements**. The **score** you get by erasing the subarray is equal to the **sum** of its elements.
+
+Return *the **maximum score** you can get by erasing **exactly one** subarray.*
+
+An array `b` is called to be a subarray of `a` if it forms a contiguous subsequence of `a`, that is, if it is equal to `a[l],a[l+1],...,a[r]` for some `(l,r)`.
+
+**Example 1**:
+
+```
+Input: nums = [4,2,4,5,6]
+Output: 17
+Explanation: The optimal subarray here is [2,4,5,6].
+```
+
+**Example 2**:
+
+```
+Input: nums = [5,2,1,2,5,2,1,2,5]
+Output: 8
+Explanation: The optimal subarray here is [5,2,1] or [1,2,5].
+```
+
+**Constraints**:
+
+- `1 <= nums.length <= 105`
+- `1 <= nums[i] <= 104`
+
+## 题目大意
+
+给你一个正整数数组 nums ，请你从中删除一个含有 若干不同元素 的子数组。删除子数组的 得分 就是子数组各元素之 和 。返回 只删除一个 子数组可获得的 最大得分 。如果数组 b 是数组 a 的一个连续子序列，即如果它等于 a[l],a[l+1],...,a[r] ，那么它就是 a 的一个子数组。
+
+## 解题思路
+
+- 读完题立马能识别出这是经典的滑动窗口题。利用滑动窗口从左往右滑动窗口，滑动过程中统计频次，如果是不同元素，右边界窗口又移，否则左边窗口缩小。每次移动更新 max 值。最终扫完一遍以后，max 值即为所求。
+
+## 代码
+
+```go
+package leetcode
+
+func maximumUniqueSubarray(nums []int) int {
+ if len(nums) == 0 {
+ return 0
+ }
+ result, left, right, freq := 0, 0, -1, map[int]int{}
+ for left < len(nums) {
+ if right+1 < len(nums) && freq[nums[right+1]] == 0 {
+ freq[nums[right+1]]++
+ right++
+ } else {
+ freq[nums[left]]--
+ left++
+ }
+ sum := 0
+ for i := left; i <= right; i++ {
+ sum += nums[i]
+ }
+ result = max(result, sum)
+ }
+ return result
+}
+
+func max(a int, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+}
+```
+# [1696. Jump Game VI](https://leetcode.com/problems/jump-game-vi/)
+
+## 题目
+
+You are given a **0-indexed** integer array `nums` and an integer `k`.
+
+You are initially standing at index `0`. In one move, you can jump at most `k` steps forward without going outside the boundaries of the array. That is, you can jump from index `i` to any index in the range `[i + 1, min(n - 1, i + k)]` **inclusive**.
+
+You want to reach the last index of the array (index `n - 1`). Your **score** is the **sum** of all `nums[j]` for each index `j` you visited in the array.
+
+Return *the **maximum score** you can get*.
+
+**Example 1:**
+
+```
+Input: nums = [1,-1,-2,4,-7,3], k = 2
+Output: 7
+Explanation: You can choose your jumps forming the subsequence [1,-1,4,3] (underlined above). The sum is 7.
+
+```
+
+**Example 2:**
+
+```
+Input: nums = [10,-5,-2,4,0,3], k = 3
+Output: 17
+Explanation: You can choose your jumps forming the subsequence [10,4,3] (underlined above). The sum is 17.
+
+```
+
+**Example 3:**
+
+```
+Input: nums = [1,-5,-20,4,-1,3,-6,-3], k = 2
+Output: 0
+
+```
+
+**Constraints:**
+
+- `1 <= nums.length, k <= 10^5`
+- `10^4 <= nums[i] <= 10^4`
+
+## 题目大意
+
+给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。一开始你在下标 0 处。每一步，你最多可以往前跳 k 步，但你不能跳出数组的边界。也就是说，你可以从下标 i 跳到 [i + 1， min(n - 1, i + k)] 包含 两个端点的任意位置。你的目标是到达数组最后一个位置（下标为 n - 1 ），你的 得分 为经过的所有数字之和。请你返回你能得到的 最大得分 。
+
+## 解题思路
+
+- 首先能想到的解题思路是动态规划。定义 `dp[i]` 为跳到第 `i` 个位子能获得的最大分数。题目要求的是 `dp[n-1]`，状态转移方程是：`dp[i] = nums[i] + max(dp[j]), max(0, i - k ) <= j < i`，这里需要注意 `j` 的下界，题目中说到不能跳到负数区间，所以左边界下界为 0 。求 `max(dp[j])` 需要遍历一次求得最大值，所以这个解法整体时间复杂度是 O((n - k) * k)，但是提交以后提示超时了。
+- 分析一下超时原因。每次都要在 `[max(0, i - k ), i)` 区间内扫描找到最大值，下一轮的区间是 `[max(0, i - k + 1), i + 1)`，前后这两轮扫描的区间存在大量重合部分 `[max(0, i - k + 1), i)`，正是这部分反反复复的扫描导致算法低效。如何高效的在一个区间内找到最大值是本题的关键。利用单调队列可以完成此题。单调队列里面存一个区间内最大值的下标。这里单调队列有 2 个性质。性质一，队列的队首永远都是最大值，队列从大到小降序排列。如果来了一个比队首更大的值的下标，需要将单调队列清空，只存这个新的最大值的下标。性质二，队列的长度为 k。从队尾插入新值，并把队头的最大值“挤”出队首。拥有了这个单调队列以后，再进行 DP 状态转移，效率就很高了。每次只需取出队首的最大值即可。具体代码见下面。
+
+## 代码
+
+```go
+package leetcode
+
+import (
+ "math"
+)
+
+// 单调队列
+func maxResult(nums []int, k int) int {
+ dp := make([]int, len(nums))
+ dp[0] = nums[0]
+ for i := 1; i < len(dp); i++ {
+ dp[i] = math.MinInt32
+ }
+ window := make([]int, k)
+ for i := 1; i < len(nums); i++ {
+ dp[i] = nums[i] + dp[window[0]]
+ for len(window) > 0 && dp[window[len(window)-1]] <= dp[i] {
+ window = window[:len(window)-1]
+ }
+ for len(window) > 0 && i-k >= window[0] {
+ window = window[1:]
+ }
+ window = append(window, i)
+ }
+ return dp[len(nums)-1]
+}
+
+// 超时
+func maxResult1(nums []int, k int) int {
+ dp := make([]int, len(nums))
+ if k > len(nums) {
+ k = len(nums)
+ }
+ dp[0] = nums[0]
+ for i := 1; i < len(dp); i++ {
+ dp[i] = math.MinInt32
+ }
+ for i := 1; i < len(nums); i++ {
+ left, tmp := max(0, i-k), math.MinInt32
+ for j := left; j < i; j++ {
+ tmp = max(tmp, dp[j])
+ }
+ dp[i] = nums[i] + tmp
+ }
+ return dp[len(nums)-1]
+}
+
+func max(a, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+}
+```
+# [1700. Number of Students Unable to Eat Lunch](https://leetcode.com/problems/number-of-students-unable-to-eat-lunch/)
+
+
+## 题目
+
+The school cafeteria offers circular and square sandwiches at lunch break, referred to by numbers `0` and `1` respectively. All students stand in a queue. Each student either prefers square or circular sandwiches.
+
+The number of sandwiches in the cafeteria is equal to the number of students. The sandwiches are placed in a **stack**. At each step:
+
+- If the student at the front of the queue **prefers** the sandwich on the top of the stack, they will **take it** and leave the queue.
+- Otherwise, they will **leave it** and go to the queue's end.
+
+This continues until none of the queue students want to take the top sandwich and are thus unable to eat.
+
+You are given two integer arrays `students` and `sandwiches` where `sandwiches[i]` is the type of the `ith` sandwich in the stack (`i = 0` is the top of the stack) and `students[j]` is the preference of the `jth` student in the initial queue (`j = 0` is the front of the queue). Return *the number of students that are unable to eat.*
+
+**Example 1:**
+
+```
+Input: students = [1,1,0,0], sandwiches = [0,1,0,1]
+Output: 0
+Explanation:
+- Front student leaves the top sandwich and returns to the end of the line making students = [1,0,0,1].
+- Front student leaves the top sandwich and returns to the end of the line making students = [0,0,1,1].
+- Front student takes the top sandwich and leaves the line making students = [0,1,1] and sandwiches = [1,0,1].
+- Front student leaves the top sandwich and returns to the end of the line making students = [1,1,0].
+- Front student takes the top sandwich and leaves the line making students = [1,0] and sandwiches = [0,1].
+- Front student leaves the top sandwich and returns to the end of the line making students = [0,1].
+- Front student takes the top sandwich and leaves the line making students = [1] and sandwiches = [1].
+- Front student takes the top sandwich and leaves the line making students = [] and sandwiches = [].
+Hence all students are able to eat.
+```
+
+**Example 2:**
+
+```
+Input: students = [1,1,1,0,0,1], sandwiches = [1,0,0,0,1,1]
+Output: 3
+```
+
+**Constraints:**
+
+- `1 <= students.length, sandwiches.length <= 100`
+- `students.length == sandwiches.length`
+- `sandwiches[i]` is `0` or `1`.
+- `students[i]` is `0` or `1`.
+
+## 题目大意
+
+学校的自助午餐提供圆形和方形的三明治，分别用数字 0 和 1 表示。所有学生站在一个队列里，每个学生要么喜欢圆形的要么喜欢方形的。
+餐厅里三明治的数量与学生的数量相同。所有三明治都放在一个 栈 里，每一轮：
+
+- 如果队列最前面的学生 喜欢 栈顶的三明治，那么会 拿走它 并离开队列。
+- 否则，这名学生会 放弃这个三明治 并回到队列的尾部。
+这个过程会一直持续到队列里所有学生都不喜欢栈顶的三明治为止。
+
+给你两个整数数组 students 和 sandwiches ，其中 sandwiches[i] 是栈里面第 i 个三明治的类型（i = 0 是栈的顶部）， students[j] 是初始队列里第 j 名学生对三明治的喜好（j = 0 是队列的最开始位置）。请你返回无法吃午餐的学生数量。
+
+## 解题思路
+
+- 简单题。按照题意，学生不管怎么轮流领三明治，如果数量够，经过多轮循环，总能领到。问题可以等价为，学生依次到队列前面领取三明治。2 个种类的三明治都摆好放在那里了。最终领不到三明治的学生都是因为喜欢的三明治不够发放了。按照这个思路，先统计 2 种三明治的总个数，然后减去学生对三明治的需求总数，剩下的学生即都是无法满足的。
+
+## 代码
+
+```go
+package leetcode
+
+func countStudents(students []int, sandwiches []int) int {
+ tmp, n, i := [2]int{}, len(students), 0
+ for _, v := range students {
+ tmp[v]++
+ }
+ for i < n && tmp[sandwiches[i]] > 0 {
+ tmp[sandwiches[i]]--
+ i++
+ }
+ return n - i
+}
+```
+# [1704. Determine if String Halves Are Alike](https://leetcode.com/problems/determine-if-string-halves-are-alike/)
+
+## 题目
+
+You are given a string `s` of even length. Split this string into two halves of equal lengths, and let `a` be the first half and `b` be the second half.
+
+Two strings are **alike** if they have the same number of vowels (`'a'`, `'e'`, `'i'`, `'o'`, `'u'`, `'A'`, `'E'`, `'I'`, `'O'`, `'U'`). Notice that `s` contains uppercase and lowercase letters.
+
+Return `true` *if* `a` *and* `b` *are **alike***. Otherwise, return `false`.
+
+**Example 1:**
+
+```
+Input: s = "book"
+Output: true
+Explanation: a = "bo" and b = "ok". a has 1 vowel and b has 1 vowel. Therefore, they are alike.
+```
+
+**Example 2:**
+
+```
+Input: s = "textbook"
+Output: false
+Explanation: a = "text" and b = "book". a has 1 vowel whereas b has 2. Therefore, they are not alike.
+Notice that the vowel o is counted twice.
+```
+
+**Example 3:**
+
+```
+Input: s = "MerryChristmas"
+Output: false
+```
+
+**Example 4:**
+
+```
+Input: s = "AbCdEfGh"
+Output: true
+```
+
+**Constraints:**
+
+- `2 <= s.length <= 1000`
+- `s.length` is even.
+- `s` consists of **uppercase and lowercase** letters.
+
+## 题目大意
+
+给你一个偶数长度的字符串 s 。将其拆分成长度相同的两半，前一半为 a ，后一半为 b 。两个字符串 相似 的前提是它们都含有相同数目的元音（'a'，'e'，'i'，'o'，'u'，'A'，'E'，'I'，'O'，'U'）。注意，s 可能同时含有大写和小写字母。如果 a 和 b 相似，返回 true ；否则，返回 false 。
+
+## 解题思路
+
+- 简单题。依题意，分别统计前半段元音字母的个数和后半段元音字母的个数，个数相同则输出 true，不同就输出 false。
+
+## 代码
+
+```go
+package leetcode
+
+func halvesAreAlike(s string) bool {
+ return numVowels(s[len(s)/2:]) == numVowels(s[:len(s)/2])
+}
+
+func numVowels(x string) int {
+ res := 0
+ for _, c := range x {
+ switch c {
+ case 'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U':
+ res++
+ }
+ }
+ return res
+}
+```
+# [1705. Maximum Number of Eaten Apples](https://leetcode.com/problems/maximum-number-of-eaten-apples/)
+
+## 题目
+
+There is a special kind of apple tree that grows apples every day for n days. On the ith day, the tree grows apples[i] apples that will rot after days[i] days, that is on day i + days[i] the apples will be rotten and cannot be eaten. On some days, the apple tree does not grow any apples, which are denoted by apples[i] == 0 and days[i] == 0.
+
+You decided to eat at most one apple a day (to keep the doctors away). Note that you can keep eating after the first n days.
+
+Given two integer arrays days and apples of length n, return the maximum number of apples you can eat.
+
+**Example 1**:
+
+ Input: apples = [1,2,3,5,2], days = [3,2,1,4,2]
+ Output: 7
+ Explanation: You can eat 7 apples:
+ - On the first day, you eat an apple that grew on the first day.
+ - On the second day, you eat an apple that grew on the second day.
+ - On the third day, you eat an apple that grew on the second day. After this day, the apples that grew on the third day rot.
+ - On the fourth to the seventh days, you eat apples that grew on the fourth day.
+
+**Example 2**:
+
+ Input: apples = [3,0,0,0,0,2], days = [3,0,0,0,0,2]
+ Output: 5
+ Explanation: You can eat 5 apples:
+ - On the first to the third day you eat apples that grew on the first day.
+ - Do nothing on the fouth and fifth days.
+ - On the sixth and seventh days you eat apples that grew on the sixth day.
+
+**Constraints:**
+
+- apples.length == n
+- days.length == n
+- 1 <= n <= 2 * 10000
+- 0 <= apples[i], days[i] <= 2 * 10000
+- days[i] = 0 if and only if apples[i] = 0.
+
+## 题目大意
+
+有一棵特殊的苹果树，一连 n 天，每天都可以长出若干个苹果。在第 i 天，树上会长出 apples[i] 个苹果，这些苹果将会在 days[i] 天后（也就是说，第 i + days[i] 天时）腐烂，变得无法食用。也可能有那么几天，树上不会长出新的苹果，此时用 apples[i] == 0 且 days[i] == 0 表示。
+
+你打算每天 最多 吃一个苹果来保证营养均衡。注意，你可以在这 n 天之后继续吃苹果。
+
+给你两个长度为 n 的整数数组 days 和 apples ，返回你可以吃掉的苹果的最大数目。
+
+## 解题思路
+
+贪心算法和最小堆
+
+ - data中的end表示腐烂的日期，left表示拥有的苹果数量
+ - 贪心:每天吃掉end最小但没有腐烂的苹果
+ - 最小堆:构造类型为数组(数组中元素的类型为data)的最小堆
+
+## 代码
+
+```go
+package leetcode
+
+import "container/heap"
+
+func eatenApples(apples []int, days []int) int {
+ h := hp{}
+ i := 0
+ var ans int
+ for ; i < len(apples); i++ {
+ for len(h) > 0 && h[0].end <= i {
+ heap.Pop(&h)
+ }
+ if apples[i] > 0 {
+ heap.Push(&h, data{apples[i], i + days[i]})
+ }
+ if len(h) > 0 {
+ minData := heap.Pop(&h).(data)
+ ans++
+ if minData.left > 1 {
+ heap.Push(&h, data{minData.left - 1, minData.end})
+ }
+ }
+ }
+ for len(h) > 0 {
+ for len(h) > 0 && h[0].end <= i {
+ heap.Pop(&h)
+ }
+ if len(h) == 0 {
+ break
+ }
+ minData := heap.Pop(&h).(data)
+ nums := min(minData.left, minData.end-i)
+ ans += nums
+ i += nums
+ }
+ return ans
+}
+
+func min(a, b int) int {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+type data struct {
+ left int
+ end int
+}
+
+type hp []data
+
+func (h hp) Len() int { return len(h) }
+func (h hp) Less(i, j int) bool { return h[i].end < h[j].end }
+func (h hp) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
+
+func (h *hp) Push(x interface{}) {
+ *h = append(*h, x.(data))
+}
+
+func (h *hp) Pop() interface{} {
+ old := *h
+ n := len(old)
+ x := old[n-1]
+ *h = old[0 : n-1]
+ return x
+}
+```
+# [1710. Maximum Units on a Truck](https://leetcode.com/problems/maximum-units-on-a-truck/)
+
+
+## 题目
+
+You are assigned to put some amount of boxes onto **one truck**. You are given a 2D array `boxTypes`, where `boxTypes[i] = [numberOfBoxesi, numberOfUnitsPerBoxi]`:
+
+- `numberOfBoxesi` is the number of boxes of type `i`.
+- `numberOfUnitsPerBoxi`is the number of units in each box of the type `i`.
+
+You are also given an integer `truckSize`, which is the **maximum** number of **boxes** that can be put on the truck. You can choose any boxes to put on the truck as long as the number of boxes does not exceed `truckSize`.
+
+Return *the **maximum** total number of **units** that can be put on the truck.*
+
+**Example 1:**
+
+```
+Input: boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4
+Output: 8
+Explanation: There are:
+- 1 box of the first type that contains 3 units.
+- 2 boxes of the second type that contain 2 units each.
+- 3 boxes of the third type that contain 1 unit each.
+You can take all the boxes of the first and second types, and one box of the third type.
+The total number of units will be = (1 * 3) + (2 * 2) + (1 * 1) = 8.
+```
+
+**Example 2:**
+
+```
+Input: boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10
+Output: 91
+```
+
+**Constraints:**
+
+- `1 <= boxTypes.length <= 1000`
+- `1 <= numberOfBoxesi, numberOfUnitsPerBoxi <= 1000`
+- `1 <= truckSize <= 106`
+
+## 题目大意
+
+请你将一些箱子装在 一辆卡车 上。给你一个二维数组 boxTypes ，其中 boxTypes[i] = [numberOfBoxesi, numberOfUnitsPerBoxi] ：
+
+- numberOfBoxesi 是类型 i 的箱子的数量。-
+- numberOfUnitsPerBoxi 是类型 i 每个箱子可以装载的单元数量。
+
+整数 truckSize 表示卡车上可以装载 箱子 的 最大数量 。只要箱子数量不超过 truckSize ，你就可以选择任意箱子装到卡车上。返回卡车可以装载 单元 的 最大 总数。
+
+## 解题思路
+
+- 简单题。先将箱子按照单元数量从大到小排序。要想卡车装载单元数最大，那么需要尽量装单元数多的箱子。所以排序以后从单元数量多的箱子开始取。一直取至 truckSize 没有空间。累积的单元数即最大总数。
+
+## 代码
+
+```go
+package leetcode
+
+import "sort"
+
+func maximumUnits(boxTypes [][]int, truckSize int) int {
+ sort.Slice(boxTypes, func(i, j int) bool {
+ return boxTypes[i][1] > boxTypes[j][1]
+ })
+ res := 0
+ for i := 0; truckSize > 0 && i < len(boxTypes); i++ {
+ if truckSize >= boxTypes[i][0] {
+ truckSize -= boxTypes[i][0]
+ res += (boxTypes[i][1] * boxTypes[i][0])
+ } else {
+ res += (truckSize * boxTypes[i][1])
+ truckSize = 0
+ }
+ }
+ return res
+}
+```
+# [1716. Calculate Money in Leetcode Bank](https://leetcode.com/problems/calculate-money-in-leetcode-bank/)
+
+
+## 题目
+
+Hercy wants to save money for his first car. He puts money in the Leetcode bank **every day**.
+
+He starts by putting in `$1` on Monday, the first day. Every day from Tuesday to Sunday, he will put in `$1` more than the day before. On every subsequent Monday, he will put in `$1` more than the **previous Monday**.
+
+Given `n`, return *the total amount of money he will have in the Leetcode bank at the end of the* `nth` *day.*
+
+**Example 1:**
+
+```
+Input: n = 4
+Output: 10
+Explanation: After the 4th day, the total is 1 + 2 + 3 + 4 = 10.
+```
+
+**Example 2:**
+
+```
+Input: n = 10
+Output: 37
+Explanation: After the 10th day, the total is (1 + 2 + 3 + 4 + 5 + 6 + 7) + (2 + 3 + 4) = 37. Notice that on the 2nd Monday, Hercy only puts in $2.
+```
+
+**Example 3:**
+
+```
+Input: n = 20
+Output: 96
+Explanation: After the 20th day, the total is (1 + 2 + 3 + 4 + 5 + 6 + 7) + (2 + 3 + 4 + 5 + 6 + 7 + 8) + (3 + 4 + 5 + 6 + 7 + 8) = 96.
+```
+
+**Constraints:**
+
+- `1 <= n <= 1000`
+
+## 题目大意
+
+Hercy 想要为购买第一辆车存钱。他 每天 都往力扣银行里存钱。最开始，他在周一的时候存入 1 块钱。从周二到周日，他每天都比前一天多存入 1 块钱。在接下来每一个周一，他都会比 前一个周一 多存入 1 块钱。给你 n ，请你返回在第 n 天结束的时候他在力扣银行总共存了多少块钱。
+
+## 解题思路
+
+- 简单题。按照题意写 2 层循环即可。
+
+## 代码
+
+```go
+package leetcode
+
+func totalMoney(n int) int {
+ res := 0
+ for tmp, count := 1, 7; n > 0; tmp, count = tmp+1, 7 {
+ for m := tmp; n > 0 && count > 0; m++ {
+ res += m
+ n--
+ count--
+ }
+ }
+ return res
+}
+```
+# [1720. Decode XORed Array](https://leetcode.com/problems/decode-xored-array/)
+
+
+## 题目
+
+There is a **hidden** integer array `arr` that consists of `n` non-negative integers.
+
+It was encoded into another integer array `encoded` of length `n - 1`, such that `encoded[i] = arr[i] XOR arr[i + 1]`. For example, if `arr = [1,0,2,1]`, then `encoded = [1,2,3]`.
+
+You are given the `encoded` array. You are also given an integer `first`, that is the first element of `arr`, i.e. `arr[0]`.
+
+Return *the original array* `arr`. It can be proved that the answer exists and is unique.
+
+**Example 1:**
+
+```
+Input: encoded = [1,2,3], first = 1
+Output: [1,0,2,1]
+Explanation: If arr = [1,0,2,1], then first = 1 and encoded = [1 XOR 0, 0 XOR 2, 2 XOR 1] = [1,2,3]
+
+```
+
+**Example 2:**
+
+```
+Input: encoded = [6,2,7,3], first = 4
+Output: [4,2,0,7,4]
+
+```
+
+**Constraints:**
+
+- `2 <= n <= 104`
+- `encoded.length == n - 1`
+- `0 <= encoded[i] <= 105`
+- `0 <= first <= 10^5`
+
+## 题目大意
+
+未知 整数数组 arr 由 n 个非负整数组成。经编码后变为长度为 n - 1 的另一个整数数组 encoded ，其中 encoded[i] = arr[i] XOR arr[i + 1] 。例如，arr = [1,0,2,1] 经编码后得到 encoded = [1,2,3] 。给你编码后的数组 encoded 和原数组 arr 的第一个元素 first（arr[0]）。请解码返回原数组 arr 。可以证明答案存在并且是唯一的。
+
+## 解题思路
+
+- 简单题。按照题意，求返回解码以后的原数组，即将编码后的数组前后两两元素依次做异或 `XOR` 运算。
+
+## 代码
+
+```go
+package leetcode
+
+func decode(encoded []int, first int) []int {
+ arr := make([]int, len(encoded)+1)
+ arr[0] = first
+ for i, val := range encoded {
+ arr[i+1] = arr[i] ^ val
+ }
+ return arr
+}
+```
+# [1721. Swapping Nodes in a Linked List](https://leetcode.com/problems/swapping-nodes-in-a-linked-list/)
+
+
+## 题目
+
+You are given the `head` of a linked list, and an integer `k`.
+
+Return *the head of the linked list after **swapping** the values of the* `kth` *node from the beginning and the* `kth` *node from the end (the list is **1-indexed**).*
+
+**Example 1:**
+
+
+
+```
+Input: head = [1,2,3,4,5], k = 2
+Output: [1,4,3,2,5]
+```
+
+**Example 2:**
+
+```
+Input: head = [7,9,6,6,7,8,3,0,9,5], k = 5
+Output: [7,9,6,6,8,7,3,0,9,5]
+```
+
+**Example 3:**
+
+```
+Input: head = [1], k = 1
+Output: [1]
+```
+
+**Example 4:**
+
+```
+Input: head = [1,2], k = 1
+Output: [2,1]
+```
+
+**Example 5:**
+
+```
+Input: head = [1,2,3], k = 2
+Output: [1,2,3]
+```
+
+**Constraints:**
+
+- The number of nodes in the list is `n`.
+- `1 <= k <= n <= 10^5`
+- `0 <= Node.val <= 100`
+
+## 题目大意
+
+给你链表的头节点 `head` 和一个整数 `k` 。**交换** 链表正数第 `k` 个节点和倒数第 `k` 个节点的值后，返回链表的头节点（链表 **从 1 开始索引**）。
+
+## 解题思路
+
+- 这道题虽然是 medium，但是实际非常简单。题目要求链表中 2 个节点的值，无非是先找到这 2 个节点，然后再交换即可。链表查询节点需要 O(n)，2 次循环找到对应的 2 个节点，交换值即可。
+
+## 代码
+
+```go
+package leetcode
+
+import (
+ "github.com/halfrost/leetcode-go/structures"
+)
+
+// ListNode define
+type ListNode = structures.ListNode
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ * Val int
+ * Next *ListNode
+ * }
+ */
+func swapNodes(head *ListNode, k int) *ListNode {
+ count := 1
+ var a, b *ListNode
+ for node := head; node != nil; node = node.Next {
+ if count == k {
+ a = node
+ }
+ count++
+ }
+ length := count
+ count = 1
+ for node := head; node != nil; node = node.Next {
+ if count == length-k {
+ b = node
+ }
+ count++
+ }
+ a.Val, b.Val = b.Val, a.Val
+ return head
+}
+```
+# [1725. Number Of Rectangles That Can Form The Largest Square](https://leetcode.com/problems/number-of-rectangles-that-can-form-the-largest-square/)
+
+
+## 题目
+
+You are given an array `rectangles` where `rectangles[i] = [li, wi]` represents the `ith` rectangle of length `li` and width `wi`.
+
+You can cut the `ith` rectangle to form a square with a side length of `k` if both `k <= li` and `k <= wi`. For example, if you have a rectangle `[4,6]`, you can cut it to get a square with a side length of at most `4`.
+
+Let `maxLen` be the side length of the **largest** square you can obtain from any of the given rectangles.
+
+Return *the **number** of rectangles that can make a square with a side length of* `maxLen`.
+
+**Example 1:**
+
+```
+Input: rectangles = [[5,8],[3,9],[5,12],[16,5]]
+Output: 3
+Explanation: The largest squares you can get from each rectangle are of lengths [5,3,5,5].
+The largest possible square is of length 5, and you can get it out of 3 rectangles.
+```
+
+**Example 2:**
+
+```
+Input: rectangles = [[2,3],[3,7],[4,3],[3,7]]
+Output: 3
+```
+
+**Constraints:**
+
+- `1 <= rectangles.length <= 1000`
+- `rectangles[i].length == 2`
+- `1 <= li, wi <= 10^9`
+- `li != wi`
+
+## 题目大意
+
+给你一个数组 rectangles ，其中 rectangles[i] = [li, wi] 表示第 i 个矩形的长度为 li 、宽度为 wi 。如果存在 k 同时满足 k <= li 和 k <= wi ，就可以将第 i 个矩形切成边长为 k 的正方形。例如，矩形 [4,6] 可以切成边长最大为 4 的正方形。设 maxLen 为可以从矩形数组 rectangles 切分得到的 最大正方形 的边长。返回可以切出边长为 maxLen 的正方形的矩形 数目 。
+
+## 解题思路
+
+- 简单题。扫描数组中的每一个矩形，先找到边长较小的那条边，作为正方形的边长。扫描过程中动态更新最大的正方形边长，并累加计数。循环一遍结束，输出最终计数值即可。
+
+## 代码
+
+```go
+package leetcode
+
+func countGoodRectangles(rectangles [][]int) int {
+ minLength, count := 0, 0
+ for i, _ := range rectangles {
+ minSide := 0
+ if rectangles[i][0] <= rectangles[i][1] {
+ minSide = rectangles[i][0]
+ } else {
+ minSide = rectangles[i][1]
+ }
+ if minSide > minLength {
+ minLength = minSide
+ count = 1
+ } else if minSide == minLength {
+ count++
+ }
+ }
+ return count
+}
+```
+# [1732. Find the Highest Altitude](https://leetcode.com/problems/find-the-highest-altitude/)
+
+
+## 题目
+
+There is a biker going on a road trip. The road trip consists of `n + 1` points at different altitudes. The biker starts his trip on point `0` with altitude equal `0`.
+
+You are given an integer array `gain` of length `n` where `gain[i]` is the **net gain in altitude** between points `i` and `i + 1` for all (`0 <= i < n)`. Return *the **highest altitude** of a point.*
+
+**Example 1:**
+
+```
+Input: gain = [-5,1,5,0,-7]
+Output: 1
+Explanation: The altitudes are [0,-5,-4,1,1,-6]. The highest is 1.
+```
+
+**Example 2:**
+
+```
+Input: gain = [-4,-3,-2,-1,4,3,2]
+Output: 0
+Explanation: The altitudes are [0,-4,-7,-9,-10,-6,-3,-1]. The highest is 0.
+```
+
+**Constraints:**
+
+- `n == gain.length`
+- `1 <= n <= 100`
+- `100 <= gain[i] <= 100`
+
+## 题目大意
+
+有一个自行车手打算进行一场公路骑行，这条路线总共由 n + 1 个不同海拔的点组成。自行车手从海拔为 0 的点 0 开始骑行。给你一个长度为 n 的整数数组 gain ，其中 gain[i] 是点 i 和点 i + 1 的 净海拔高度差（0 <= i < n）。请你返回 最高点的海拔 。
+
+## 解题思路
+
+- 简单题。循环数组依次从第一个海拔点开始还原每个海拔点，动态记录最大高度。循环结束输出最大高度即可。
+
+## 代码
+
+```go
+package leetcode
+
+func largestAltitude(gain []int) int {
+ max, height := 0, 0
+ for _, g := range gain {
+ height += g
+ if height > max {
+ max = height
+ }
+ }
+ return max
+}
+```
+# [1734. Decode XORed Permutation](https://leetcode.com/problems/decode-xored-permutation/)
+
+
+## 题目
+
+There is an integer array `perm` that is a permutation of the first `n` positive integers, where `n` is always **odd**.
+
+It was encoded into another integer array `encoded` of length `n - 1`, such that `encoded[i] = perm[i] XOR perm[i + 1]`. For example, if `perm = [1,3,2]`, then `encoded = [2,1]`.
+
+Given the `encoded` array, return *the original array* `perm`. It is guaranteed that the answer exists and is unique.
+
+**Example 1:**
+
+```
+Input: encoded = [3,1]
+Output: [1,2,3]
+Explanation: If perm = [1,2,3], then encoded = [1 XOR 2,2 XOR 3] = [3,1]
+
+```
+
+**Example 2:**
+
+```
+Input: encoded = [6,5,4,6]
+Output: [2,4,1,5,3]
+
+```
+
+**Constraints:**
+
+- `3 <= n < 10^5`
+- `n` is odd.
+- `encoded.length == n - 1`
+
+## 题目大意
+
+给你一个整数数组 perm ，它是前 n 个正整数的排列，且 n 是个奇数 。它被加密成另一个长度为 n - 1 的整数数组 encoded ，满足 encoded[i] = perm[i] XOR perm[i + 1] 。比方说，如果 perm = [1,3,2] ，那么 encoded = [2,1] 。给你 encoded 数组，请你返回原始数组 perm 。题目保证答案存在且唯一。
+
+## 解题思路
+
+- 这一题与第 136 题和第 137 题思路类似，借用 `x ^ x = 0` 这个性质解题。依题意，原数组 perm 是 n 个正整数，即取值在 `[1,n+1]` 区间内，但是排列顺序未知。可以考虑先将 `[1,n+1]` 区间内的所有数异或得到 total。再将 encoded 数组中奇数下标的元素异或得到 odd：
+
+ {{< katex display >}}
+ \begin{aligned}odd &= encoded[1] + encoded[3] + ... + encoded[n-1]\\&= (perm[1] \,\, XOR \,\, perm[2]) + (perm[3] \,\, XOR \,\, perm[4]) + ... + (perm[n-1] \,\, XOR \,\, perm[n])\end{aligned}
+ {{< /katex >}}
+
+ total 是 n 个正整数异或全集，odd 是 `n-1` 个正整数异或集。两者异或 `total ^ odd` 得到的值必定是 perm[0]，因为 `x ^ x = 0`，那么重复出现的元素被异或以后消失了。算出 perm[0] 就好办了。
+
+ {{< katex display >}}
+ \begin{aligned}encoded[0] &= perm[0] \,\, XOR \,\, perm[1]\\perm[0] \,\, XOR \,\, encoded[0] &= perm[0] \,\, XOR \,\, perm[0] \,\, XOR \,\, perm[1] = perm[1]\\perm[1] \,\, XOR \,\, encoded[1] &= perm[1] \,\, XOR \,\, perm[1] \,\, XOR \,\, perm[2] = perm[2]\\...\\perm[n-1] \,\, XOR \,\, encoded[n-1] &= perm[n-1] \,\, XOR \,\, perm[n-1] \,\, XOR \,\, perm[n] = perm[n]\\\end{aligned}
+ {{< /katex >}}
+
+ 依次类推，便可以推出原数组 perm 中的所有数。
+
+## 代码
+
+```go
+package leetcode
+
+func decode(encoded []int) []int {
+ n, total, odd := len(encoded), 0, 0
+ for i := 1; i <= n+1; i++ {
+ total ^= i
+ }
+ for i := 1; i < n; i += 2 {
+ odd ^= encoded[i]
+ }
+ perm := make([]int, n+1)
+ perm[0] = total ^ odd
+ for i, v := range encoded {
+ perm[i+1] = perm[i] ^ v
+ }
+ return perm
+}
+```
+# [1736. Latest Time by Replacing Hidden Digits](https://leetcode.com/problems/latest-time-by-replacing-hidden-digits/)
+
+
+## 题目
+
+You are given a string `time` in the form of `hh:mm`, where some of the digits in the string are hidden (represented by `?`).
+
+The valid times are those inclusively between `00:00` and `23:59`.
+
+Return *the latest valid time you can get from* `time` *by replacing the hidden* *digits*.
+
+**Example 1:**
+
+```
+Input: time = "2?:?0"
+Output: "23:50"
+Explanation: The latest hour beginning with the digit '2' is 23 and the latest minute ending with the digit '0' is 50.
+```
+
+**Example 2:**
+
+```
+Input: time = "0?:3?"
+Output: "09:39"
+```
+
+**Example 3:**
+
+```
+Input: time = "1?:22"
+Output: "19:22"
+```
+
+**Constraints:**
+
+- `time` is in the format `hh:mm`.
+- It is guaranteed that you can produce a valid time from the given string.
+
+## 题目大意
+
+给你一个字符串 time ，格式为 hh:mm（小时：分钟），其中某几位数字被隐藏（用 ? 表示）。有效的时间为 00:00 到 23:59 之间的所有时间，包括 00:00 和 23:59 。替换 time 中隐藏的数字，返回你可以得到的最晚有效时间。
+
+## 解题思路
+
+- 简单题。根据题意，需要找到最晚的有效时间。枚举时间 4 个位置即可。如果第 3 个位置是 ？，那么它最晚时间是 5；如果第 4 个位置是 ？，那么它最晚时间是 9；如果第 2 个位置是 ？，那么它最晚时间是 9；如果第 1 个位置是 ？，根据第 2 个位置判断，如果第 2 个位置是大于 3 的数，那么第一个位置最晚时间是 1，如果第 2 个位置是小于 3 的数那么第一个位置最晚时间是 2 。按照上述规则即可还原最晚时间。
+
+## 代码
+
+```go
+package leetcode
+
+func maximumTime(time string) string {
+ timeb := []byte(time)
+ if timeb[3] == '?' {
+ timeb[3] = '5'
+ }
+ if timeb[4] == '?' {
+ timeb[4] = '9'
+ }
+ if timeb[0] == '?' {
+ if int(timeb[1]-'0') > 3 && int(timeb[1]-'0') < 10 {
+ timeb[0] = '1'
+ } else {
+ timeb[0] = '2'
+ }
+ }
+ if timeb[1] == '?' {
+ timeb[1] = '9'
+ }
+ if timeb[0] == '2' && timeb[1] == '9' {
+ timeb[1] = '3'
+ }
+ return string(timeb)
+}
+```
+# [1738. Find Kth Largest XOR Coordinate Value](https://leetcode.com/problems/find-kth-largest-xor-coordinate-value/)
+
+
+## 题目
+
+You are given a 2D `matrix` of size `m x n`, consisting of non-negative integers. You are also given an integer `k`.
+
+The **value** of coordinate `(a, b)` of the matrix is the XOR of all `matrix[i][j]` where `0 <= i <= a < m` and `0 <= j <= b < n` **(0-indexed)**.
+
+Find the `kth` largest value **(1-indexed)** of all the coordinates of `matrix`.
+
+**Example 1:**
+
+```
+Input: matrix = [[5,2],[1,6]], k = 1
+Output: 7
+Explanation: The value of coordinate (0,1) is 5 XOR 2 = 7, which is the largest value.
+```
+
+**Example 2:**
+
+```
+Input: matrix = [[5,2],[1,6]], k = 2
+Output: 5
+Explanation:The value of coordinate (0,0) is 5 = 5, which is the 2nd largest value.
+```
+
+**Example 3:**
+
+```
+Input: matrix = [[5,2],[1,6]], k = 3
+Output: 4
+Explanation: The value of coordinate (1,0) is 5 XOR 1 = 4, which is the 3rd largest value.
+```
+
+**Example 4:**
+
+```
+Input: matrix = [[5,2],[1,6]], k = 4
+Output: 0
+Explanation: The value of coordinate (1,1) is 5 XOR 2 XOR 1 XOR 6 = 0, which is the 4th largest value.
+```
+
+**Constraints:**
+
+- `m == matrix.length`
+- `n == matrix[i].length`
+- `1 <= m, n <= 1000`
+- `0 <= matrix[i][j] <= 10^6`
+- `1 <= k <= m * n`
+
+## 题目大意
+
+给你一个二维矩阵 matrix 和一个整数 k ，矩阵大小为 m x n 由非负整数组成。矩阵中坐标 (a, b) 的 值 可由对所有满足 0 <= i <= a < m 且 0 <= j <= b < n 的元素 matrix[i][j]（下标从 0 开始计数）执行异或运算得到。请你找出 matrix 的所有坐标中第 k 大的值（k 的值从 1 开始计数）。
+
+## 解题思路
+
+- 区间异或结果类比于区间二维前缀和。只不过需要注意 x^x = 0 这一性质。举例：
+
+ 
+
+ 通过简单推理，可以得出区间二维前缀和 preSum 的递推式。具体代码见解法二。
+
+- 上面的解法中，preSum 用二维数组计算的。能否再优化空间复杂度，降低成 O(n)？答案是可以的。通过观察可以发现。preSum 可以按照一行一行来生成。先生成 preSum 前一行，下一行生成过程中会用到前一行的信息，异或计算以后，可以覆盖原数据(前一行的信息)，对之后的计算没有影响。这个优化空间复杂度的方法和优化 DP 空间复杂度是完全一样的思路和方法。
+
+ 
+
+ 具体代码见解法一。
+
+- 计算出了 preSum，还需要考虑如何输出第 k 大的值。有 3 种做法，第一种是排序，第二种是优先队列，第三种是第 215 题中的 O(n) 的 partition 方法。时间复杂度最低的当然是 O(n)。但是经过实际测试，runtime 最优的是排序的方法。所以笔者以下两种方法均采用了排序的方法。
+
+## 代码
+
+```go
+package leetcode
+
+import "sort"
+
+// 解法一 压缩版的前缀和
+func kthLargestValue(matrix [][]int, k int) int {
+ if len(matrix) == 0 || len(matrix[0]) == 0 {
+ return 0
+ }
+ res, prefixSum := make([]int, 0, len(matrix)*len(matrix[0])), make([]int, len(matrix[0]))
+ for i := range matrix {
+ line := 0
+ for j, v := range matrix[i] {
+ line ^= v
+ prefixSum[j] ^= line
+ res = append(res, prefixSum[j])
+ }
+ }
+ sort.Ints(res)
+ return res[len(res)-k]
+}
+
+// 解法二 前缀和
+func kthLargestValue1(matrix [][]int, k int) int {
+ nums, prefixSum := []int{}, make([][]int, len(matrix)+1)
+ prefixSum[0] = make([]int, len(matrix[0])+1)
+ for i, row := range matrix {
+ prefixSum[i+1] = make([]int, len(matrix[0])+1)
+ for j, val := range row {
+ prefixSum[i+1][j+1] = prefixSum[i+1][j] ^ prefixSum[i][j+1] ^ prefixSum[i][j] ^ val
+ nums = append(nums, prefixSum[i+1][j+1])
+ }
+ }
+ sort.Ints(nums)
+ return nums[len(nums)-k]
+}
+```
+# [1742. Maximum Number of Balls in a Box](https://leetcode.com/problems/maximum-number-of-balls-in-a-box/)
+
+
+## 题目
+
+You are working in a ball factory where you have `n` balls numbered from `lowLimit` up to `highLimit` **inclusive** (i.e., `n == highLimit - lowLimit + 1`), and an infinite number of boxes numbered from `1` to `infinity`.
+
+Your job at this factory is to put each ball in the box with a number equal to the sum of digits of the ball's number. For example, the ball number `321` will be put in the box number `3 + 2 + 1 = 6` and the ball number `10` will be put in the box number `1 + 0 = 1`.
+
+Given two integers `lowLimit` and `highLimit`, return *the number of balls in the box with the most balls.*
+
+**Example 1:**
+
+```
+Input: lowLimit = 1, highLimit = 10
+Output: 2
+Explanation:
+Box Number: 1 2 3 4 5 6 7 8 9 10 11 ...
+Ball Count: 2 1 1 1 1 1 1 1 1 0 0 ...
+Box 1 has the most number of balls with 2 balls.
+```
+
+**Example 2:**
+
+```
+Input: lowLimit = 5, highLimit = 15
+Output: 2
+Explanation:
+Box Number: 1 2 3 4 5 6 7 8 9 10 11 ...
+Ball Count: 1 1 1 1 2 2 1 1 1 0 0 ...
+Boxes 5 and 6 have the most number of balls with 2 balls in each.
+
+```
+
+**Example 3:**
+
+```
+Input: lowLimit = 19, highLimit = 28
+Output: 2
+Explanation:
+Box Number: 1 2 3 4 5 6 7 8 9 10 11 12 ...
+Ball Count: 0 1 1 1 1 1 1 1 1 2 0 0 ...
+Box 10 has the most number of balls with 2 balls.
+
+```
+
+**Constraints:**
+
+- `1 <= lowLimit <= highLimit <= 10^5`
+
+## 题目大意
+
+你在一家生产小球的玩具厂工作，有 n 个小球，编号从 lowLimit 开始，到 highLimit 结束（包括 lowLimit 和 highLimit ，即 n == highLimit - lowLimit + 1）。另有无限数量的盒子，编号从 1 到 infinity 。你的工作是将每个小球放入盒子中，其中盒子的编号应当等于小球编号上每位数字的和。例如，编号 321 的小球应当放入编号 3 + 2 + 1 = 6 的盒子，而编号 10 的小球应当放入编号 1 + 0 = 1 的盒子。
+
+给你两个整数 lowLimit 和 highLimit ，返回放有最多小球的盒子中的小球数量。如果有多个盒子都满足放有最多小球，只需返回其中任一盒子的小球数量。
+
+## 解题思路
+
+- 简单题。循环遍历一遍数组，依次计算出所有小球的编号各位数字累加和，并且动态维护放有小球最多的数目。循环结束，输出最多小球个数即可。
+
+## 代码
+
+```go
+package leetcode
+
+func countBalls(lowLimit int, highLimit int) int {
+ buckets, maxBall := [46]int{}, 0
+ for i := lowLimit; i <= highLimit; i++ {
+ t := 0
+ for j := i; j > 0; {
+ t += j % 10
+ j = j / 10
+ }
+ buckets[t]++
+ if buckets[t] > maxBall {
+ maxBall = buckets[t]
+ }
+ }
+ return maxBall
+}
+```
+# [1744. Can You Eat Your Favorite Candy on Your Favorite Day?](https://leetcode.com/problems/can-you-eat-your-favorite-candy-on-your-favorite-day/)
+
+## 题目
+
+You are given a **(0-indexed)** array of positive integers `candiesCount` where `candiesCount[i]` represents the number of candies of the `ith` type you have. You are also given a 2D array `queries` where `queries[i] = [favoriteTypei, favoriteDayi, dailyCapi]`.
+
+You play a game with the following rules:
+
+- You start eating candies on day **`0`**.
+- You **cannot** eat **any** candy of type `i` unless you have eaten **all** candies of type `i - 1`.
+- You must eat **at least** **one** candy per day until you have eaten all the candies.
+
+Construct a boolean array `answer` such that `answer.length == queries.length` and `answer[i]` is `true` if you can eat a candy of type `favoriteTypei` on day `favoriteDayi` without eating **more than** `dailyCapi` candies on **any** day, and `false` otherwise. Note that you can eat different types of candy on the same day, provided that you follow rule 2.
+
+Return *the constructed array* `answer`.
+
+**Example 1:**
+
+```
+Input: candiesCount = [7,4,5,3,8], queries = [[0,2,2],[4,2,4],[2,13,1000000000]]
+Output: [true,false,true]
+Explanation:
+1- If you eat 2 candies (type 0) on day 0 and 2 candies (type 0) on day 1, you will eat a candy of type 0 on day 2.
+2- You can eat at most 4 candies each day.
+ If you eat 4 candies every day, you will eat 4 candies (type 0) on day 0 and 4 candies (type 0 and type 1) on day 1.
+ On day 2, you can only eat 4 candies (type 1 and type 2), so you cannot eat a candy of type 4 on day 2.
+3- If you eat 1 candy each day, you will eat a candy of type 2 on day 13.
+```
+
+**Example 2:**
+
+```
+Input: candiesCount = [5,2,6,4,1], queries = [[3,1,2],[4,10,3],[3,10,100],[4,100,30],[1,3,1]]
+Output: [false,true,true,false,false]
+```
+
+**Constraints:**
+
+- `1 <= candiesCount.length <= 105`
+- `1 <= candiesCount[i] <= 105`
+- `1 <= queries.length <= 105`
+- `queries[i].length == 3`
+- `0 <= favoriteTypei < candiesCount.length`
+- `0 <= favoriteDayi <= 109`
+- `1 <= dailyCapi <= 109`
+
+## 题目大意
+
+给你一个下标从 0 开始的正整数数组 candiesCount ，其中 candiesCount[i] 表示你拥有的第 i 类糖果的数目。同时给你一个二维数组 queries ，其中 queries[i] = [favoriteTypei, favoriteDayi, dailyCapi] 。你按照如下规则进行一场游戏：
+
+- 你从第 0 天开始吃糖果。
+- 你在吃完 所有 第 i - 1 类糖果之前，不能 吃任何一颗第 i 类糖果。
+- 在吃完所有糖果之前，你必须每天 至少 吃 一颗 糖果。
+
+请你构建一个布尔型数组 answer ，满足 answer.length == queries.length 。answer[i] 为 true 的条件是：在每天吃 不超过 dailyCapi 颗糖果的前提下，你可以在第 favoriteDayi 天吃到第 favoriteTypei 类糖果；否则 answer[i] 为 false 。注意，只要满足上面 3 条规则中的第二条规则，你就可以在同一天吃不同类型的糖果。请你返回得到的数组 answer 。
+
+## 解题思路
+
+- 每天吃糖个数的下限是 1 颗，上限是 dailyCap。针对每一个 query 查询在第 i 天能否吃到 i 类型的糖果，要想吃到 i 类型的糖果，必须吃完 i-1 类型的糖果。意味着在 [favoriteDayi + 1, (favoriteDayi+1)×dailyCapi] 区间内能否包含一颗第 favoriteTypei 类型的糖果。如果能包含则输出 true，不能包含则输出 false。吃的糖果数是累积的，所以这里利用前缀和计算出累积吃糖果数所在区间 [sum[favoriteTypei−1]+1, sum[favoriteTypei]]。最后判断 query 区间和累积吃糖果数的区间是否有重叠即可。如果重叠即输出 true。
+- 判断两个区间是否重合，情况有好几种：内包含，全包含，半包含等等。没有交集的情况比较少，所以可以用排除法。对于区间 [x1, y1] 以及 [x2, y2]，它们没有交集当且仅当 x1 > y2 或者 y1 < x2。
+
+## 代码
+
+```go
+package leetcode
+
+func canEat(candiesCount []int, queries [][]int) []bool {
+ n := len(candiesCount)
+ prefixSum := make([]int, n)
+ prefixSum[0] = candiesCount[0]
+ for i := 1; i < n; i++ {
+ prefixSum[i] = prefixSum[i-1] + candiesCount[i]
+ }
+ res := make([]bool, len(queries))
+ for i, q := range queries {
+ favoriteType, favoriteDay, dailyCap := q[0], q[1], q[2]
+ x1 := favoriteDay + 1
+ y1 := (favoriteDay + 1) * dailyCap
+ x2 := 1
+ if favoriteType > 0 {
+ x2 = prefixSum[favoriteType-1] + 1
+ }
+ y2 := prefixSum[favoriteType]
+ res[i] = !(x1 > y2 || y1 < x2)
+ }
+ return res
+}
+```
+# [1748. Sum of Unique Elements](https://leetcode.com/problems/sum-of-unique-elements/)
+
+
+## 题目
+
+You are given an integer array `nums`. The unique elements of an array are the elements that appear **exactly once** in the array.
+
+Return *the **sum** of all the unique elements of* `nums`.
+
+**Example 1:**
+
+```
+Input: nums = [1,2,3,2]
+Output: 4
+Explanation: The unique elements are [1,3], and the sum is 4.
+```
+
+**Example 2:**
+
+```
+Input: nums = [1,1,1,1,1]
+Output: 0
+Explanation: There are no unique elements, and the sum is 0.
+```
+
+**Example 3:**
+
+```
+Input: nums = [1,2,3,4,5]
+Output: 15
+Explanation: The unique elements are [1,2,3,4,5], and the sum is 15.
+```
+
+**Constraints:**
+
+- `1 <= nums.length <= 100`
+- `1 <= nums[i] <= 100`
+
+## 题目大意
+
+给你一个整数数组 `nums` 。数组中唯一元素是那些只出现 **恰好一次** 的元素。请你返回 `nums` 中唯一元素的 **和** 。
+
+## 解题思路
+
+- 简单题。利用 map 统计出每个元素出现的频次。再累加所有频次为 1 的元素，最后输出累加和即可。
+
+## 代码
+
+```go
+package leetcode
+
+func sumOfUnique(nums []int) int {
+ freq, res := make(map[int]int), 0
+ for _, v := range nums {
+ if _, ok := freq[v]; !ok {
+ freq[v] = 0
+ }
+ freq[v]++
+ }
+ for k, v := range freq {
+ if v == 1 {
+ res += k
+ }
+ }
+ return res
+}
+```
+# [1752. Check if Array Is Sorted and Rotated](https://leetcode.com/problems/check-if-array-is-sorted-and-rotated/)
+
+
+## 题目
+
+Given an array `nums`, return `true` *if the array was originally sorted in non-decreasing order, then rotated **some** number of positions (including zero)*. Otherwise, return `false`.
+
+There may be **duplicates** in the original array.
+
+**Note:** An array `A` rotated by `x` positions results in an array `B` of the same length such that `A[i] == B[(i+x) % A.length]`, where `%` is the modulo operation.
+
+**Example 1:**
+
+```
+Input: nums = [3,4,5,1,2]
+Output: true
+Explanation: [1,2,3,4,5] is the original sorted array.
+You can rotate the array by x = 3 positions to begin on the the element of value 3: [3,4,5,1,2].
+```
+
+**Example 2:**
+
+```
+Input: nums = [2,1,3,4]
+Output: false
+Explanation: There is no sorted array once rotated that can make nums.
+```
+
+**Example 3:**
+
+```
+Input: nums = [1,2,3]
+Output: true
+Explanation: [1,2,3] is the original sorted array.
+You can rotate the array by x = 0 positions (i.e. no rotation) to make nums.
+```
+
+**Example 4:**
+
+```
+Input: nums = [1,1,1]
+Output: true
+Explanation: [1,1,1] is the original sorted array.
+You can rotate any number of positions to make nums.
+```
+
+**Example 5:**
+
+```
+Input: nums = [2,1]
+Output: true
+Explanation: [1,2] is the original sorted array.
+You can rotate the array by x = 5 positions to begin on the element of value 2: [2,1].
+```
+
+**Constraints:**
+
+- `1 <= nums.length <= 100`
+- `1 <= nums[i] <= 100`
+
+## 题目大意
+
+给你一个数组 nums 。nums 的源数组中，所有元素与 nums 相同，但按非递减顺序排列。如果 nums 能够由源数组轮转若干位置（包括 0 个位置）得到，则返回 true ；否则，返回 false 。源数组中可能存在 重复项 。
+
+## 解题思路
+
+- 简单题。从头扫描一遍数组，找出相邻两个元素递减的数对。如果递减的数对只有 1 个，则有可能是轮转得来的，超过 1 个，则返回 false。题干里面还提到可能有多个重复元素，针对这一情况还需要判断一下 `nums[0]` 和 `nums[len(nums)-1]` 。如果是相同元素，`nums[0] < nums[len(nums)-1]`，并且数组中间还存在一对递减的数对，这时候也是 false。判断好上述这 2 种情况，本题得解。
+
+## 代码
+
+```go
+package leetcode
+
+func check(nums []int) bool {
+ count := 0
+ for i := 0; i < len(nums)-1; i++ {
+ if nums[i] > nums[i+1] {
+ count++
+ if count > 1 || nums[0] < nums[len(nums)-1] {
+ return false
+ }
+ }
+ }
+ return true
+}
+```
+# [1758. Minimum Changes To Make Alternating Binary String](https://leetcode.com/problems/minimum-changes-to-make-alternating-binary-string/)
+
+
+## 题目
+
+You are given a string `s` consisting only of the characters `'0'` and `'1'`. In one operation, you can change any `'0'` to `'1'` or vice versa.
+
+The string is called alternating if no two adjacent characters are equal. For example, the string `"010"` is alternating, while the string `"0100"` is not.
+
+Return *the **minimum** number of operations needed to make* `s` *alternating*.
+
+**Example 1:**
+
+```
+Input: s = "0100"
+Output: 1
+Explanation: If you change the last character to '1', s will be "0101", which is alternating.
+```
+
+**Example 2:**
+
+```
+Input: s = "10"
+Output: 0
+Explanation: s is already alternating.
+```
+
+**Example 3:**
+
+```
+Input: s = "1111"
+Output: 2
+Explanation: You need two operations to reach "0101" or "1010".
+```
+
+**Constraints:**
+
+- `1 <= s.length <= 104`
+- `s[i]` is either `'0'` or `'1'`.
+
+## 题目大意
+
+你将得到一个仅包含字符“ 0”和“ 1”的字符串 `s`。 在一项操作中，你可以将任何 `'0'` 更改为 `'1'`，反之亦然。 如果两个相邻字符都不相等，则该字符串称为交替字符串。 例如，字符串“ 010”是交替的，而字符串“ 0100”则不是。 返回使 `s` 交替所需的最小操作数。
+
+## 解题思路
+
+- 简单题。利用数组下标奇偶交替性来判断交替字符串。交替字符串有 2 种，一个是 `'01010101……'` 还有一个是 `'1010101010……'`，这两个只需要计算出一个即可，另外一个利用 `len(s) - res` 就是答案。
+
+## 代码
+
+```go
+package leetcode
+
+func minOperations(s string) int {
+ res := 0
+ for i := 0; i < len(s); i++ {
+ if int(s[i]-'0') != i%2 {
+ res++
+ }
+ }
+ return min(res, len(s)-res)
+}
+
+func min(a, b int) int {
+ if a > b {
+ return b
+ }
+ return a
+}
+```
+# [1763. Longest Nice Substring](https://leetcode.com/problems/longest-nice-substring/)
+
+
+## 题目
+
+A string `s` is **nice** if, for every letter of the alphabet that `s` contains, it appears **both** in uppercase and lowercase. For example, `"abABB"` is nice because `'A'` and `'a'` appear, and `'B'` and `'b'` appear. However, `"abA"` is not because `'b'` appears, but `'B'` does not.
+
+Given a string `s`, return *the longest **substring** of `s` that is **nice**. If there are multiple, return the substring of the **earliest** occurrence. If there are none, return an empty string*.
+
+**Example 1:**
+
+```
+Input: s = "YazaAay"
+Output: "aAa"
+Explanation:"aAa" is a nice string because 'A/a' is the only letter of the alphabet in s, and both 'A' and 'a' appear.
+"aAa" is the longest nice substring.
+
+```
+
+**Example 2:**
+
+```
+Input: s = "Bb"
+Output: "Bb"
+Explanation: "Bb" is a nice string because both 'B' and 'b' appear. The whole string is a substring.
+
+```
+
+**Example 3:**
+
+```
+Input: s = "c"
+Output: ""
+Explanation: There are no nice substrings.
+
+```
+
+**Constraints:**
+
+- `1 <= s.length <= 100`
+- `s` consists of uppercase and lowercase English letters.
+
+## 题目大意
+
+当一个字符串 s 包含的每一种字母的大写和小写形式 同时 出现在 s 中，就称这个字符串 s 是 美好 字符串。比方说，"abABB" 是美好字符串，因为 'A' 和 'a' 同时出现了，且 'B' 和 'b' 也同时出现了。然而，"abA" 不是美好字符串因为 'b' 出现了，而 'B' 没有出现。
+
+给你一个字符串 s ，请你返回 s 最长的 美好子字符串 。如果有多个答案，请你返回 最早 出现的一个。如果不存在美好子字符串，请你返回一个空字符串。
+
+## 解题思路
+
+- 解法一，暴力解法。枚举每一段字符串，判断这个子字符串内是否满足美好字符串的定义，即字母的大小写是否同时出现。
+- 解法二，这个解法是解法一的小幅优化版，利用二进制记录状态。先构造二进制状态串，再利用直接比较这个二进制串。
+- 解法三，分治。以 `i` 为分割点依次切开字符串。左右两个字符串分别判断是否满足美好字符串的定义。左右分开的字符串还可以继续划分。直至分到一个字母为止。在这个过程中记录最早出现的字符串。
+
+## 代码
+
+```go
+package leetcode
+
+import "unicode"
+
+// 解法一 分治，时间复杂度 O(n)
+func longestNiceSubstring(s string) string {
+ if len(s) < 2 {
+ return ""
+ }
+
+ chars := map[rune]int{}
+ for _, r := range s {
+ chars[r]++
+ }
+
+ for i := 0; i < len(s); i++ {
+ r := rune(s[i])
+ _, u := chars[unicode.ToUpper(r)]
+ _, l := chars[unicode.ToLower(r)]
+ if u && l {
+ continue
+ }
+ left := longestNiceSubstring(s[:i])
+ right := longestNiceSubstring(s[i+1:])
+ if len(left) >= len(right) {
+ return left
+ } else {
+ return right
+ }
+ }
+ return s
+}
+
+// 解法二 用二进制表示状态
+func longestNiceSubstring1(s string) (ans string) {
+ for i := range s {
+ lower, upper := 0, 0
+ for j := i; j < len(s); j++ {
+ if unicode.IsLower(rune(s[j])) {
+ lower |= 1 << (s[j] - 'a')
+ } else {
+ upper |= 1 << (s[j] - 'A')
+ }
+ if lower == upper && j-i+1 > len(ans) {
+ ans = s[i : j+1]
+ }
+ }
+ }
+ return
+}
+
+// 解法三 暴力枚举，时间复杂度 O(n^2)
+func longestNiceSubstring2(s string) string {
+ res := ""
+ for i := 0; i < len(s); i++ {
+ m := map[byte]int{}
+ m[s[i]]++
+ for j := i + 1; j < len(s); j++ {
+ m[s[j]]++
+ if checkNiceString(m) && (j-i+1 > len(res)) {
+ res = s[i : j+1]
+ }
+ }
+ }
+ return res
+}
+
+func checkNiceString(m map[byte]int) bool {
+ for k := range m {
+ if k >= 97 && k <= 122 {
+ if _, ok := m[k-32]; !ok {
+ return false
+ }
+ }
+ if k >= 65 && k <= 90 {
+ if _, ok := m[k+32]; !ok {
+ return false
+ }
+ }
+ }
+ return true
+}
+```
+# [1791.Find Center of Star Graph](https://leetcode.com/problems/find-center-of-star-graph/)
+
+## 题目
+
+There is an undirected star graph consisting of n nodes labeled from 1 to n. A star graph is a graph where there is one center node and exactly n - 1 edges that connect the center node with every other node.
+
+You are given a 2D integer array edges where each edges[i] = [ui, vi] indicates that there is an edge between the nodes ui and vi. Return the center of the given star graph.
+
+**Example 1:**
+
+
+
+ Input: edges = [[1,2],[2,3],[4,2]]
+ Output: 2
+ Explanation: As shown in the figure above, node 2 is connected to every other node, so 2 is the center.
+
+**Example 2:**
+
+ Input: edges = [[1,2],[5,1],[1,3],[1,4]]
+ Output: 1
+
+**Constraints:**
+
+- 3 <= n <= 100000
+- edges.length == n - 1
+- edges[i].length == 2
+- 1 <= ui, vi <= n
+- ui != vi
+- The given edges represent a valid star graph.
+
+## 题目大意
+
+有一个无向的 星型 图，由 n 个编号从 1 到 n 的节点组成。星型图有一个 中心 节点，并且恰有 n - 1 条边将中心节点与其他每个节点连接起来。
+
+给你一个二维整数数组 edges ，其中 edges[i] = [ui, vi] 表示在节点 ui 和 vi 之间存在一条边。请你找出并返回 edges 所表示星型图的中心节点。
+
+## 解题思路
+
+- 求出edges中前两个元素的共同值，即是中心节点
+
+## 代码
+
+```go
+package leetcode
+
+func findCenter(edges [][]int) int {
+ if edges[0][0] == edges[1][0] || edges[0][0] == edges[1][1] {
+ return edges[0][0]
+ }
+ return edges[0][1]
+}
+```
+# [1816. Truncate Sentence](https://leetcode.com/problems/truncate-sentence/)
+
+## 题目
+
+A sentence is a list of words that are separated by a single space with no leading or trailing spaces. Each of the words consists of only uppercase and lowercase English letters (no punctuation).
+
+- For example, "Hello World", "HELLO", and "hello world hello world" are all sentences.
+
+You are given a sentence s and an integer k. You want to truncate s such that it contains only the first k words. Return s after truncating it.
+
+**Example 1**:
+
+ Input: s = "Hello how are you Contestant", k = 4
+ Output: "Hello how are you"
+ Explanation:
+ The words in s are ["Hello", "how" "are", "you", "Contestant"].
+ The first 4 words are ["Hello", "how", "are", "you"].
+ Hence, you should return "Hello how are you".
+
+**Example 2**:
+
+ Input: s = "What is the solution to this problem", k = 4
+ Output: "What is the solution"
+ Explanation:
+ The words in s are ["What", "is" "the", "solution", "to", "this", "problem"].
+ The first 4 words are ["What", "is", "the", "solution"].
+ Hence, you should return "What is the solution".
+
+**Example 3**:
+
+ Input: s = "chopper is not a tanuki", k = 5
+ Output: "chopper is not a tanuki"
+
+**Constraints:**
+
+- 1 <= s.length <= 500
+- k is in the range [1, the number of words in s].
+- s consist of only lowercase and uppercase English letters and spaces.
+- The words in s are separated by a single space.
+- There are no leading or trailing spaces.
+
+## 题目大意
+
+句子 是一个单词列表，列表中的单词之间用单个空格隔开，且不存在前导或尾随空格。每个单词仅由大小写英文字母组成（不含标点符号）。
+
+- 例如，"Hello World"、"HELLO" 和 "hello world hello world" 都是句子。
+
+给你一个句子 s 和一个整数 k ，请你将 s 截断使截断后的句子仅含前 k 个单词。返回截断 s 后得到的句子。
+
+## 解题思路
+
+- 遍历字符串 s，找到最后一个空格的下标 end
+- 如果 end 为 0，直接返回 s,否则返回 s[:end]
+
+## 代码
+
+```go
+package leetcode
+
+func truncateSentence(s string, k int) string {
+ end := 0
+ for i := range s {
+ if k > 0 && s[i] == ' ' {
+ k--
+ }
+ if k == 0 {
+ end = i
+ break
+ }
+ }
+ if end == 0 {
+ return s
+ }
+ return s[:end]
+}
+```
+# [1818. Minimum Absolute Sum Difference](https://leetcode.com/problems/minimum-absolute-sum-difference/)
+
+## 题目
+
+You are given two positive integer arrays `nums1` and `nums2`, both of length `n`.
+
+The **absolute sum difference** of arrays `nums1` and `nums2` is defined as the **sum** of `|nums1[i] - nums2[i]|` for each `0 <= i < n` (**0-indexed**).
+
+You can replace **at most one** element of `nums1` with **any** other element in `nums1` to **minimize** the absolute sum difference.
+
+Return the *minimum absolute sum difference **after** replacing at most one ****element in the array `nums1`.* Since the answer may be large, return it **modulo** `109 + 7`.
+
+`|x|` is defined as:
+
+- `x` if `x >= 0`, or
+- `x` if `x < 0`.
+
+**Example 1:**
+
+```
+Input: nums1 = [1,7,5], nums2 = [2,3,5]
+Output: 3
+Explanation:There are two possible optimal solutions:
+- Replace the second element with the first: [1,7,5] => [1,1,5], or
+- Replace the second element with the third: [1,7,5] => [1,5,5].
+Both will yield an absolute sum difference of|1-2| + (|1-3| or |5-3|) + |5-5| =3.
+
+```
+
+**Example 2:**
+
+```
+Input: nums1 = [2,4,6,8,10], nums2 = [2,4,6,8,10]
+Output: 0
+Explanation:nums1 is equal to nums2 so no replacement is needed. This will result in an
+absolute sum difference of 0.
+
+```
+
+**Example 3:**
+
+```
+Input: nums1 = [1,10,4,4,2,7], nums2 = [9,3,5,1,7,4]
+Output: 20
+Explanation:Replace the first element with the second: [1,10,4,4,2,7] => [10,10,4,4,2,7].
+This yields an absolute sum difference of|10-9| + |10-3| + |4-5| + |4-1| + |2-7| + |7-4| = 20
+```
+
+**Constraints:**
+
+- `n == nums1.length`
+- `n == nums2.length`
+- `1 <= n <= 10^5`
+- `1 <= nums1[i], nums2[i] <= 10^5`
+
+## 题目大意
+
+给你两个正整数数组 nums1 和 nums2 ，数组的长度都是 n 。数组 nums1 和 nums2 的 绝对差值和 定义为所有 |nums1[i] - nums2[i]|（0 <= i < n）的 总和（下标从 0 开始）。你可以选用 nums1 中的 任意一个 元素来替换 nums1 中的 至多 一个元素，以 最小化 绝对差值和。在替换数组 nums1 中最多一个元素 之后 ，返回最小绝对差值和。因为答案可能很大，所以需要对 10^9 + 7 取余 后返回。
+
+## 解题思路
+
+- 如果不改变任何元素，绝对差值和为 {{< katex >}} \sum \left | nums1[i] - nums2[i] \right | {{< /katex >}}。如果改变一个元素后，那么绝对差值和为
+ {{< katex display>}} \begin{aligned}&\sum \left | nums1[i] - nums2[i] \right | - \left ( \left | nums1[i] - nums2[i] \right | - \left | nums1[j] - nums2[i] \right |\right )\\= &\sum \left | nums1[i] - nums2[i] \right | - \Delta \end{aligned} {{< /katex >}}
+
+ 题目要求返回最小绝对差值和，即求 {{< katex >}}\Delta {{< /katex >}} 的最大值。暴力枚举 nums1 和 nums2 中两两差值，找到 maxdiff，即 {{< katex >}}\Delta {{< /katex >}} 的最大值，此题得到解。
+
+## 代码
+
+```go
+package leetcode
+
+func minAbsoluteSumDiff(nums1 []int, nums2 []int) int {
+ diff := 0
+ maxDiff := 0
+ for i, n2 := range nums2 {
+ d := abs(nums1[i] - n2)
+ diff += d
+ if maxDiff < d {
+ t := 100001
+ for _, n1 := range nums1 {
+ maxDiff = max(maxDiff, d-min(t, abs(n1-n2)))
+ }
+ }
+ }
+ return (diff - maxDiff) % (1e9 + 7)
+}
+
+func max(a, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+func abs(a int) int {
+ if a > 0 {
+ return a
+ }
+ return -a
+}
+
+func min(a, b int) int {
+ if a > b {
+ return b
+ }
+ return a
+}
+```
+# [1846. Maximum Element After Decreasing and Rearranging](https://leetcode.com/problems/maximum-element-after-decreasing-and-rearranging/)
+
+
+## 题目
+
+You are given an array of positive integers `arr`. Perform some operations (possibly none) on `arr` so that it satisfies these conditions:
+
+- The value of the **first** element in `arr` must be `1`.
+- The absolute difference between any 2 adjacent elements must be **less than or equal to** `1`. In other words, `abs(arr[i] - arr[i - 1]) <= 1` for each `i` where `1 <= i < arr.length` (**0-indexed**). `abs(x)` is the absolute value of `x`.
+
+There are 2 types of operations that you can perform any number of times:
+
+- **Decrease** the value of any element of `arr` to a **smaller positive integer**.
+- **Rearrange** the elements of `arr` to be in any order.
+
+Return *the **maximum** possible value of an element in* `arr` *after performing the operations to satisfy the conditions*.
+
+**Example 1:**
+
+```
+Input: arr = [2,2,1,2,1]
+Output: 2
+Explanation:
+We can satisfy the conditions by rearrangingarr so it becomes[1,2,2,2,1].
+The largest element inarr is 2.
+
+```
+
+**Example 2:**
+
+```
+Input: arr = [100,1,1000]
+Output: 3
+Explanation:
+One possible way to satisfy the conditions is by doing the following:
+1. Rearrangearr so it becomes[1,100,1000].
+2. Decrease the value of the second element to 2.
+3. Decrease the value of the third element to 3.
+Nowarr = [1,2,3], whichsatisfies the conditions.
+The largest element inarr is 3.
+```
+
+**Example 3:**
+
+```
+Input: arr = [1,2,3,4,5]
+Output: 5
+Explanation: The array already satisfies the conditions, and the largest element is 5.
+
+```
+
+**Constraints:**
+
+- `1 <= arr.length <= 10^5`
+- `1 <= arr[i] <= 10^9`
+
+## 题目大意
+
+给你一个正整数数组 arr 。请你对 arr 执行一些操作（也可以不进行任何操作），使得数组满足以下条件：
+
+- arr 中 第一个 元素必须为 1 。
+- 任意相邻两个元素的差的绝对值 小于等于 1 ，也就是说，对于任意的 1 <= i < arr.length （数组下标从 0 开始），都满足 abs(arr[i] - arr[i - 1]) <= 1 。abs(x) 为 x 的绝对值。
+
+你可以执行以下 2 种操作任意次：
+
+- 减小 arr 中任意元素的值，使其变为一个 更小的正整数 。
+- 重新排列 arr 中的元素，你可以以任意顺序重新排列。
+
+请你返回执行以上操作后，在满足前文所述的条件下，arr 中可能的 最大值 。
+
+## 解题思路
+
+- 正整数数组 arr 第一个元素必须为 1，且两两元素绝对值小于等于 1，那么 arr 最大值肯定不大于 n。采用贪心的策略，先统计所有元素出现的次数，大于 n 的元素出现次数都累加到 n 上。然后从 1 扫描到 n，遇到“空隙”（出现次数为 0 的元素），便将最近一个出现次数大于 1 的元素“挪”过来填补“空隙”。题目所求最大值出现在，“填补空隙”之后，数组从左往右连续的最右端。
+
+## 代码
+
+```go
+package leetcode
+
+func maximumElementAfterDecrementingAndRearranging(arr []int) int {
+ n := len(arr)
+ count := make([]int, n+1)
+ for _, v := range arr {
+ count[min(v, n)]++
+ }
+ miss := 0
+ for _, c := range count[1:] {
+ if c == 0 {
+ miss++
+ } else {
+ miss -= min(c-1, miss)
+ }
+ }
+ return n - miss
+}
+
+func min(a, b int) int {
+ if a < b {
+ return a
+ }
+ return b
+}
+```
+# [1877. Minimize Maximum Pair Sum in Array](https://leetcode.com/problems/minimize-maximum-pair-sum-in-array/)
+
+
+## 题目
+
+The **pair sum** of a pair `(a,b)` is equal to `a + b`. The **maximum pair sum** is the largest **pair sum** in a list of pairs.
+
+- For example, if we have pairs `(1,5)`, `(2,3)`, and `(4,4)`, the **maximum pair sum** would be `max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8`.
+
+Given an array `nums` of **even** length `n`, pair up the elements of `nums` into `n / 2` pairs such that:
+
+- Each element of `nums` is in **exactly one** pair, and
+- The **maximum pair sum** is **minimized**.
+
+Return *the minimized **maximum pair sum** after optimally pairing up the elements*.
+
+**Example 1:**
+
+```
+Input: nums = [3,5,2,3]
+Output: 7
+Explanation: The elements can be paired up into pairs (3,3) and (5,2).
+The maximum pair sum is max(3+3, 5+2) = max(6, 7) = 7.
+```
+
+**Example 2:**
+
+```
+Input: nums = [3,5,4,2,4,6]
+Output: 8
+Explanation: The elements can be paired up into pairs (3,5), (4,4), and (6,2).
+The maximum pair sum is max(3+5, 4+4, 6+2) = max(8, 8, 8) = 8.
+```
+
+**Constraints:**
+
+- `n == nums.length`
+- `2 <= n <= 105`
+- `n` is **even**.
+- `1 <= nums[i] <= 105`
+
+## 题目大意
+
+一个数对 (a,b) 的 **数对和** 等于 a + b 。**最大数对和** 是一个数对数组中最大的 数对和 。
+
+- 比方说，如果我们有数对 (1,5) ，(2,3) 和 (4,4)，**最大数对和** 为 max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8 。
+
+给你一个长度为 **偶数** n 的数组 nums ，请你将 nums 中的元素分成 n / 2 个数对，使得：
+
+- nums 中每个元素 **恰好** 在 一个 数对中，且
+- **最大数对和** 的值 **最小** 。
+
+请你在最优数对划分的方案下，返回最小的 最大数对和 。
+
+## 解题思路
+
+- 要想最大数对和最小，那么最大的元素一定只能和最小的元素组合在一起，不然一定不是最小。当最大元素和最小元素组合在一起了，剩下的次最大元素也应该和次最小元素组合在一起。按照这个思路，先将数组从小到大排序，然后依次取出首尾元素，两两组合在一起。输出这些数对的最大值即为所求。
+
+## 代码
+
+```go
+package leetcode
+
+import "sort"
+
+func minPairSum(nums []int) int {
+ sort.Ints(nums)
+ n, res := len(nums), 0
+ for i, val := range nums[:n/2] {
+ res = max(res, val+nums[n-1-i])
+ }
+ return res
+}
+
+func max(a, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+}
+```
+# [1984. Minimum Difference Between Highest and Lowest of K Scores](https://leetcode.com/problems/minimum-difference-between-highest-and-lowest-of-k-scores/)
+
+## 题目
+
+You are given a 0-indexed integer array nums, where nums[i] represents the score of the ith student. You are also given an integer k.
+
+Pick the scores of any k students from the array so that the difference between the highest and the lowest of the k scores is minimized.
+
+Return the minimum possible difference.
+
+**Example 1:**
+
+ Input: nums = [90], k = 1
+ Output: 0
+ Explanation: There is one way to pick score(s) of one student:
+ - [90]. The difference between the highest and lowest score is 90 - 90 = 0.
+ The minimum possible difference is 0.
+
+**Example 2:**
+
+ Input: nums = [9,4,1,7], k = 2
+ Output: 2
+ Explanation: There are six ways to pick score(s) of two students:
+ - [9,4,1,7]. The difference between the highest and lowest score is 9 - 4 = 5.
+ - [9,4,1,7]. The difference between the highest and lowest score is 9 - 1 = 8.
+ - [9,4,1,7]. The difference between the highest and lowest score is 9 - 7 = 2.
+ - [9,4,1,7]. The difference between the highest and lowest score is 4 - 1 = 3.
+ - [9,4,1,7]. The difference between the highest and lowest score is 7 - 4 = 3.
+ - [9,4,1,7]. The difference between the highest and lowest score is 7 - 1 = 6.
+ The minimum possible difference is 2.
+
+**Constraints:**
+
+- 1 <= k <= nums.length <= 1000
+- 0 <= nums[i] <= 100000
+
+## 题目大意
+
+给你一个下标从 0 开始的整数数组 nums ，其中 nums[i] 表示第 i 名学生的分数。另给你一个整数 k 。
+
+从数组中选出任意 k 名学生的分数，使这 k 个分数间最高分和最低分的差值达到最小化 。
+
+返回可能的最小差值 。
+
+## 解题思路
+
+- nums 排序
+- 求出nums[i+k-1] - nums[i]中的最小差值
+
+## 代码
+
+```go
+package leetcode
+
+import "sort"
+
+func minimumDifference(nums []int, k int) int {
+ sort.Ints(nums)
+ minDiff := 100000 + 1
+ for i := 0; i < len(nums); i++ {
+ if i+k-1 >= len(nums) {
+ break
+ }
+ diff := nums[i+k-1] - nums[i]
+ if diff < minDiff {
+ minDiff = diff
+ }
+ }
+ return minDiff
+}
+```
+# [2021. Brightest Position on Street](https://leetcode.com/problems/brightest-position-on-street/)
+
+
+## 题目
+
+A perfectly straight street is represented by a number line. The street has street lamp(s) on it and is represented by a 2D integer array `lights`. Each `lights[i] = [positioni, rangei]` indicates that there is a street lamp at position `positioni` that lights up the area from `[positioni - rangei, positioni + rangei]` (**inclusive**).
+
+The **brightness** of a position `p` is defined as the number of street lamp that light up the position `p`.
+
+Given `lights`, return *the **brightest** position on the street. If there are multiple brightest positions, return the **smallest** one.*
+
+**Example 1:**
+
+
+
+```
+Input: lights = [[-3,2],[1,2],[3,3]]
+Output: -1
+Explanation:
+The first street lamp lights up the area from [(-3) - 2, (-3) + 2] = [-5, -1].
+The second street lamp lights up the area from [1 - 2, 1 + 2] = [-1, 3].
+The third street lamp lights up the area from [3 - 3, 3 + 3] = [0, 6].
+
+Position -1 has a brightness of 2, illuminated by the first and second street light.
+Positions 0, 1, 2, and 3 have a brightness of 2, illuminated by the second and third street light.
+Out of all these positions, -1 is the smallest, so return it.
+
+```
+
+**Example 2:**
+
+```
+Input: lights = [[1,0],[0,1]]
+Output: 1
+Explanation:
+The first street lamp lights up the area from [1 - 0, 1 + 0] = [1, 1].
+The second street lamp lights up the area from [0 - 1, 0 + 1] = [-1, 1].
+
+Position 1 has a brightness of 2, illuminated by the first and second street light.
+Return 1 because it is the brightest position on the street.
+
+```
+
+**Example 3:**
+
+```
+Input: lights = [[1,2]]
+Output: -1
+Explanation:
+The first street lamp lights up the area from [1 - 2, 1 + 2] = [-1, 3].
+
+Positions -1, 0, 1, 2, and 3 have a brightness of 1, illuminated by the first street light.
+Out of all these positions, -1 is the smallest, so return it.
+
+```
+
+**Constraints:**
+
+- `1 <= lights.length <= 105`
+- `lights[i].length == 2`
+- `108 <= positioni <= 108`
+- `0 <= rangei <= 108`
+
+## 题目大意
+
+一条完全笔直的街道由一条数字线表示。街道上有路灯，由二维数据表示。每个 `lights[i] = [positioni, rangei]` 表示位置 `i` 处有一盏路灯，灯可以照亮从 `[positioni - rangei, positioni + rangei]` （含）的区域。 位置 `p` 的亮度定义为点亮位置 `p` 的路灯数量。 给定路灯，返回街道上最亮的位置。如果有多个最亮的位置，则返回最小的一个。
+
+## 解题思路
+
+- 先将每个路灯的起始和终点位置计算出来。这样我们得到了一堆坐标点。假设灯照亮的范围是 [A, B]，那么在坐标轴上 A 坐标点处 + 1， B + 1 坐标点处 -1 。这样处理的含义是：坐标点 A 可以被一盏灯照亮，所以它照亮次数加一，坐标点 B + 1 出了灯照亮的范围了，所以照亮次数减一。那么从坐标轴坐标开始扫一遍，每次遇到 + 1 的时候就 + 1，遇到 - 1 的地方就 - 1。如此可以算出某个坐标点处，可以被灯照亮的总次数。
+- 需要注意的点是，题目给的测试数据可能会有单点照亮的情况，即某一盏灯只照亮一个坐标点，灯照范围为 0。同一个坐标点也可能是多个灯的起点。用一个 map 去重坐标点即可。
+
+## 代码
+
+```go
+package leetcode
+
+import (
+ "sort"
+)
+
+type lightItem struct {
+ index int
+ sign int
+}
+
+func brightestPosition(lights [][]int) int {
+ lightMap, lightItems := map[int]int{}, []lightItem{}
+ for _, light := range lights {
+ lightMap[light[0]-light[1]] += 1
+ lightMap[light[0]+light[1]+1] -= 1
+ }
+ for k, v := range lightMap {
+ lightItems = append(lightItems, lightItem{index: k, sign: v})
+ }
+ sort.SliceStable(lightItems, func(i, j int) bool {
+ return lightItems[i].index < lightItems[j].index
+ })
+ res, border, tmp := 0, 0, 0
+ for _, v := range lightItems {
+ tmp += v.sign
+ if border < tmp {
+ res = v.index
+ border = tmp
+ }
+ }
+ return res
+}
+```
+# [2022. Convert 1D Array Into 2D Array](https://leetcode.com/problems/convert-1d-array-into-2d-array/)
+
+## 题目
+
+You are given a **0-indexed** 1-dimensional (1D) integer array `original`, and two integers, `m` and `n`. You are tasked with creating a 2-dimensional (2D) array with `m` rows and `n` columns using **all** the elements from `original`.
+
+The elements from indices `0` to `n - 1` (**inclusive**) of `original` should form the first row of the constructed 2D array, the elements from indices `n` to `2 * n - 1` (**inclusive**) should form the second row of the constructed 2D array, and so on.
+
+Return *an* `m x n` *2D array constructed according to the above procedure, or an empty 2D array if it is impossible*.
+
+**Example 1:**
+
+
+
+```
+Input: original = [1,2,3,4], m = 2, n = 2
+Output: [[1,2],[3,4]]
+Explanation: The constructed 2D array should contain 2 rows and 2 columns.
+The first group of n=2 elements in original, [1,2], becomes the first row in the constructed 2D array.
+The second group of n=2 elements in original, [3,4], becomes the second row in the constructed 2D array.
+
+```
+
+**Example 2:**
+
+```
+Input: original = [1,2,3], m = 1, n = 3
+Output: [[1,2,3]]
+Explanation: The constructed 2D array should contain 1 row and 3 columns.
+Put all three elements in original into the first row of the constructed 2D array.
+
+```
+
+**Example 3:**
+
+```
+Input: original = [1,2], m = 1, n = 1
+Output: []
+Explanation: There are 2 elements in original.
+It is impossible to fit 2 elements in a 1x1 2D array, so return an empty 2D array.
+
+```
+
+**Constraints:**
+
+- `1 <= original.length <= 5 * 104`
+- `1 <= original[i] <= 105`
+- `1 <= m, n <= 4 * 104`
+
+## 题目大意
+
+给你一个下标从 0 开始的一维整数数组 original 和两个整数 m 和 n 。你需要使用 original 中 所有 元素创建一个 m 行 n 列的二维数组。
+
+original 中下标从 0 到 n - 1 （都 包含 ）的元素构成二维数组的第一行，下标从 n 到 2 * n - 1 （都 包含 ）的元素构成二维数组的第二行，依此类推。
+
+请你根据上述过程返回一个 m x n 的二维数组。如果无法构成这样的二维数组，请你返回一个空的二维数组。
+
+## 解题思路
+
+- 简单题。从一维数组 original 中依次取出每行 n 个元素，顺序放到 m 行中。此题中，如果 m*n 大于或者小于 original 的长度，都输出空数组。
+
+## 代码
+
+```go
+package leetcode
+
+func construct2DArray(original []int, m int, n int) [][]int {
+ if m*n != len(original) {
+ return [][]int{}
+ }
+ res := make([][]int, m)
+ for i := 0; i < m; i++ {
+ res[i] = original[n*i : n*(i+1)]
+ }
+ return res
+}
+```
+# [2037. Minimum Number of Moves to Seat Everyone](https://leetcode.com/problems/minimum-number-of-moves-to-seat-everyone/)
+
+## 题目
+
+There are n seats and n students in a room. You are given an array seats of length n, where seats[i] is the position of the ith seat. You are also given the array students of length n, where students[j] is the position of the jth student.
+
+You may perform the following move any number of times:
+
+- Increase or decrease the position of the ith student by 1 (i.e., moving the ith student from position x to x + 1 or x - 1)
+
+Return the minimum number of moves required to move each student to a seat such that no two students are in the same seat.
+
+Note that there may be multiple seats or students in the same position at the beginning.
+
+**Example 1:**
+
+ Input: seats = [3,1,5], students = [2,7,4]
+ Output: 4
+ Explanation: The students are moved as follows:
+ - The first student is moved from from position 2 to position 1 using 1 move.
+ - The second student is moved from from position 7 to position 5 using 2 moves.
+ - The third student is moved from from position 4 to position 3 using 1 move.
+ In total, 1 + 2 + 1 = 4 moves were used.
+
+**Example 2:**
+
+ Input: seats = [4,1,5,9], students = [1,3,2,6]
+ Output: 7
+ Explanation: The students are moved as follows:
+ - The first student is not moved.
+ - The second student is moved from from position 3 to position 4 using 1 move.
+ - The third student is moved from from position 2 to position 5 using 3 moves.
+ - The fourth student is moved from from position 6 to position 9 using 3 moves.
+ In total, 0 + 1 + 3 + 3 = 7 moves were used.
+
+**Example 3:**
+
+ Input: seats = [2,2,6,6], students = [1,3,2,6]
+ Output: 4
+ Explanation: Note that there are two seats at position 2 and two seats at position 6.
+ The students are moved as follows:
+ - The first student is moved from from position 1 to position 2 using 1 move.
+ - The second student is moved from from position 3 to position 6 using 3 moves.
+ - The third student is not moved.
+ - The fourth student is not moved.
+ In total, 1 + 3 + 0 + 0 = 4 moves were used.
+
+**Constraints:**
+
+- n == seats.length == students.length
+- 1 <= n <= 100
+- 1 <= seats[i], students[j] <= 100
+
+## 题目大意
+
+一个房间里有 n 个座位和 n 名学生，房间用一个数轴表示。给你一个长度为 n 的数组 seats，其中 seats[i] 是第 i 个座位的位置。同时给你一个长度为 n 的数组 students ，其中 students[j] 是第 j 位学生的位置。
+
+你可以执行以下操作任意次：
+
+增加或者减少第 i 位学生的位置，每次变化量为 1（也就是将第 i 位学生从位置 x 移动到 x + 1或者 x - 1）
+
+请你返回使所有学生都有座位坐的最少移动次数，并确保没有两位学生的座位相同。
+
+请注意，初始时有可能有多个座位或者多位学生在 同一位置。
+
+## 解题思路
+
+- 排序+模拟计算
+
+# 代码
+
+```go
+package leetcode
+
+import "sort"
+
+func minMovesToSeat(seats []int, students []int) int {
+ sort.Ints(seats)
+ sort.Ints(students)
+ n := len(students)
+ moves := 0
+ for i := 0; i < n; i++ {
+ moves += abs(seats[i], students[i])
+ }
+ return moves
+}
+
+func abs(a, b int) int {
+ if a > b {
+ return a - b
+ }
+ return b - a
+}
+```
+# [2038. Remove Colored Pieces if Both Neighbors are the Same Color](https://leetcode.com/problems/remove-colored-pieces-if-both-neighbors-are-the-same-color/)
+
+## 题目
+
+There are n pieces arranged in a line, and each piece is colored either by 'A' or by 'B'. You are given a string colors of length n where colors[i] is the color of the ith piece.
+
+Alice and Bob are playing a game where they take alternating turns removing pieces from the line. In this game, Alice moves first.
+
+- Alice is only allowed to remove a piece colored 'A' if both its neighbors are also colored 'A'. She is not allowed to remove pieces that are colored 'B'.
+- Bob is only allowed to remove a piece colored 'B' if both its neighbors are also colored 'B'. He is not allowed to remove pieces that are colored 'A'.
+- Alice and Bob cannot remove pieces from the edge of the line.
+- If a player cannot make a move on their turn, that player loses and the other player wins.
+
+Assuming Alice and Bob play optimally, return true if Alice wins, or return false if Bob wins.
+
+**Example 1:**
+
+ Input: colors = "AAABABB"
+ Output: true
+ Explanation:
+ AAABABB -> AABABB
+ Alice moves first.
+ She removes the second 'A' from the left since that is the only 'A' whose neighbors are both 'A'.
+
+ Now it's Bob's turn.
+ Bob cannot make a move on his turn since there are no 'B's whose neighbors are both 'B'.
+ Thus, Alice wins, so return true.
+
+**Example 2:**
+
+ Input: colors = "AA"
+ Output: false
+ Explanation:
+ Alice has her turn first.
+ There are only two 'A's and both are on the edge of the line, so she cannot move on her turn.
+ Thus, Bob wins, so return false.
+
+**Example 3:**
+
+ Input: colors = "ABBBBBBBAAA"
+ Output: false
+ Explanation:
+ ABBBBBBBAAA -> ABBBBBBBAA
+ Alice moves first.
+ Her only option is to remove the second to last 'A' from the right.
+
+ ABBBBBBBAA -> ABBBBBBAA
+ Next is Bob's turn.
+ He has many options for which 'B' piece to remove. He can pick any.
+
+ On Alice's second turn, she has no more pieces that she can remove.
+ Thus, Bob wins, so return false.
+
+**Constraints:**
+
+- 1 <= colors.length <= 100000
+- colors consists of only the letters 'A' and 'B'
+
+## 题目大意
+
+总共有 n 个颜色片段排成一列，每个颜色片段要么是 'A' 要么是 'B' 。给你一个长度为 n 的字符串 colors ，其中 colors[i] 表示第 i 个颜色片段的颜色。
+
+Alice 和 Bob 在玩一个游戏，他们轮流从这个字符串中删除颜色。Alice 先手。
+
+- 如果一个颜色片段为 'A' 且相邻两个颜色都是颜色 'A'，那么 Alice 可以删除该颜色片段。Alice不可以删除任何颜色 'B' 片段。
+- 如果一个颜色片段为 'B'且相邻两个颜色都是颜色 'B' ，那么 Bob 可以删除该颜色片段。Bob 不可以删除任何颜色 'A' 片段。
+- Alice 和 Bob 不能从字符串两端删除颜色片段。
+- 如果其中一人无法继续操作，则该玩家 输掉游戏且另一玩家 获胜。
+
+假设 Alice 和 Bob 都采用最优策略，如果 Alice 获胜，请返回true，否则 Bob 获胜，返回false。
+
+## 解题思路
+
+- 统计 Alice 和 Bob 分别可以操作的次数记为 As，Bs
+- 因为 Alice 先手，所以只要 As 大于 Bs，Alice 获胜返回 true，否则 Bob 获胜返回 false
+
+# 代码
+
+```go
+package leetcode
+
+func winnerOfGame(colors string) bool {
+ As, Bs := 0, 0
+ Acont, Bcont := 0, 0
+ for _, color := range colors {
+ if color == 'A' {
+ Acont += 1
+ Bcont = 0
+ } else {
+ Bcont += 1
+ Acont = 0
+ }
+ if Acont >= 3 {
+ As += Acont - 2
+ }
+ if Bcont >= 3 {
+ Bs += Bcont - 2
+ }
+ }
+ if As > Bs {
+ return true
+ }
+ return false
+}
+```
+# [2043. Simple Bank System](https://leetcode.com/problems/simple-bank-system/)
+
+## 题目
+
+You have been tasked with writing a program for a popular bank that will automate all its incoming transactions (transfer, deposit, and withdraw). The bank has n accounts numbered from 1 to n. The initial balance of each account is stored in a 0-indexed integer array balance, with the (i + 1)th account having an initial balance of balance[i].
+
+Execute all the valid transactions. A transaction is valid if:
+
+- The given account number(s) are between 1 and n, and
+- The amount of money withdrawn or transferred from is less than or equal to the balance of the account.
+
+Implement the Bank class:
+
+- Bank(long[] balance) Initializes the object with the 0-indexed integer array balance.
+- boolean transfer(int account1, int account2, long money) Transfers money dollars from the account numbered account1 to the account numbered account2. Return true if the transaction was successful, false otherwise.
+- boolean deposit(int account, long money) Deposit money dollars into the account numbered account. Return true if the transaction was successful, false otherwise.
+- boolean withdraw(int account, long money) Withdraw money dollars from the account numbered account. Return true if the transaction was successful, false otherwise.
+
+**Example 1:**
+
+ Input
+ ["Bank", "withdraw", "transfer", "deposit", "transfer", "withdraw"]
+ [[[10, 100, 20, 50, 30]], [3, 10], [5, 1, 20], [5, 20], [3, 4, 15], [10, 50]]
+ Output
+ [null, true, true, true, false, false]
+
+ Explanation
+ Bank bank = new Bank([10, 100, 20, 50, 30]);
+ bank.withdraw(3, 10); // return true, account 3 has a balance of $20, so it is valid to withdraw $10.
+ // Account 3 has $20 - $10 = $10.
+ bank.transfer(5, 1, 20); // return true, account 5 has a balance of $30, so it is valid to transfer $20.
+ // Account 5 has $30 - $20 = $10, and account 1 has $10 + $20 = $30.
+ bank.deposit(5, 20); // return true, it is valid to deposit $20 to account 5.
+ // Account 5 has $10 + $20 = $30.
+ bank.transfer(3, 4, 15); // return false, the current balance of account 3 is $10,
+ // so it is invalid to transfer $15 from it.
+ bank.withdraw(10, 50); // return false, it is invalid because account 10 does not exist.
+
+**Constraints:**
+
+- n == balance.length
+- 1 <= n, account, account1, account2 <= 100000
+- 0 <= balance[i], money <= 1000000000000
+- At most 104 calls will be made to each function transfer, deposit, withdraw.
+
+## 题目大意
+
+你的任务是为一个很受欢迎的银行设计一款程序，以自动化执行所有传入的交易（转账，存款和取款）。银行共有 n 个账户，编号从 1 到 n 。每个账号的初始余额存储在一个下标从 0 开始的整数数组 balance 中，其中第 (i + 1) 个账户的初始余额是 balance[i] 。
+
+请你执行所有 有效的 交易。如果满足下面全部条件，则交易 有效 ：
+
+- 指定的账户数量在 1 和 n 之间，且
+- 取款或者转账需要的钱的总数 小于或者等于 账户余额。
+
+实现 Bank 类：
+
+- Bank(long[] balance) 使用下标从 0 开始的整数数组 balance 初始化该对象。
+- boolean transfer(int account1, int account2, long money) 从编号为 account1 的账户向编号为 account2 的账户转帐 money 美元。如果交易成功，返回 true ，否则，返回 false 。
+- boolean deposit(int account, long money) 向编号为 account 的账户存款 money 美元。如果交易成功，返回 true ；否则，返回 false 。
+- boolean withdraw(int account, long money) 从编号为 account 的账户取款 money 美元。如果交易成功，返回 true ；否则，返回 false 。
+
+## 解题思路
+
+ 根据题意进行简单模拟
+
+# 代码
+
+```go
+package leetcode
+
+type Bank struct {
+ accounts []int64
+ n int
+}
+
+func Constructor(balance []int64) Bank {
+ return Bank{
+ accounts: balance,
+ n: len(balance),
+ }
+}
+
+func (this *Bank) Transfer(account1 int, account2 int, money int64) bool {
+ if account1 > this.n || account2 > this.n {
+ return false
+ }
+ if this.accounts[account1-1] < money {
+ return false
+ }
+ this.accounts[account1-1] -= money
+ this.accounts[account2-1] += money
+ return true
+}
+
+func (this *Bank) Deposit(account int, money int64) bool {
+ if account > this.n {
+ return false
+ }
+ this.accounts[account-1] += money
+ return true
+}
+
+func (this *Bank) Withdraw(account int, money int64) bool {
+ if account > this.n {
+ return false
+ }
+ if this.accounts[account-1] < money {
+ return false
+ }
+ this.accounts[account-1] -= money
+ return true
+}
+```
+# [2096. Step-By-Step Directions From a Binary Tree Node to Another](https://leetcode.com/problems/step-by-step-directions-from-a-binary-tree-node-to-another/)
+
+
+## 题目
+
+You are given the `root` of a **binary tree** with `n` nodes. Each node is uniquely assigned a value from `1` to `n`. You are also given an integer `startValue` representing the value of the start node `s`, and a different integer `destValue` representing the value of the destination node `t`.
+
+Find the **shortest path** starting from node `s` and ending at node `t`. Generate step-by-step directions of such path as a string consisting of only the **uppercase** letters `'L'`, `'R'`, and `'U'`. Each letter indicates a specific direction:
+
+- `'L'` means to go from a node to its **left child** node.
+- `'R'` means to go from a node to its **right child** node.
+- `'U'` means to go from a node to its **parent** node.
+
+Return *the step-by-step directions of the **shortest path** from node* `s` *to node* `t`.
+
+**Example 1:**
+
+
+
+```
+Input: root = [5,1,2,3,null,6,4], startValue = 3, destValue = 6
+Output: "UURL"
+Explanation: The shortest path is: 3 → 1 → 5 → 2 → 6.
+
+```
+
+**Example 2:**
+
+
+
+```
+Input: root = [2,1], startValue = 2, destValue = 1
+Output: "L"
+Explanation: The shortest path is: 2 → 1.
+
+```
+
+**Constraints:**
+
+- The number of nodes in the tree is `n`.
+- `2 <= n <= 105`
+- `1 <= Node.val <= n`
+- All the values in the tree are **unique**.
+- `1 <= startValue, destValue <= n`
+- `startValue != destValue`
+
+## 题目大意
+
+给你一棵 二叉树 的根节点 root ，这棵二叉树总共有 n 个节点。每个节点的值为 1 到 n 中的一个整数，且互不相同。给你一个整数 startValue ，表示起点节点 s 的值，和另一个不同的整数 destValue ，表示终点节点 t 的值。
+
+请找到从节点 s 到节点 t 的 最短路径 ，并以字符串的形式返回每一步的方向。每一步用 大写 字母 'L' ，'R' 和 'U' 分别表示一种方向：
+
+- 'L' 表示从一个节点前往它的 左孩子 节点。
+- 'R' 表示从一个节点前往它的 右孩子 节点。
+- 'U' 表示从一个节点前往它的 父 节点。
+
+请你返回从 s 到 t 最短路径 每一步的方向。
+
+## 解题思路
+
+- 二叉树中一个节点到另一个节点的最短路径一定可以分为两个部分（可能为空）：从起点节点向上到两个节点的**最近公共祖先**，再从最近公共祖先向下到达终点节点。
+- 首先需要找到起点 s 与公共祖先的节点之间的 path1，公共祖先节点与终点 t 的 path2。再删掉 2 个 path 的公共前缀。如果起点 s 和终点 t 在不同的分支上，不存在公共前缀。如果他们在相同的分支上，那么最终答案要去掉这个公共前缀。
+- 删除掉公共前缀以后，需要再整理一下最终答案的输出格式。由于题目要求，起点到公共祖先节点需要输出 U，所以把这段 path1 全部改成 U，然后再拼接上 path2 字符串，即可得到的字符串即为待求 ss 到 tt 每一步的最短路径。
+
+## 代码
+
+```go
+package leetcode
+
+import (
+ "github.com/halfrost/leetcode-go/structures"
+)
+
+// TreeNode define
+type TreeNode = structures.TreeNode
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ * Val int
+ * Left *TreeNode
+ * Right *TreeNode
+ * }
+ */
+
+func getDirections(root *TreeNode, startValue int, destValue int) string {
+ sPath, dPath := make([]byte, 0), make([]byte, 0)
+ findPath(root, startValue, &sPath)
+ findPath(root, destValue, &dPath)
+ size, i := min(len(sPath), len(dPath)), 0
+ for i < size {
+ if sPath[len(sPath)-1-i] == dPath[len(dPath)-1-i] {
+ i++
+ } else {
+ break
+ }
+ }
+ sPath = sPath[:len(sPath)-i]
+ replace(sPath)
+ dPath = dPath[:len(dPath)-i]
+ reverse(dPath)
+ sPath = append(sPath, dPath...)
+ return string(sPath)
+}
+
+func findPath(root *TreeNode, value int, path *[]byte) bool {
+ if root.Val == value {
+ return true
+ }
+
+ if root.Left != nil && findPath(root.Left, value, path) {
+ *path = append(*path, 'L')
+ return true
+ }
+
+ if root.Right != nil && findPath(root.Right, value, path) {
+ *path = append(*path, 'R')
+ return true
+ }
+
+ return false
+}
+
+func reverse(path []byte) {
+ left, right := 0, len(path)-1
+ for left < right {
+ path[left], path[right] = path[right], path[left]
+ left++
+ right--
+ }
+}
+
+func replace(path []byte) {
+ for i := 0; i < len(path); i++ {
+ path[i] = 'U'
+ }
+}
+
+func min(i, j int) int {
+ if i < j {
+ return i
+ }
+ return j
+}
+```
+# [2164. Sort Even and Odd Indices Independently](https://leetcode.com/problems/sort-even-and-odd-indices-independently/)
+
+
+## 题目
+
+You are given a **0-indexed** integer array `nums`. Rearrange the values of `nums` according to the following rules:
+
+1. Sort the values at **odd indices** of `nums` in **non-increasing** order.
+ - For example, if `nums = [4,**1**,2,**3**]` before this step, it becomes `[4,**3**,2,**1**]` after. The values at odd indices `1` and `3` are sorted in non-increasing order.
+2. Sort the values at **even indices** of `nums` in **non-decreasing** order.
+ - For example, if `nums = [**4**,1,**2**,3]` before this step, it becomes `[**2**,1,**4**,3]` after. The values at even indices `0` and `2` are sorted in non-decreasing order.
+
+Return *the array formed after rearranging the values of* `nums`.
+
+**Example 1:**
+
+```
+Input: nums = [4,1,2,3]
+Output: [2,3,4,1]
+Explanation:
+First, we sort the values present at odd indices (1 and 3) in non-increasing order.
+So, nums changes from [4,1,2,3] to [4,3,2,1].
+Next, we sort the values present at even indices (0 and 2) in non-decreasing order.
+So, nums changes from [4,1,2,3] to [2,3,4,1].
+Thus, the array formed after rearranging the values is [2,3,4,1].
+
+```
+
+**Example 2:**
+
+```
+Input: nums = [2,1]
+Output: [2,1]
+Explanation:
+Since there is exactly one odd index and one even index, no rearrangement of values takes place.
+The resultant array formed is [2,1], which is the same as the initial array.
+
+```
+
+**Constraints:**
+
+- `1 <= nums.length <= 100`
+- `1 <= nums[i] <= 100`
+
+## 题目大意
+
+给你一个下标从 0 开始的整数数组 nums 。根据下述规则重排 nums 中的值：
+
+1. 按 非递增 顺序排列 nums 奇数下标 上的所有值。
+举个例子，如果排序前 nums = [4,1,2,3] ，对奇数下标的值排序后变为 [4,3,2,1] 。奇数下标 1 和 3 的值按照非递增顺序重排。
+2. 按 非递减 顺序排列 nums 偶数下标 上的所有值。
+举个例子，如果排序前 nums = [4,1,2,3] ，对偶数下标的值排序后变为 [2,1,4,3] 。偶数下标 0 和 2 的值按照非递减顺序重排。
+
+返回重排 nums 的值之后形成的数组。
+
+## 解题思路
+
+- 简单题。分别将奇数和偶数位上的数字排序，奇数位的数从大到小，偶数位的数从小到大。最后将他们组合成一个数组。
+
+## 代码
+
+```go
+package leetcode
+
+import (
+ "sort"
+)
+
+func sortEvenOdd(nums []int) []int {
+ odd, even, res := []int{}, []int{}, []int{}
+ for index, v := range nums {
+ if index%2 == 0 {
+ even = append(even, v)
+ } else {
+ odd = append(odd, v)
+ }
+ }
+ sort.Ints(even)
+ sort.Sort(sort.Reverse(sort.IntSlice(odd)))
+
+ indexO, indexE := 0, 0
+ for i := 0; i < len(nums); i++ {
+ if i%2 == 0 {
+ res = append(res, even[indexE])
+ indexE++
+ } else {
+ res = append(res, odd[indexO])
+ indexO++
+ }
+ }
+ return res
+}
+```
+# [2165. Smallest Value of the Rearranged Number](https://leetcode.com/problems/smallest-value-of-the-rearranged-number/)
+
+
+## 题目
+
+You are given an integer `num.` **Rearrange** the digits of `num` such that its value is **minimized** and it does not contain **any** leading zeros.
+
+Return *the rearranged number with minimal value*.
+
+Note that the sign of the number does not change after rearranging the digits.
+
+**Example 1:**
+
+```
+Input: num = 310
+Output: 103
+Explanation: The possible arrangements for the digits of 310 are 013, 031, 103, 130, 301, 310.
+The arrangement with the smallest value that does not contain any leading zeros is 103.
+
+```
+
+**Example 2:**
+
+```
+Input: num = -7605
+Output: -7650
+Explanation: Some possible arrangements for the digits of -7605 are -7650, -6705, -5076, -0567.
+The arrangement with the smallest value that does not contain any leading zeros is -7650.
+
+```
+
+**Constraints:**
+
+- `10^15 <= num <= 10^15`
+
+## 题目大意
+
+给你一个整数 num 。重排 num 中的各位数字，使其值 最小化 且不含 任何 前导零。
+
+返回不含前导零且值最小的重排数字。注意，重排各位数字后，num 的符号不会改变。
+
+## 解题思路
+
+- 先将每个数字出现次数统计出来。然后将数字大小从小到大排序。如果原数是正数，当出现有数字 0 的情况的时候，需先将第二小的数字排列到第一个，再把 0 排列完。再继续排列第二小，第三小。。。
+- 如果原数是负数。那么就逆序排列，即先排列最大的数字，然后次大的数字，直到排列最小的数字。因为数字越大，对应的这个数的负数就越小。
+
+## 代码
+
+```go
+package leetcode
+
+import "sort"
+
+func smallestNumber(num int64) int64 {
+ pos := true
+ if num < 0 {
+ pos = false
+ num *= -1
+ }
+ nums, m, res := []int{}, map[int]int{}, 0
+ for num != 0 {
+ tmp := int(num % 10)
+ m[tmp]++
+ num = num / 10
+ }
+
+ for k := range m {
+ nums = append(nums, k)
+ }
+ if pos {
+ sort.Ints(nums)
+ } else {
+ sort.Sort(sort.Reverse(sort.IntSlice(nums)))
+ }
+
+ if nums[0] == 0 && len(nums) > 1 {
+ res += nums[1]
+ m[nums[1]]--
+ }
+
+ for _, v := range nums {
+ if res != 0 {
+ for j := m[v]; j > 0; j-- {
+ res = res * 10
+ res += v
+ }
+ } else {
+ res += v
+ tmp := m[v] - 1
+ for j := tmp; j > 0; j-- {
+ res = res * 10
+ res += v
+ }
+ }
+ }
+ if !pos {
+ return -1 * int64(res)
+ }
+ return int64(res)
+}
+```
+# [2166. Design Bitset](https://leetcode.com/problems/design-bitset/)
+
+
+## 题目
+
+A **Bitset** is a data structure that compactly stores bits.
+
+Implement the `Bitset` class:
+
+- `Bitset(int size)` Initializes the Bitset with `size` bits, all of which are `0`.
+- `void fix(int idx)` Updates the value of the bit at the index `idx` to `1`. If the value was already `1`, no change occurs.
+- `void unfix(int idx)` Updates the value of the bit at the index `idx` to `0`. If the value was already `0`, no change occurs.
+- `void flip()` Flips the values of each bit in the Bitset. In other words, all bits with value `0` will now have value `1` and vice versa.
+- `boolean all()` Checks if the value of **each** bit in the Bitset is `1`. Returns `true` if it satisfies the condition, `false` otherwise.
+- `boolean one()` Checks if there is **at least one** bit in the Bitset with value `1`. Returns `true` if it satisfies the condition, `false` otherwise.
+- `int count()` Returns the **total number** of bits in the Bitset which have value `1`.
+- `String toString()` Returns the current composition of the Bitset. Note that in the resultant string, the character at the `ith` index should coincide with the value at the `ith` bit of the Bitset.
+
+**Example 1:**
+
+```
+Input
+["Bitset", "fix", "fix", "flip", "all", "unfix", "flip", "one", "unfix", "count", "toString"]
+[[5], [3], [1], [], [], [0], [], [], [0], [], []]
+Output
+[null, null, null, null, false, null, null, true, null, 2, "01010"]
+
+Explanation
+Bitset bs = new Bitset(5); // bitset = "00000".
+bs.fix(3); // the value at idx = 3 is updated to 1, so bitset = "00010".
+bs.fix(1); // the value at idx = 1 is updated to 1, so bitset = "01010".
+bs.flip(); // the value of each bit is flipped, so bitset = "10101".
+bs.all(); // return False, as not all values of the bitset are 1.
+bs.unfix(0); // the value at idx = 0 is updated to 0, so bitset = "00101".
+bs.flip(); // the value of each bit is flipped, so bitset = "11010".
+bs.one(); // return True, as there is at least 1 index with value 1.
+bs.unfix(0); // the value at idx = 0 is updated to 0, so bitset = "01010".
+bs.count(); // return 2, as there are 2 bits with value 1.
+bs.toString(); // return "01010", which is the composition of bitset.
+
+```
+
+**Constraints:**
+
+- `1 <= size <= 10^5`
+- `0 <= idx <= size - 1`
+- At most `10^5` calls will be made **in total** to `fix`, `unfix`, `flip`, `all`, `one`, `count`, and `toString`.
+- At least one call will be made to `all`, `one`, `count`, or `toString`.
+- At most `5` calls will be made to `toString`.
+
+## 题目大意
+
+位集 Bitset 是一种能以紧凑形式存储位的数据结构。
+
+请你实现 Bitset 类。
+
+- Bitset(int size) 用 size 个位初始化 Bitset ，所有位都是 0 。
+- void fix(int idx) 将下标为 idx 的位上的值更新为 1 。如果值已经是 1 ，则不会发生任何改变。
+- void unfix(int idx) 将下标为 idx 的位上的值更新为 0 。如果值已经是 0 ，则不会发生任何改变。
+- void flip() 翻转 Bitset 中每一位上的值。换句话说，所有值为 0 的位将会变成 1 ，反之亦然。
+- boolean all() 检查 Bitset 中 每一位 的值是否都是 1 。如果满足此条件，返回 true ；否则，返回 false 。
+- boolean one() 检查 Bitset 中 是否 至少一位 的值是 1 。如果满足此条件，返回 true ；否则，返回 false 。
+- int count() 返回 Bitset 中值为 1 的位的 总数 。
+- String toString() 返回 Bitset 的当前组成情况。注意，在结果字符串中，第 i 个下标处的字符应该与 Bitset 中的第 i 位一致。
+
+提示：
+
+- 1 <= size <= 10^5
+- 0 <= idx <= size - 1
+- 至多调用 fix、unfix、flip、all、one、count 和 toString 方法 总共 10^5 次
+- 至少调用 all、one、count 或 toString 方法一次
+- 至多调用 toString 方法 5 次
+
+## 解题思路
+
+- 题目中给出了 size 大小，10^5 位二进制。所以不能用 int64 数据类型。
+- 用数组模拟二进制位的一系列操作。flip 操作并不需要每次去翻转，偶数次翻转等于没有翻转，奇数次翻转记下标记，同时更新 1 的个数。这次懒操作在调用 fix 和 unfix 时，更新到原来数组中。
+- fix 和 unfix 根据懒数组中的标记对应更新二进制位。同时更新 1 的个数。
+- all，one，count 都是判断 1 的个数。toString 输出即可。
+
+## 代码
+
+```go
+package leetcode
+
+type Bitset struct {
+ set []byte
+ flipped []byte
+ oneCount int
+ size int
+}
+
+func Constructor(size int) Bitset {
+ set := make([]byte, size)
+ flipped := make([]byte, size)
+ for i := 0; i < size; i++ {
+ set[i] = byte('0')
+ flipped[i] = byte('1')
+ }
+ return Bitset{
+ set: set,
+ flipped: flipped,
+ oneCount: 0,
+ size: size,
+ }
+}
+
+func (this *Bitset) Fix(idx int) {
+ if this.set[idx] == byte('0') {
+ this.set[idx] = byte('1')
+ this.flipped[idx] = byte('0')
+ this.oneCount++
+ }
+}
+
+func (this *Bitset) Unfix(idx int) {
+ if this.set[idx] == byte('1') {
+ this.set[idx] = byte('0')
+ this.flipped[idx] = byte('1')
+ this.oneCount--
+ }
+}
+
+func (this *Bitset) Flip() {
+ this.set, this.flipped = this.flipped, this.set
+ this.oneCount = this.size - this.oneCount
+}
+
+func (this *Bitset) All() bool {
+ return this.oneCount == this.size
+}
+
+func (this *Bitset) One() bool {
+ return this.oneCount != 0
+}
+
+func (this *Bitset) Count() int {
+ return this.oneCount
+}
+
+func (this *Bitset) ToString() string {
+ return string(this.set)
+}
+
+/**
+ * Your Bitset object will be instantiated and called as such:
+ * obj := Constructor(size);
+ * obj.Fix(idx);
+ * obj.Unfix(idx);
+ * obj.Flip();
+ * param_4 := obj.All();
+ * param_5 := obj.One();
+ * param_6 := obj.Count();
+ * param_7 := obj.ToString();
+ */
+```
+# [2167. Minimum Time to Remove All Cars Containing Illegal Goods](https://leetcode.com/problems/minimum-time-to-remove-all-cars-containing-illegal-goods/)
+
+
+## 题目
+
+You are given a **0-indexed** binary string `s` which represents a sequence of train cars. `s[i] = '0'` denotes that the `ith` car does **not** contain illegal goods and `s[i] = '1'` denotes that the `ith` car does contain illegal goods.
+
+As the train conductor, you would like to get rid of all the cars containing illegal goods. You can do any of the following three operations **any** number of times:
+
+1. Remove a train car from the **left** end (i.e., remove `s[0]`) which takes 1 unit of time.
+2. Remove a train car from the **right** end (i.e., remove `s[s.length - 1]`) which takes 1 unit of time.
+3. Remove a train car from **anywhere** in the sequence which takes 2 units of time.
+
+Return *the **minimum** time to remove all the cars containing illegal goods*.
+
+Note that an empty sequence of cars is considered to have no cars containing illegal goods.
+
+**Example 1:**
+
+```
+Input: s = "1100101"
+Output: 5
+Explanation:
+One way to remove all the cars containing illegal goods from the sequence is to
+- remove a car from the left end 2 times. Time taken is 2 * 1 = 2.
+- remove a car from the right end. Time taken is 1.
+- remove the car containing illegal goods found in the middle. Time taken is 2.
+This obtains a total time of 2 + 1 + 2 = 5.
+
+An alternative way is to
+- remove a car from the left end 2 times. Time taken is 2 * 1 = 2.
+- remove a car from the right end 3 times. Time taken is 3 * 1 = 3.
+This also obtains a total time of 2 + 3 = 5.
+
+5 is the minimum time taken to remove all the cars containing illegal goods.
+There are no other ways to remove them with less time.
+
+```
+
+**Example 2:**
+
+```
+Input: s = "0010"
+Output: 2
+Explanation:
+One way to remove all the cars containing illegal goods from the sequence is to
+- remove a car from the left end 3 times. Time taken is 3 * 1 = 3.
+This obtains a total time of 3.
+
+Another way to remove all the cars containing illegal goods from the sequence is to
+- remove the car containing illegal goods found in the middle. Time taken is 2.
+This obtains a total time of 2.
+
+Another way to remove all the cars containing illegal goods from the sequence is to
+- remove a car from the right end 2 times. Time taken is 2 * 1 = 2.
+This obtains a total time of 2.
+
+2 is the minimum time taken to remove all the cars containing illegal goods.
+There are no other ways to remove them with less time.
+```
+
+**Constraints:**
+
+- `1 <= s.length <= 2 * 10^5`
+- `s[i]` is either `'0'` or `'1'`.
+
+## 题目大意
+
+给你一个下标从 0 开始的二进制字符串 s ，表示一个列车车厢序列。s[i] = '0' 表示第 i 节车厢 不 含违禁货物，而 s[i] = '1' 表示第 i 节车厢含违禁货物。
+
+作为列车长，你需要清理掉所有载有违禁货物的车厢。你可以不限次数执行下述三种操作中的任意一个：
+
+1. 从列车 左 端移除一节车厢（即移除 s[0]），用去 1 单位时间。
+2. 从列车 右 端移除一节车厢（即移除 s[s.length - 1]），用去 1 单位时间。
+3. 从列车车厢序列的 任意位置 移除一节车厢，用去 2 单位时间。
+
+返回移除所有载有违禁货物车厢所需要的 最少 单位时间数。注意，空的列车车厢序列视为没有车厢含违禁货物。
+
+## 解题思路
+
+- 这道题求最少单位时间数，最少时间数一定是尽量少使用 2 个单位时间的操作，多用 1 个时间的操作。从列车两头移除车厢，只需要移除和旁边车厢的金属连接处即可。由于列车位于两边，所以与其他车厢的金属连接处只有 1 个，故只需要 1 个单位时间；当车厢在中间，该车厢与两边的车厢有 2 个金属连接处，移除它需要断开与两边车厢的连接。所以需要 2 个单位时间。
+- 断开中间一节车厢以后，列车会被断成 2 部分。2 部分列车分别有 2 个头 2 个尾。举例：`1100111101`，如果把它从第 5 节开始断开，剩下的列车为 `11001 (1)` 和 `1101`。剩下的 1 都位于 2 边，移除他们都只需要 1 个单位时间。那么移除所有违禁品最少时间是 2 * 1 + 1 * 6 = 8。
+- 左半部分，定义 prefixSum[i] 表示移除前 i 节车厢所花费的最少时间。状态转移方程为：
+
+ {{< katex display >}}
+ prefixSum[i] =\left\{\begin{matrix}prefixSum[i-1],s[i]=0\\ min(prefixSum[i-1]+2, i+1), s[i]=1\end{matrix}\right.
+ {{< /katex >}}
+
+- 同理，右半部分定义 suffixSum[i] 表示移除后 i 节车厢所花费的最少时间。状态转移方程为：
+
+ {{< katex display >}}
+ suffixSum[i] =\left\{\begin{matrix} suffixSum[i+1],s[i]=0\\ min(suffixSum[i+1]+2, n-i), s[i]=1\end{matrix}\right.
+ {{< /katex >}}
+
+- 最后一层循环枚举 prefixSum[i] + suffixSum[i+1] 的最小值即为答案。
+- 这一题在解法一的基础上还可以再简化。当 s[i] = 1 时，prefixSum 和 suffixSum 是两种计算方法。我们可以假设中间断开的部分在 prefixSum 中。于是可以合并上面两个状态转移方程。简化以后的代码见解法二。
+
+## 代码
+
+```go
+package leetcode
+
+import "runtime/debug"
+
+// 解法一 DP
+func minimumTime(s string) int {
+ suffixSum, prefixSum, res := make([]int, len(s)+1), make([]int, len(s)+1), 0
+ for i := len(s) - 1; i >= 0; i-- {
+ if s[i] == '0' {
+ suffixSum[i] = suffixSum[i+1]
+ } else {
+ suffixSum[i] = min(suffixSum[i+1]+2, len(s)-i)
+ }
+ }
+ res = suffixSum[0]
+ if s[0] == '1' {
+ prefixSum[0] = 1
+ }
+ for i := 1; i < len(s); i++ {
+ if s[i] == '0' {
+ prefixSum[i] = prefixSum[i-1]
+ } else {
+ prefixSum[i] = min(prefixSum[i-1]+2, i+1)
+ }
+ res = min(res, prefixSum[i]+suffixSum[i+1])
+ }
+ return res
+}
+
+func init() { debug.SetGCPercent(-1) }
+
+// 解法二 小幅优化时间和空间复杂度
+func minimumTime1(s string) int {
+ res, count := len(s), 0
+ for i := 0; i < len(s); i++ {
+ count = min(count+int(s[i]-'0')*2, i+1)
+ res = min(res, count+len(s)-i-1)
+ }
+ return res
+}
+
+func min(a, b int) int {
+ if a < b {
+ return a
+ } else {
+ return b
+ }
+}
+```
+# [2169. Count Operations to Obtain Zero](https://leetcode.com/problems/count-operations-to-obtain-zero/)
+
+
+## 题目
+
+You are given two **non-negative** integers `num1` and `num2`.
+
+In one **operation**, if `num1 >= num2`, you must subtract `num2` from `num1`, otherwise subtract `num1` from `num2`.
+
+- For example, if `num1 = 5` and `num2 = 4`, subtract `num2` from `num1`, thus obtaining `num1 = 1` and `num2 = 4`. However, if `num1 = 4` and `num2 = 5`, after one operation, `num1 = 4` and `num2 = 1`.
+
+Return *the **number of operations** required to make either* `num1 = 0` *or* `num2 = 0`.
+
+**Example 1:**
+
+```
+Input: num1 = 2, num2 = 3
+Output: 3
+Explanation:
+- Operation 1: num1 = 2, num2 = 3. Since num1 < num2, we subtract num1 from num2 and get num1 = 2, num2 = 3 - 2 = 1.
+- Operation 2: num1 = 2, num2 = 1. Since num1 > num2, we subtract num2 from num1.
+- Operation 3: num1 = 1, num2 = 1. Since num1 == num2, we subtract num2 from num1.
+Now num1 = 0 and num2 = 1. Since num1 == 0, we do not need to perform any further operations.
+So the total number of operations required is 3.
+
+```
+
+**Example 2:**
+
+```
+Input: num1 = 10, num2 = 10
+Output: 1
+Explanation:
+- Operation 1: num1 = 10, num2 = 10. Since num1 == num2, we subtract num2 from num1 and get num1 = 10 - 10 = 0.
+Now num1 = 0 and num2 = 10. Since num1 == 0, we are done.
+So the total number of operations required is 1.
+
+```
+
+**Constraints:**
+
+- `0 <= num1, num2 <= 10^5`
+
+## 题目大意
+
+给你两个 非负 整数 num1 和 num2 。每一步 操作 中，如果 num1 >= num2 ，你必须用 num1 减 num2 ；否则，你必须用 num2 减 num1 。
+
+- 例如，num1 = 5 且 num2 = 4 ，应该用 num1 减 num2 ，因此，得到 num1 = 1 和 num2 = 4 。然而，如果 num1 = 4且 num2 = 5 ，一步操作后，得到 num1 = 4 和 num2 = 1 。
+
+返回使 num1 = 0 或 num2 = 0 的 操作数 。
+
+## 解题思路
+
+- 简单题，按照题意模拟，每次两个数字相减，便累加操作次数。当某个数字变为 0 时，输出操作次数。
+
+## 代码
+
+```go
+package leetcode
+
+func countOperations(num1 int, num2 int) int {
+ res := 0
+ for num1 != 0 && num2 != 0 {
+ if num1 >= num2 {
+ num1 -= num2
+ } else {
+ num2 -= num1
+ }
+ res++
+ }
+ return res
+}
+```
+# [2170. Minimum Operations to Make the Array Alternating](https://leetcode.com/problems/minimum-operations-to-make-the-array-alternating/)
+
+
+## 题目
+
+You are given a **0-indexed** array `nums` consisting of `n` positive integers.
+
+The array `nums` is called **alternating** if:
+
+- `nums[i - 2] == nums[i]`, where `2 <= i <= n - 1`.
+- `nums[i - 1] != nums[i]`, where `1 <= i <= n - 1`.
+
+In one **operation**, you can choose an index `i` and **change** `nums[i]` into **any** positive integer.
+
+Return *the **minimum number of operations** required to make the array alternating*.
+
+**Example 1:**
+
+```
+Input: nums = [3,1,3,2,4,3]
+Output: 3
+Explanation:
+One way to make the array alternating is by converting it to [3,1,3,1,3,1].
+The number of operations required in this case is 3.
+It can be proven that it is not possible to make the array alternating in less than 3 operations.
+
+```
+
+**Example 2:**
+
+```
+Input: nums = [1,2,2,2,2]
+Output: 2
+Explanation:
+One way to make the array alternating is by converting it to [1,2,1,2,1].
+The number of operations required in this case is 2.
+Note that the array cannot be converted to [2,2,2,2,2] because in this case nums[0] == nums[1] which violates the conditions of an alternating array.
+
+```
+
+**Constraints:**
+
+- `1 <= nums.length <= 10^5`
+- `1 <= nums[i] <= 10^5`
+
+## 题目大意
+
+给你一个下标从 0 开始的数组 nums ，该数组由 n 个正整数组成。
+
+如果满足下述条件，则数组 nums 是一个 交替数组 ：
+
+- nums[i - 2] == nums[i] ，其中 2 <= i <= n - 1 。
+- nums[i - 1] != nums[i] ，其中 1 <= i <= n - 1 。
+
+在一步 操作 中，你可以选择下标 i 并将 nums[i] 更改 为 任一 正整数。返回使数组变成交替数组的 最少操作数 。
+
+**提示：**
+
+- `1 <= nums.length <= 10^5`
+- `1 <= nums[i] <= 10^5`
+
+## 解题思路
+
+- 题目要求最少操作数，即留下出现频次最多的数字，剩下的数字都替换成这个数字。先将每个数字出现的频次统计出来，然后按照频次从大到小排序。优先选择出现频次高的数字。
+- 有几种“特殊”情况需要处理：当奇数下标的数字频次最大的数字和偶数下标的数字频次最大的数字相同（数字相同，频次不同），这时应选取频次大的数字留下；当数字相同，频次也相同，这时要看奇数下标和偶数下标的数字分别有几个。 如果其中一个只有一种数字，那么另外一组数字则需都变成该组频次第二大的数字，例如奇数下标的数字全是 1，频次是 3，偶数下标的数字是 1，最大频次是 2。第二频次的数字是 9，频次是 1 。那么这种情况下，选择奇数下标的数字 1，和偶数下标数字 9 。将偶数下标不是 9 的数字改变成 9 ；更近一步，如果奇数下标和偶数下标都只有一个数字，频次相同，那么只能改变奇数下标或者偶数下标的所有数字。
+
+## 代码
+
+```go
+package leetcode
+
+import (
+ "sort"
+)
+
+type node struct {
+ value int
+ count int
+}
+
+func minimumOperations(nums []int) int {
+ if len(nums) == 1 {
+ return 0
+ }
+ res, odd, even, oddMap, evenMap := 0, []node{}, []node{}, map[int]int{}, map[int]int{}
+
+ for i := 0; i < len(nums); i += 2 {
+ evenMap[nums[i]]++
+ }
+ for k, v := range evenMap {
+ even = append(even, node{value: k, count: v})
+ }
+ sort.Slice(even, func(i, j int) bool {
+ return even[i].count > even[j].count
+ })
+
+ for i := 1; i < len(nums); i += 2 {
+ oddMap[nums[i]]++
+ }
+ for k, v := range oddMap {
+ odd = append(odd, node{value: k, count: v})
+ }
+ sort.Slice(odd, func(i, j int) bool {
+ return odd[i].count > odd[j].count
+ })
+
+ if even[0].value == odd[0].value {
+ if len(even) == 1 && len(odd) != 1 {
+ res = len(nums) - even[0].count - odd[1].count
+ } else if len(odd) == 1 && len(even) != 1 {
+ res = len(nums) - odd[0].count - even[1].count
+ } else if len(odd) == 1 && len(even) == 1 {
+ res = len(nums) / 2
+ } else {
+ // both != 1
+ res = min(len(nums)-odd[0].count-even[1].count, len(nums)-odd[1].count-even[0].count)
+ }
+ } else {
+ res = len(nums) - even[0].count - odd[0].count
+ }
+ return res
+}
+
+func min(a, b int) int {
+ if a > b {
+ return b
+ }
+ return a
+}
+```
+# [2171. Removing Minimum Number of Magic Beans](https://leetcode.com/problems/removing-minimum-number-of-magic-beans/)
+
+
+## 题目
+
+You are given an array of **positive** integers `beans`, where each integer represents the number of magic beans found in a particular magic bag.
+
+**Remove** any number of beans (**possibly none**) from each bag such that the number of beans in each remaining **non-empty** bag (still containing **at least one** bean) is **equal**. Once a bean has been removed from a bag, you are **not** allowed to return it to any of the bags.
+
+Return *the **minimum** number of magic beans that you have to remove*.
+
+**Example 1:**
+
+```
+Input: beans = [4,1,6,5]
+Output: 4
+Explanation:
+- We remove 1 bean from the bag with only 1 bean.
+ This results in the remaining bags: [4,0,6,5]
+- Then we remove 2 beans from the bag with 6 beans.
+ This results in the remaining bags: [4,0,4,5]
+- Then we remove 1 bean from the bag with 5 beans.
+ This results in the remaining bags: [4,0,4,4]
+We removed a total of 1 + 2 + 1 = 4 beans to make the remaining non-empty bags have an equal number of beans.
+There are no other solutions that remove 4 beans or fewer.
+
+```
+
+**Example 2:**
+
+```
+Input: beans = [2,10,3,2]
+Output: 7
+Explanation:
+- We remove 2 beans from one of the bags with 2 beans.
+ This results in the remaining bags: [0,10,3,2]
+- Then we remove 2 beans from the other bag with 2 beans.
+ This results in the remaining bags: [0,10,3,0]
+- Then we remove 3 beans from the bag with 3 beans.
+ This results in the remaining bags: [0,10,0,0]
+We removed a total of 2 + 2 + 3 = 7 beans to make the remaining non-empty bags have an equal number of beans.
+There are no other solutions that removes 7 beans or fewer.
+
+```
+
+**Constraints:**
+
+- `1 <= beans.length <= 10^5`
+- `1 <= beans[i] <= 10^5`
+
+## 题目大意
+
+给你一个 正 整数数组 beans ，其中每个整数表示一个袋子里装的魔法豆的数目。
+
+请你从每个袋子中 拿出 一些豆子（也可以 不拿出），使得剩下的 非空 袋子中（即 至少 还有 一颗 魔法豆的袋子）魔法豆的数目 相等 。一旦魔法豆从袋子中取出，你不能将它放到任何其他的袋子中。请你返回你需要拿出魔法豆的 最少数目。
+
+**提示：**
+
+- `1 <= beans.length <= 10^5`
+- `1 <= beans[i] <= 10^5`
+
+## 解题思路
+
+- 这一题没有特别巧妙的方法。最初思路来源于暴力解法。从第一个袋子开始，依次以每个袋子中的豆子为基准，改变其他袋子里面的豆子数，使得其他袋子里面的豆子都和基准袋子中豆子一样多。
+- 如果从下标为 0 扫到下标 n-1 ，这中间会有大量重复计算。有些计算区间和的操作，反复计算了很多遍，导致算法不高效。由于移除豆子数量多少和基准袋豆子数量强相关，所以先排序。如果袋子内豆子数目小于基准袋的豆子，`0 ≤ j < i`，那么这些袋子内的豆子数量会归零。需要移除 `beans[0] + beans[1] + ... + beans[i-1]` 个豆子；如果袋子内豆子数目大于等于基准袋的豆子，`j ≥ i` ，那么这些袋子内的豆子需要调整为 `beans[i]` 个。需要移除 `(beans[i] - beans[i]) + (beans[i+1] - beans[i]) + (beans[i+2] - beans[i]) + ... + (beans[n-1] - beans[i]) = beans[i]+ ... + beans[n-1] - (n-i) * beans[i]` 个豆子。将这 2 种情况综合起来，那么总共需要移除 `sum(beans) - (N - i) * beans[i]` 个豆子。综上，先排序，然后从小到大扫一遍数组，动态维护最少移除豆子的个数即可。
+
+## 代码
+
+```go
+package leetcode
+
+import "sort"
+
+func minimumRemoval(beans []int) int64 {
+ sort.Ints(beans)
+ sum, mx := 0, 0
+ for i, v := range beans {
+ sum += v
+ mx = max(mx, (len(beans)-i)*v)
+ }
+ return int64(sum - mx)
+}
+
+func max(a, b int) int {
+ if b > a {
+ return b
+ }
+ return a
+}
+```
+# [2180. Count Integers With Even Digit Sum](https://leetcode.com/problems/count-integers-with-even-digit-sum/)
+
+
+## 题目
+
+Given a positive integer `num`, return *the number of positive integers **less than or equal to*** `num` *whose digit sums are **even***.
+
+The **digit sum** of a positive integer is the sum of all its digits.
+
+**Example 1:**
+
+```
+Input: num = 4
+Output: 2
+Explanation:
+The only integers less than or equal to 4 whose digit sums are even are 2 and 4.
+
+```
+
+**Example 2:**
+
+```
+Input: num = 30
+Output: 14
+Explanation:
+The 14 integers less than or equal to 30 whose digit sums are even are
+2, 4, 6, 8, 11, 13, 15, 17, 19, 20, 22, 24, 26, and 28.
+
+```
+
+**Constraints:**
+
+- `1 <= num <= 1000`
+
+## 题目大意
+
+给你一个正整数 num ，请你统计并返回 小于或等于 num 且各位数字之和为 偶数 的正整数的数目。
+
+正整数的 各位数字之和 是其所有位上的对应数字相加的结果。
+
+## 解题思路
+
+- 简单题。依照题意，计算每个数的各位数字之和，如何和为偶数，则统计结果加一。最后输出统计结果即可。
+
+## 代码
+
+```go
+package leetcode
+
+func countEven(num int) int {
+ count := 0
+ for i := 1; i <= num; i++ {
+ if addSum(i)%2 == 0 {
+ count++
+ }
+ }
+ return count
+}
+
+func addSum(num int) int {
+ sum := 0
+ tmp := num
+ for tmp != 0 {
+ sum += tmp % 10
+ tmp = tmp / 10
+ }
+ return sum
+}
+```
+# [2181. Merge Nodes in Between Zeros](https://leetcode.com/problems/merge-nodes-in-between-zeros/)
+
+## 题目
+
+You are given the `head` of a linked list, which contains a series of integers **separated** by `0`'s. The **beginning** and **end** of the linked list will have `Node.val == 0`.
+
+For **every** two consecutive `0`'s, **merge** all the nodes lying in between them into a single node whose value is the **sum** of all the merged nodes. The modified list should not contain any `0`'s.
+
+Return *the* `head` *of the modified linked list*.
+
+**Example 1:**
+
+
+
+```
+Input: head = [0,3,1,0,4,5,2,0]
+Output: [4,11]
+Explanation:
+The above figure represents the given linked list. The modified list contains
+- The sum of the nodes marked in green: 3 + 1 = 4.
+- The sum of the nodes marked in red: 4 + 5 + 2 = 11.
+
+```
+
+**Example 2:**
+
+
+
+```
+Input: head = [0,1,0,3,0,2,2,0]
+Output: [1,3,4]
+Explanation:
+The above figure represents the given linked list. The modified list contains
+- The sum of the nodes marked in green: 1 = 1.
+- The sum of the nodes marked in red: 3 = 3.
+- The sum of the nodes marked in yellow: 2 + 2 = 4.
+
+```
+
+**Constraints:**
+
+- The number of nodes in the list is in the range `[3, 2 * 10^5]`.
+- `0 <= Node.val <= 1000`
+- There are **no** two consecutive nodes with `Node.val == 0`.
+- The **beginning** and **end** of the linked list have `Node.val == 0`.
+
+## 题目大意
+
+给你一个链表的头节点 head ，该链表包含由 0 分隔开的一连串整数。链表的 开端 和 末尾 的节点都满足 Node.val == 0 。对于每两个相邻的 0 ，请你将它们之间的所有节点合并成一个节点，其值是所有已合并节点的值之和。然后将所有 0 移除，修改后的链表不应该含有任何 0 。
+
+返回修改后链表的头节点 head 。
+
+## 解题思路
+
+- 简单题。合并链表中两个值为 0 的节点。从头开始遍历链表，遇到节点值不为 0 的节点便累加；遇到节点值为 0 的节点，将累加值转换成结果链表要输出的节点值，然后继续遍历。
+
+## 代码
+
+```go
+package leetcode
+
+import (
+ "github.com/halfrost/leetcode-go/structures"
+)
+
+// ListNode define
+type ListNode = structures.ListNode
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ * Val int
+ * Next *ListNode
+ * }
+ */
+func mergeNodes(head *ListNode) *ListNode {
+ res := &ListNode{}
+ h := res
+ if head.Next == nil {
+ return &structures.ListNode{}
+ }
+ cur := head
+ sum := 0
+ for cur.Next != nil {
+ if cur.Next.Val != 0 {
+ sum += cur.Next.Val
+ } else {
+ h.Next = &ListNode{Val: sum, Next: nil}
+ h = h.Next
+ sum = 0
+ }
+ cur = cur.Next
+ }
+ return res.Next
+}
+```
+# [2182. Construct String With Repeat Limit](https://leetcode.com/problems/construct-string-with-repeat-limit/)
+
+
+## 题目
+
+You are given a string `s` and an integer `repeatLimit`. Construct a new string `repeatLimitedString` using the characters of `s` such that no letter appears **more than** `repeatLimit` times **in a row**. You do **not** have to use all characters from `s`.
+
+Return *the **lexicographically largest*** `repeatLimitedString` *possible*.
+
+A string `a` is **lexicographically larger** than a string `b` if in the first position where `a` and `b` differ, string `a` has a letter that appears later in the alphabet than the corresponding letter in `b`. If the first `min(a.length, b.length)` characters do not differ, then the longer string is the lexicographically larger one.
+
+**Example 1:**
+
+```
+Input: s = "cczazcc", repeatLimit = 3
+Output: "zzcccac"
+Explanation: We use all of the characters from s to construct the repeatLimitedString "zzcccac".
+The letter 'a' appears at most 1 time in a row.
+The letter 'c' appears at most 3 times in a row.
+The letter 'z' appears at most 2 times in a row.
+Hence, no letter appears more than repeatLimit times in a row and the string is a valid repeatLimitedString.
+The string is the lexicographically largest repeatLimitedString possible so we return "zzcccac".
+Note that the string "zzcccca" is lexicographically larger but the letter 'c' appears more than 3 times in a row, so it is not a valid repeatLimitedString.
+
+```
+
+**Example 2:**
+
+```
+Input: s = "aababab", repeatLimit = 2
+Output: "bbabaa"
+Explanation: We use only some of the characters from s to construct the repeatLimitedString "bbabaa".
+The letter 'a' appears at most 2 times in a row.
+The letter 'b' appears at most 2 times in a row.
+Hence, no letter appears more than repeatLimit times in a row and the string is a valid repeatLimitedString.
+The string is the lexicographically largest repeatLimitedString possible so we return "bbabaa".
+Note that the string "bbabaaa" is lexicographically larger but the letter 'a' appears more than 2 times in a row, so it is not a valid repeatLimitedString.
+
+```
+
+**Constraints:**
+
+- `1 <= repeatLimit <= s.length <= 10^5`
+- `s` consists of lowercase English letters.
+
+## 题目大意
+
+给你一个字符串 s 和一个整数 repeatLimit ，用 s 中的字符构造一个新字符串 repeatLimitedString ，使任何字母 连续 出现的次数都不超过 repeatLimit 次。你不必使用 s 中的全部字符。
+
+返回 字典序最大的 repeatLimitedString 。
+
+如果在字符串 a 和 b 不同的第一个位置，字符串 a 中的字母在字母表中出现时间比字符串 b 对应的字母晚，则认为字符串 a 比字符串 b 字典序更大 。如果字符串中前 min(a.length, b.length) 个字符都相同，那么较长的字符串字典序更大。
+
+## 解题思路
+
+- 利用贪心的思想，由于题意要求返回字典序最大的字符串，所以先从字典序最大的字母开始选起。然后选择当前字典序最大的字母个数和 limit 的最小值。如果当前字典序最大的字母比较多，多于 limit，不能一直选择它。选完 limit 个以后，需要选一个字典序次大的字母，选完这个字母以后再次选择字典序最大的字母。因为 limit 限制字母不能连续多于 limit 个。如此循环，直到所有的字母都选完。这样的策略排列出来的字母串为最大字典序。
+
+## 代码
+
+```go
+package leetcode
+
+func repeatLimitedString(s string, repeatLimit int) string {
+ cnt := make([]int, 26)
+ for _, c := range s {
+ cnt[int(c-'a')]++
+ }
+ var ns []byte
+ for i := 25; i >= 0; {
+ k := i - 1
+ for cnt[i] > 0 {
+ for j := 0; j < min(cnt[i], repeatLimit); j++ {
+ ns = append(ns, byte(i)+'a')
+ }
+ cnt[i] -= repeatLimit
+ if cnt[i] > 0 {
+ for ; k >= 0 && cnt[k] == 0; k-- {
+ }
+ if k < 0 {
+ break
+ } else {
+ ns = append(ns, byte(k)+'a')
+ cnt[k]--
+ }
+ }
+ }
+ i = k
+ }
+ return string(ns)
+}
+func min(a, b int) int {
+ if a < b {
+ return a
+ } else {
+ return b
+ }
+}
+```
+# [2183. Count Array Pairs Divisible by K](https://leetcode.com/problems/count-array-pairs-divisible-by-k/)
+
+
+## 题目
+
+Given a **0-indexed** integer array `nums` of length `n` and an integer `k`, return *the **number of pairs*** `(i, j)` *such that:*
+
+- `0 <= i < j <= n - 1` *and*
+- `nums[i] * nums[j]` *is divisible by* `k`.
+
+**Example 1:**
+
+```
+Input: nums = [1,2,3,4,5], k = 2
+Output: 7
+Explanation:
+The 7 pairs of indices whose corresponding products are divisible by 2 are
+(0, 1), (0, 3), (1, 2), (1, 3), (1, 4), (2, 3), and (3, 4).
+Their products are 2, 4, 6, 8, 10, 12, and 20 respectively.
+Other pairs such as (0, 2) and (2, 4) have products 3 and 15 respectively, which are not divisible by 2.
+
+```
+
+**Example 2:**
+
+```
+Input: nums = [1,2,3,4], k = 5
+Output: 0
+Explanation: There does not exist any pair of indices whose corresponding product is divisible by 5.
+
+```
+
+**Constraints:**
+
+- `1 <= nums.length <= 10^5`
+- `1 <= nums[i], k <= 10^5`
+
+## 题目大意
+
+给你一个下标从 0 开始、长度为 n 的整数数组 nums 和一个整数 k ，返回满足下述条件的下标对 (i, j) 的数目：
+
+- 0 <= i < j <= n - 1 且
+- nums[i] * nums[j] 能被 k 整除。
+
+## 解题思路
+
+- 先找出 num 中每个元素与 k 的最大公约数。并统计这些公约数出现的频次，将数据保存在 map 中。在计算过程中，循环可以只需算到 {{< katex >}}{O(\sqrt {k})}{{< /katex >}} , 因为每一个 gcd[i] 一定是 k 的因数，而它出现的频次不会超过 {{< katex >}}{O(\sqrt {k})}{{< /katex >}}。简单证明一下：假设因子 v 和 k/v 这两个因数为 k 的因子。v 和 k/v 必至少有 1 个小于等于 {{< katex >}}\sqrt {k}{{< /katex >}}。所以 k 的因子也不会超过 2 * {{< katex >}}\sqrt {k}{{< /katex >}} = {{< katex >}}{O(\sqrt {k})}{{< /katex >}} 个。
+- 算出上述的 map 以后，2 层循环暴力遍历 key 值，如果 a * b 能被 k 整除，并且 a 和 b 不相同，那么 a 和 b 对应的 value 值相乘即为满足条件的下标对数；如果 a 和 b 相同，那么下标对数为 {{< katex >}}C_{n}^{2}{{< /katex >}}。最后累加结果即可。
+
+## 代码
+
+```go
+package leetcode
+
+import "math"
+
+func countPairs(nums []int, k int) int64 {
+ n := int(math.Sqrt(float64(k)))
+ gcds, res := make(map[int]int, n), 0
+ for _, num := range nums {
+ gcds[gcd(num, k)]++
+ }
+
+ for a, n1 := range gcds {
+ for b, n2 := range gcds {
+ if a > b || (a*b)%k != 0 {
+ continue
+ }
+ if a != b {
+ res += n1 * n2
+ } else { // a == b
+ res += n1 * (n1 - 1) / 2
+ }
+ }
+ }
+ return int64(res)
+}
+
+func gcd(a, b int) int {
+ for a%b != 0 {
+ a, b = b, a%b
+ }
+ return b
+}
+```
diff --git a/README.md b/README.md
index 8297ba964..0810905dd 100755
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@
-
+
diff --git a/ctl/command.go b/ctl/command.go
index a440a5710..72a596131 100644
--- a/ctl/command.go
+++ b/ctl/command.go
@@ -23,7 +23,6 @@ func init() {
rootCmd.AddCommand(
versionCmd,
newBuildCommand(),
- newLabelCommand(),
newPDFCommand(),
newRefresh(),
)
diff --git a/ctl/config.go b/ctl/config.go
index 4288c3d25..dcc48e3ff 100644
--- a/ctl/config.go
+++ b/ctl/config.go
@@ -25,7 +25,7 @@ func (c config) String() string {
func getConfig() *config {
cfg := new(config)
if _, err := toml.DecodeFile(configTOML, &cfg); err != nil {
- log.Panicf(err.Error())
+ log.Panic(err)
}
// log.Printf("get config: %s", cfg)
return cfg
diff --git a/ctl/label.go b/ctl/label.go
index 804f28b0e..064807836 100644
--- a/ctl/label.go
+++ b/ctl/label.go
@@ -1,37 +1,22 @@
package main
import (
- "bufio"
- "errors"
"fmt"
- "io"
- "io/ioutil"
- "os"
- "regexp"
- "strings"
"github.com/halfrost/LeetCode-Go/ctl/util"
- "github.com/spf13/cobra"
)
+// 上/下页导航已改由 Hugo 主题在渲染时动态生成
+// （themes/book/layouts/partials/docs/inject/content-after.html），
+// 不再把导航 HTML 写进 markdown，因此原先 add-pre-next / del-pre-next
+// 这一整套读写 markdown 的逻辑已全部移除。
+
var (
chapterOneFileOrder = []string{"_index", "Data_Structure", "Algorithm", "Time_Complexity"}
chapterOneMenuOrder = []string{"_index", "#关于作者", "Data_Structure", "Algorithm", "Time_Complexity"}
chapterTwoFileOrder = []string{"_index", "Array", "String", "Two_Pointers", "Linked_List", "Stack", "Tree", "Dynamic_Programming", "Backtracking", "Depth_First_Search", "Breadth_First_Search",
"Binary_Search", "Math", "Hash_Table", "Sorting", "Bit_Manipulation", "Union_Find", "Sliding_Window", "Segment_Tree", "Binary_Indexed_Tree"}
chapterThreeFileOrder = []string{"_index", "Segment_Tree", "UnionFind", "LRUCache", "LFUCache"}
- preNextHeader = "----------------------------------------------\n
\n"
- preNextFotter = "
"
- delLine = "----------------------------------------------\n"
- delHeader = ""
- delLabel = "<[a-zA-Z]+.*?>([\\s\\S]*?)"
- delFooter = "
"
-
- //ErrNoFilename is thrown when the path the the file to tail was not given
- ErrNoFilename = errors.New("You must provide the path to a file in the \"-file\" flag.")
-
- //ErrInvalidLineCount is thrown when the user provided 0 (zero) as the value for number of lines to tail
- ErrInvalidLineCount = errors.New("You cannot tail zero lines.")
chapterMap = map[string]map[string]string{
"ChapterOne": {
@@ -82,267 +67,3 @@ func getChapterFourFileOrder() ([]string, []int) {
fmt.Printf("ChapterFour 中包括 _index 有 %v 个文件, len(id) = %v\n", len(chapterFourFileOrder), len(solutionIds))
return chapterFourFileOrder, solutionIds
}
-
-func newLabelCommand() *cobra.Command {
- mc := &cobra.Command{
- Use: "label ",
- Short: "Label related commands",
- }
- //mc.PersistentFlags().StringVar(&logicEndpoint, "endpoint", "localhost:5880", "endpoint of logic service")
- mc.AddCommand(
- newAddPreNext(),
- newDeletePreNext(),
- )
- return mc
-}
-
-func newAddPreNext() *cobra.Command {
- cmd := &cobra.Command{
- Use: "add-pre-next",
- Short: "Add pre-next label",
- Run: func(cmd *cobra.Command, args []string) {
- addPreNext()
- },
- }
- // cmd.Flags().StringVar(&alias, "alias", "", "alias")
- // cmd.Flags().StringVar(&appId, "appid", "", "appid")
- return cmd
-}
-
-func newDeletePreNext() *cobra.Command {
- cmd := &cobra.Command{
- Use: "del-pre-next",
- Short: "Delete pre-next label",
- Run: func(cmd *cobra.Command, args []string) {
- delPreNext()
- },
- }
- // cmd.Flags().StringVar(&alias, "alias", "", "alias")
- // cmd.Flags().StringVar(&appId, "appid", "", "appid")
- return cmd
-}
-
-func addPreNext() {
- // 上/下页导航已改由 Hugo 主题在渲染时动态生成
- // （themes/book/layouts/partials/docs/inject/content-after.html），
- // 不再把导航 HTML 写进 markdown，避免与主题渲染的导航重复。
- // 如需恢复写入 markdown 的旧行为，取消下面的注释即可。
- //
- // addPreNextLabel(chapterOneFileOrder, []string{}, []int{}, "", "ChapterOne", "ChapterTwo")
- // addPreNextLabel(chapterTwoFileOrder, chapterOneFileOrder, []int{}, "ChapterOne", "ChapterTwo", "ChapterThree")
- // addPreNextLabel(chapterThreeFileOrder, chapterTwoFileOrder, []int{}, "ChapterTwo", "ChapterThree", "ChapterFour")
- // chapterFourFileOrder, solutionIds := getChapterFourFileOrder()
- // addPreNextLabel(chapterFourFileOrder, chapterThreeFileOrder, solutionIds, "ChapterThree", "ChapterFour", "")
-}
-
-func addPreNextLabel(order, preOrder []string, chapterFourIds []int, preChapter, chapter, nextChapter string) {
- var (
- exist bool
- err error
- res []byte
- count int
- )
- for index, path := range order {
- tmp := ""
- if index == 0 {
- if chapter == "ChapterOne" {
- // 第一页不需要“上一章”
- tmp = "\n\n" + delLine + fmt.Sprintf("下一页➡️
\n", chapter, order[index+1])
- } else {
- if chapter == "ChapterFour" {
- tmp = "\n\n" + preNextHeader + fmt.Sprintf("⬅️上一章
\n", preChapter, preOrder[len(preOrder)-1]) + fmt.Sprintf("下一页➡️
\n", chapter, util.GetChpaterFourFileNum(chapterFourIds[(index-1)+1]), order[index+1]) + preNextFotter
- } else {
- tmp = "\n\n" + preNextHeader + fmt.Sprintf("⬅️上一章
\n", preChapter, preOrder[len(preOrder)-1]) + fmt.Sprintf("下一页➡️
\n", chapter, order[index+1]) + preNextFotter
- }
- }
- } else if index == len(order)-1 {
- if chapter == "ChapterFour" {
- // 最后一页不需要“下一页”
- tmp = "\n\n" + delLine + fmt.Sprintf("⬅️上一页
\n", chapter, util.GetChpaterFourFileNum(chapterFourIds[(index-1)-1]), order[index-1])
- } else {
- tmp = "\n\n" + preNextHeader + fmt.Sprintf("⬅️上一页
\n", chapter, order[index-1]) + fmt.Sprintf("下一章➡️
\n", nextChapter) + preNextFotter
- }
- } else if index == 1 {
- if chapter == "ChapterFour" {
- tmp = "\n\n" + preNextHeader + fmt.Sprintf("⬅️上一页
\n", chapter) + fmt.Sprintf("下一页➡️
\n", chapter, util.GetChpaterFourFileNum(chapterFourIds[(index-1)+1]), order[index+1]) + preNextFotter
- } else {
- tmp = "\n\n" + preNextHeader + fmt.Sprintf("⬅️上一页
\n", chapter) + fmt.Sprintf("下一页➡️
\n", chapter, order[index+1]) + preNextFotter
- }
- } else {
- if chapter == "ChapterFour" {
- tmp = "\n\n" + preNextHeader + fmt.Sprintf("⬅️上一页
\n", chapter, util.GetChpaterFourFileNum(chapterFourIds[(index-1)-1]), order[index-1]) + fmt.Sprintf("下一页➡️
\n", chapter, util.GetChpaterFourFileNum(chapterFourIds[(index-1)+1]), order[index+1]) + preNextFotter
- } else {
- tmp = "\n\n" + preNextHeader + fmt.Sprintf("⬅️上一页
\n", chapter, order[index-1]) + fmt.Sprintf("下一页➡️
\n", chapter, order[index+1]) + preNextFotter
- }
- }
-
- if chapter == "ChapterFour" && index > 0 {
- path = fmt.Sprintf("%v/%v", util.GetChpaterFourFileNum(chapterFourIds[(index-1)]), path)
- }
-
- exist, err = needAdd(fmt.Sprintf("../website/content/%v/%v.md", chapter, path))
- if err != nil {
- fmt.Println(err)
- return
- }
- // 当前没有上一页和下一页，才添加
- if !exist && err == nil {
- res, err = eofAdd(fmt.Sprintf("../website/content/%v/%v.md", chapter, path), tmp)
- if err != nil {
- fmt.Println(err)
- return
- }
- util.WriteFile(fmt.Sprintf("../website/content/%v/%v.md", chapter, path), res)
- count++
- }
- }
- fmt.Printf("添加了 %v 个文件的 pre-next\n", count)
-}
-
-func eofAdd(filePath string, labelString string) ([]byte, error) {
- f, err := os.OpenFile(filePath, os.O_RDONLY, 0644)
- if err != nil {
- return nil, err
- }
- defer f.Close()
- reader, output := bufio.NewReader(f), []byte{}
-
- for {
- line, _, err := reader.ReadLine()
- if err != nil {
- if err == io.EOF {
- output = append(output, []byte(labelString)...)
- output = append(output, []byte("\n")...)
- return output, nil
- }
- return nil, err
- }
- output = append(output, line...)
- output = append(output, []byte("\n")...)
- }
-}
-
-func delPreNext() {
- // Chpater one del pre-next
- delPreNextLabel(chapterOneFileOrder, []int{}, "ChapterOne")
- // Chpater two del pre-next
- delPreNextLabel(chapterTwoFileOrder, []int{}, "ChapterTwo")
- // Chpater three del pre-next
- delPreNextLabel(chapterThreeFileOrder, []int{}, "ChapterThree")
- // Chpater four del pre-next
- chapterFourFileOrder, solutionIds := getChapterFourFileOrder()
- delPreNextLabel(chapterFourFileOrder, solutionIds, "ChapterFour")
-}
-
-func delPreNextLabel(order []string, chapterFourIds []int, chapter string) {
- count := 0
- for index, path := range order {
- lineNum := 5
- if index == 0 && chapter == "ChapterOne" || index == len(order)-1 && chapter == "ChapterFour" {
- lineNum = 3
- }
- if chapter == "ChapterFour" && index > 0 {
- path = fmt.Sprintf("%v/%v", util.GetChpaterFourFileNum(chapterFourIds[(index-1)]), path)
- }
-
- exist, err := needAdd(fmt.Sprintf("../website/content/%v/%v.md", chapter, path))
- if err != nil {
- fmt.Println(err)
- return
- }
- // 存在才删除
- if exist && err == nil {
- removeLine(fmt.Sprintf("../website/content/%v/%v.md", chapter, path), lineNum+1)
- count++
- }
- }
- fmt.Printf("删除了 %v 个文件的 pre-next\n", count)
- // 另外一种删除方法
- // res, err := eofDel(fmt.Sprintf("../website/content/ChapterOne/%v.md", v))
- // if err != nil {
- // fmt.Println(err)
- // return
- // }
- // util.WriteFile(fmt.Sprintf("../website/content/ChapterOne/%v.md", v), res)
-}
-
-func needAdd(filePath string) (bool, error) {
- f, err := os.OpenFile(filePath, os.O_RDONLY, 0644)
- if err != nil {
- return false, err
- }
- defer f.Close()
- reader, output := bufio.NewReader(f), []byte{}
- for {
- line, _, err := reader.ReadLine()
- if err != nil {
- if err == io.EOF {
- return false, nil
- }
- return false, err
- }
- if ok, _ := regexp.Match(delHeader, line); ok {
- return true, nil
- } else if ok, _ := regexp.Match(delLabel, line); ok {
- return true, nil
- } else {
- output = append(output, line...)
- output = append(output, []byte("\n")...)
- }
- }
-}
-
-func eofDel(filePath string) ([]byte, error) {
- f, err := os.OpenFile(filePath, os.O_RDONLY, 0644)
- if err != nil {
- return nil, err
- }
- defer f.Close()
- reader, output := bufio.NewReader(f), []byte{}
- for {
- line, _, err := reader.ReadLine()
- if err != nil {
- if err == io.EOF {
- return output, nil
- }
- return nil, err
- }
- if ok, _ := regexp.Match(delLine, line); ok {
- reg := regexp.MustCompile(delLine)
- newByte := reg.ReplaceAll(line, []byte(""))
- output = append(output, newByte...)
- output = append(output, []byte("\n")...)
- } else if ok, _ := regexp.Match(delHeader, line); ok {
- reg := regexp.MustCompile(delHeader)
- newByte := reg.ReplaceAll(line, []byte(""))
- output = append(output, newByte...)
- output = append(output, []byte("\n")...)
- } else if ok, _ := regexp.Match(delLabel, line); ok {
- reg := regexp.MustCompile(delLabel)
- newByte := reg.ReplaceAll(line, []byte(""))
- output = append(output, newByte...)
- output = append(output, []byte("\n")...)
- } else if ok, _ := regexp.Match(delFooter, line); ok {
- reg := regexp.MustCompile(delFooter)
- newByte := reg.ReplaceAll(line, []byte(""))
- output = append(output, newByte...)
- output = append(output, []byte("\n")...)
- } else {
- output = append(output, line...)
- output = append(output, []byte("\n")...)
- }
- }
-}
-
-func removeLine(path string, lineNumber int) {
- file, err := ioutil.ReadFile(path)
- if err != nil {
- panic(err)
- }
- info, _ := os.Stat(path)
- mode := info.Mode()
- array := strings.Split(string(file), "\n")
- array = array[:len(array)-lineNumber-1]
- ioutil.WriteFile(path, []byte(strings.Join(array, "\n")), mode)
- //fmt.Println("remove line successful")
-}
diff --git a/ctl/pdf.go b/ctl/pdf.go
index d481df4c5..14b890974 100644
--- a/ctl/pdf.go
+++ b/ctl/pdf.go
@@ -58,8 +58,8 @@ func generatePDF() {
pdf, tmp []byte
err error
)
- // 先删除 pre-next
- delPreNext()
+ // 上/下页导航由 Hugo 主题渲染时动态生成，markdown 中不再写入导航 HTML，
+ // 因此这里无需再做删除/还原导航的操作。
chapterFourFileOrder, _ := util.LoadChapterFourDir()
totalSolutions = len(chapterFourFileOrder)
@@ -90,7 +90,6 @@ func generatePDF() {
// 生成 PDF
util.WriteFile(fmt.Sprintf("../PDF v%v.%v.%v.md", majorVersion, midVersion, lastVersion), pdf)
// 还原现场
- addPreNext()
util.DestoryDir("./pdftemp")
}
@@ -106,9 +105,9 @@ func loadChapter(order []string, path, chapter string) ([]byte, error) {
} else {
if chapter == "ChapterFour" {
if v[4] == '.' {
- num, err := strconv.Atoi(v[:4])
- if err != nil {
- fmt.Println(err)
+ num, atoiErr := strconv.Atoi(v[:4])
+ if atoiErr != nil {
+ fmt.Println(atoiErr)
}
tmp, err = util.LoadFile(fmt.Sprintf("%v/%v/%v/%v.md", path, chapter, util.GetChpaterFourFileNum(num), v))
}
diff --git a/ctl/refresh.go b/ctl/refresh.go
index 501031a6a..d80f9ed75 100644
--- a/ctl/refresh.go
+++ b/ctl/refresh.go
@@ -20,8 +20,6 @@ func newRefresh() *cobra.Command {
func refresh() {
//buildBookMenu()
copyLackFile()
- delPreNext()
buildREADME()
buildChapterTwo(true)
- addPreNext()
}
diff --git a/ctl/request.go b/ctl/request.go
index 8222a1fc0..41efa462a 100644
--- a/ctl/request.go
+++ b/ctl/request.go
@@ -50,14 +50,14 @@ func getRaw(URL string) []byte {
req := newReq()
resp, err := req.Get(URL)
if err != nil {
- fmt.Printf("getRaw: Get Error: " + err.Error())
+ fmt.Printf("getRaw: Get Error: %s\n", err.Error())
return []byte{}
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
- fmt.Printf("getRaw: Read Error: " + err.Error())
+ fmt.Printf("getRaw: Read Error: %s\n", err.Error())
return []byte{}
}
if resp.StatusCode == 200 {
@@ -79,14 +79,14 @@ func getQraphql(payload string) []byte {
req := newReq()
resp, err := req.PostForm(QraphqlURL, bytes.NewBuffer([]byte(payload)))
if err != nil {
- fmt.Printf("getRaw: Get Error: " + err.Error())
+ fmt.Printf("getRaw: Get Error: %s\n", err.Error())
return []byte{}
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
- fmt.Printf("getRaw: Read Error: " + err.Error())
+ fmt.Printf("getRaw: Read Error: %s\n", err.Error())
return []byte{}
}
if resp.StatusCode == 200 {
diff --git a/ctl/version.go b/ctl/version.go
index c996a651a..bc1ddf8dc 100644
--- a/ctl/version.go
+++ b/ctl/version.go
@@ -10,9 +10,9 @@ var (
version = "v1.0"
versionCmd = &cobra.Command{
Use: "version",
- Short: "Prints the version of tacoctl",
+ Short: "Prints the version of leetcode-go",
Run: func(cmd *cobra.Command, args []string) {
- fmt.Println("tacoctl version:", version)
+ fmt.Println("leetcode-go version:", version)
},
}
)
diff --git a/leetcode/0492.Construct-the-Rectangle/README.md b/leetcode/0492.Construct-the-Rectangle/README.md
index 8024d6e16..94f6f139b 100644
--- a/leetcode/0492.Construct-the-Rectangle/README.md
+++ b/leetcode/0492.Construct-the-Rectangle/README.md
@@ -69,4 +69,4 @@ func constructRectangle(area int) []int {
return ans
}
-``
\ No newline at end of file
+```
\ No newline at end of file
diff --git a/website/content.en/ChapterFour/0400~0499/0492.Construct-the-Rectangle.md b/website/content.en/ChapterFour/0400~0499/0492.Construct-the-Rectangle.md
index 08fa57e49..b41bad075 100644
--- a/website/content.en/ChapterFour/0400~0499/0492.Construct-the-Rectangle.md
+++ b/website/content.en/ChapterFour/0400~0499/0492.Construct-the-Rectangle.md
@@ -69,4 +69,4 @@ func constructRectangle(area int) []int {
return ans
}
-``
+```
diff --git a/website/content/ChapterFour/0400~0499/0492.Construct-the-Rectangle.md b/website/content/ChapterFour/0400~0499/0492.Construct-the-Rectangle.md
index 0de70f9cd..f27c4a18c 100644
--- a/website/content/ChapterFour/0400~0499/0492.Construct-the-Rectangle.md
+++ b/website/content/ChapterFour/0400~0499/0492.Construct-the-Rectangle.md
@@ -69,4 +69,4 @@ func constructRectangle(area int) []int {
return ans
}
-``
+```
+
+
+
+# 说明
+
+此版本是 https://books.halfrost.com/leetcode 网页的离线版，由于网页版实时会更新，所以此 PDF 版难免会有一些排版或者错别字。如果读者遇到了，可以到网页版相应页面，点击页面 edit 按钮，提交 pr 进行更改。此 PDF 版本号是 V1.7.97。PDF 永久更新地址是 https://github.com/halfrost/leetcode-go/releases/，以版本号区分不同版本。笔者还是强烈推荐看在线版，有任何错误都会立即更新。如果觉得此书对刷题有一点点帮助，可以给此书点一个 star，鼓励一下笔者早点更新更多题解。
+
+> 版本号说明，V1.7.97，1 是大版本号，7 代表当前题解中有几百题，目前是 797 题，所以第二个版本号是 7，97 代表当前题解中有几十题，目前是 797 题，所以第三个版本号是 97 。
+
+# 目录
+
+[toc]
+
+
+# 第一章 序章
+
+
+## 关于 LeetCode
+
+说到 LeetCode，作为一个程序员来说，应该不陌生，近几年参加面试都会提到它。国内外的程序员用它刷题主要是为了面试。据历史记载，这个网站 2011 年就成立了，马上就要到自己 10 周年的生日了。每周举行周赛，双周赛，月赛，在有限时间内编码，确实非常能考验人的算法能力。一些大公司赞助冠名的比赛获得前几名除了有奖品，还能直接拿到内推的机会。
+
+
+
+## 什么是 Cookbook
+
+直译的话就是烹饪书，教你做各种食谱美食的书。经常看 O'Reilly 技术书的同学对这个名词会很熟悉。一般动手操作，实践类的书都会有这个名字。
+
+
+
+
+
+## 为什么会写这个开源书
+
+笔者刷题刷了一年了，想和大家分享分享一些做题心得，解题方法。想和有相同爱好的人交个朋友，一起交流学习。对于自己来说，写题解也是一种提高。把一道深奥的题目讲给一点都没有头绪的人，并能让他完全听懂，很能锻炼人的表达能力。在讲解中很可能还会遇到听者的一些提问，这些问题可能是自己的知识漏洞，强迫自己去弥补。笔者在公司做过相关的分享，感受很深，双方受益都还不错。
+
+> 另外，在大学期间，笔者做题的时候最讨厌写题解，感觉是浪费时间，用更多的时间去做更多的题。现在不知道算不算是“出来混的，总是要还的”。
+
+
+## 关于书的封面
+
+常看 O'Reilly 动物书的同学一看这个封面就知道是向他们致敬。确实是这个目的。O'Reilly 的封面动物都是稀缺动物，并且画风都是黑白素描风。这些动物都有版权了，所以只能在网上找没有版权的黑白素描风的图片。常见的能找到 40 张这种风格的图片。不过用的人太多了，笔者费劲的找了其他几张这种图片，这张孔雀开屏是其中一张。孔雀开屏的意义是希望大家刷完 LeetCode 以后，提高了自身的算法能力，在人生的舞台上开出自己的“屏”。全书配色也都是绿色，因为这是 AC 的颜色。
+
+
+## 关于作者
+
+笔者是一个刚刚入行一年半的 gopher 新人，还请各位大佬多多指点小弟我。大学参加了 3 年 ACM-ICPC，但是由于资质不高，没有拿到一块金牌。所以在算法方面，我对自己的评价算是新手吧。参加 ACM-ICPC 最大的收获是训练了思维能力，这种能力也会运用到生活中。其次是认识了很多国内很聪明的选手，看到了自己和他们的差距。最后，就是那 200 多页，有些自己都没有完全理解的，打印的密密麻麻的[算法模板](https://github.com/halfrost/leetcode-go/releases/tag/Special)。知识学会了，终身都是自己的，没有学会，那些知识都是身外之物。
+
+笔者从 2019 年 3 月 25 号开始刷题，到 2020 年 3 月 25 号，整整一年的时间。原计划是每天一题。实际上每天有时候不止一题，最终完成了 600+：
+
+
+
+> 一个温馨提示：笔者本以为每天做一题，会让这个 submissions 图全绿，但是我发现我错了。如果你也想坚持，让这个图全绿，一定要注意以下的问题：LeetCode 服务器是在 +0 时区的，这个图也是按照这个时区计算的。也就是说，中国每天早上 8 点之前，是算前一天的！也是因为时区的问题，导致我空白了这 22 个格子。比如有一道 Hard 题很难，当天工作也很多，晚上下班回家想出来了就到第二天凌晨了。于是再做一题当做第二天的量。结果会发现这 2 题都算前一天的。有时候笔者早上 6 点起床刷题，提交以后也都是前一天的。
+>
+> (当然这些都是过去了，不重要了，全当是奋斗路上的一些小插曲)
+
+2020 年笔者肯定还会继续刷题，因为还没有达到自己的一些目标。可能会朝着 1000 题奋进，也有可能刷到 800 题的时候回头开始二刷，三刷。(不达目的不罢休吧~)
+
+## 关于书中的代码
+
+代码都放在 [github repo](https://github.com/halfrost/leetcode-go/tree/master/leetcode) 中，按题号可以搜索到题目。
+本书题目的代码都已经 beats 100% 了。没有 beats 100% 题解就没有放到本书中了。那些题目笔者会继续优化到 100% 再放进来。
+
+有可能读者会问，为何要追求 beats 100%。笔者认为优化到 beats 100% 才算是把这题做出感觉了。有好几道 Hard 题，笔者都用暴力解法 AC 了，然后只 beats 了 5%。这题就如同没做一样。而且面试中如果给了这样的答案，面试官也不会满意，“还有没有更优解？”。如果通过自己的思考能给出更优解，面试官会更满意一些。
+
+LeetCode 统计代码运行时长会有波动的，相同的代码提交 10 次可能就会 beats 100% 了。笔者开始没有发现这个问题，很多题用正确的代码连续交了很多次，一年提交 3400+ 次，导致我的正确率也变的奇高。😢
+
+当然，如果还有其他更优美的解法，也能 beats 100% 的，欢迎提交 PR，笔者和大家一起学习。
+
+## 目标读者
+
+想通过 LeetCode 提高算法能力的编程爱好者。
+
+
+## 编程语言
+
+本书的算法全部用 Go 语言实现。
+
+
+## 使用说明
+
+- 本电子书的左上角有搜索栏，可以迅速帮你找到你想看的章节和题号。
+- 本电子书每页都接入了 Gitalk，每一页的最下方都有评论框可以评论，如果没有显示出来，请检查自己的网络。
+- 关于题解，笔者建议这样使用：先自己读题，思考如何解题。如果 15 分钟还没有思路，那么先看笔者的解题思路，但是不要看代码。有思路以后自己用代码实现一遍。如果完全不会写，那就看笔者提供的代码，找出自己到底哪里不会写，找出问题记下来，这就是自己要弥补的知识漏洞。如果自己实现出来了，提交以后有错误，自己先 debug。AC 以后没有到 100% 也先自己思考如何优化。如果每道题自己都能优化到 100% 了，那么一段时间以后进步会很大。所以总的来说，实在没思路，看解题思路；实在优化不到 100%，看看代码。
+
+## 互动与勘误
+
+如果书中文章有所遗漏，欢迎点击所在页面下边的 edit 按钮进行评论和互动，感谢您的支持与帮助。
+
+## 最后
+
+一起开始刷题吧~
+
+
+
+本作品采用 [知识署名-非商业性使用-禁止演绎 （BY-NC-ND） 4.0 国际许可协议](https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode.zh-Hans) 进行许可。
+
+
+题解里面的所有题目版权均归 [LeetCode](https://leetcode.com/) 和 [力扣中国](https://leetcode-cn.com/) 所有
+
+# 数据结构知识
+
+以下是笔者整理的数据结构相关的知识。希望能把常见的数据结构都枚举穷尽。如有遗漏，欢迎大家赐教，提 PR。相关题目还在慢慢整理中，讲解的文章还在创作中。
+
+> 刷题只是提升算法能力的手段，最终目的应该是提升自我的思维能力，知识需要凝结成块，那么就把这些总结在第一章这两节中，让它得到升华吧~希望读者在刷完题之后再回过头来看这个表格，能很清晰的梳理自己的知识体系，查缺补漏，尽早完善。
+
+| 数据结构 | 变种 | 相关题目 | 讲解文章 |
+|:-------:|:-------|:------|:------|
+|顺序线性表：向量 
+
+