Add weekly-contest-214 solution

Author: halfrost

leetcode/5561.Get-Maximum-in-Generated-Array/5561. Get Maximum in Generated Array.go renamed to leetcode/1646.Get-Maximum-in-Generated-Array/1646. Get Maximum in Generated Array.go

@@ -0,0 +1,62 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question1646 struct {
+	para1646
+	ans1646
+}
+
+// para 是参数
+// one 代表第一个参数
+type para1646 struct {
+	n int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans1646 struct {
+	one int
+}
+
+func Test_Problem1646(t *testing.T) {
+
+	qs := []question1646{
+
+		{
+			para1646{7},
+			ans1646{3},
+		},
+
+		{
+			para1646{2},
+			ans1646{1},
+		},
+
+		{
+			para1646{3},
+			ans1646{2},
+		},
+
+		{
+			para1646{0},
+			ans1646{0},
+		},
+
+		{
+			para1646{1},
+			ans1646{1},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 1646------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans1646, q.para1646
+		fmt.Printf("【input】:%v      【output】:%v      \n", p, getMaximumGenerated(p.n))
+	}
+	fmt.Printf("\n\n\n")
+}

leetcode/1646.Get-Maximum-in-Generated-Array/1646. Get Maximum in Generated Array_test.go

@@ -0,0 +1,96 @@
+# [1646. Get Maximum in Generated Array](https://leetcode.com/problems/get-maximum-in-generated-array/)
+
+
+## 题目
+
+You are given an integer `n`. An array `nums` of length `n + 1` is generated in the following way:
+
+- `nums[0] = 0`
+- `nums[1] = 1`
+- `nums[2 * i] = nums[i]` when `2 <= 2 * i <= n`
+- `nums[2 * i + 1] = nums[i] + nums[i + 1]` when `2 <= 2 * i + 1 <= n`
+
+Return *****the **maximum** integer in the array* `nums`.
+
+**Example 1:**
+
+```
+Input: n = 7
+Output: 3
+Explanation: According to the given rules:
+  nums[0] = 0
+  nums[1] = 1
+  nums[(1 * 2) = 2] = nums[1] = 1
+  nums[(1 * 2) + 1 = 3] = nums[1] + nums[2] = 1 + 1 = 2
+  nums[(2 * 2) = 4] = nums[2] = 1
+  nums[(2 * 2) + 1 = 5] = nums[2] + nums[3] = 1 + 2 = 3
+  nums[(3 * 2) = 6] = nums[3] = 2
+  nums[(3 * 2) + 1 = 7] = nums[3] + nums[4] = 2 + 1 = 3
+Hence, nums = [0,1,1,2,1,3,2,3], and the maximum is 3.
+
+```
+
+**Example 2:**
+
+```
+Input: n = 2
+Output: 1
+Explanation: According to the given rules, the maximum between nums[0], nums[1], and nums[2] is 1.
+
+```
+
+**Example 3:**
+
+```
+Input: n = 3
+Output: 2
+Explanation: According to the given rules, the maximum between nums[0], nums[1], nums[2], and nums[3] is 2.
+
+```
+
+**Constraints:**
+
+- `0 <= n <= 100`
+
+## 题目大意
+
+给你一个整数 n 。按下述规则生成一个长度为 n + 1 的数组 nums ：
+
+- nums[0] = 0
+- nums[1] = 1
+- 当 2 <= 2 * i <= n 时，nums[2 * i] = nums[i]
+- 当 2 <= 2 * i + 1 <= n 时，nums[2 * i + 1] = nums[i] + nums[i + 1]
+
+返回生成数组 nums 中的 最大值。
+
+## 解题思路
+
+- 给出一个 n + 1 的数组，并按照生成规则生成这个数组，求出这个数组中的最大值。
+- 简单题，按照题意生成数组，边生成边记录和更新最大值即可。
+- 注意边界条件，当 n 为 0 的时候，数组里面只有一个元素 0 。
+
+## 代码
+
+```go
+package leetcode
+
+func getMaximumGenerated(n int) int {
+	if n == 0 {
+		return 0
+	}
+	nums, max := make([]int, n+1), 0
+	nums[0], nums[1] = 0, 1
+	for i := 0; i <= n; i++ {
+		if nums[i] > max {
+			max = nums[i]
+		}
+		if 2*i >= 2 && 2*i <= n {
+			nums[2*i] = nums[i]
+		}
+		if 2*i+1 >= 2 && 2*i+1 <= n {
+			nums[2*i+1] = nums[i] + nums[i+1]
+		}
+	}
+	return max
+}
+```

leetcode/1646.Get-Maximum-in-Generated-Array/README.md

@@ -1,7 +1,6 @@
 package leetcode
 
 import (
-	"fmt"
 	"sort"
 )
 
@@ -11,7 +10,6 @@ func minDeletions(s string) int {
 		frequency[s[i]-'a']++
 	}
 	sort.Sort(sort.Reverse(sort.IntSlice(frequency)))
-	fmt.Printf("%v\n", frequency)
 	for i := 1; i <= 25; i++ {
 		if frequency[i] == frequency[i-1] && frequency[i] != 0 {
 			res++

leetcode/5562.Minimum-Deletions-to-Make-Character-Frequencies-Unique/5562. Minimum Deletions to Make Character Frequencies Unique.go renamed to leetcode/1647.Minimum-Deletions-to-Make-Character-Frequencies-Unique/1647. Minimum Deletions to Make Character Frequencies Unique.go

@@ -0,0 +1,62 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question1647 struct {
+	para1647
+	ans1647
+}
+
+// para 是参数
+// one 代表第一个参数
+type para1647 struct {
+	s string
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans1647 struct {
+	one int
+}
+
+func Test_Problem1647(t *testing.T) {
+
+	qs := []question1647{
+
+		{
+			para1647{"aab"},
+			ans1647{0},
+		},
+
+		{
+			para1647{"aaabbbcc"},
+			ans1647{2},
+		},
+
+		{
+			para1647{"ceabaacb"},
+			ans1647{2},
+		},
+
+		{
+			para1647{""},
+			ans1647{0},
+		},
+
+		{
+			para1647{"abcabc"},
+			ans1647{3},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 1647------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans1647, q.para1647
+		fmt.Printf("【input】:%v      【output】:%v      \n", p, minDeletions(p.s))
+	}
+	fmt.Printf("\n\n\n")
+}

leetcode/1647.Minimum-Deletions-to-Make-Character-Frequencies-Unique/1647. Minimum Deletions to Make Character Frequencies Unique_test.go

@@ -0,0 +1,89 @@
+# [1647. Minimum Deletions to Make Character Frequencies Unique](https://leetcode.com/problems/minimum-deletions-to-make-character-frequencies-unique/)
+
+
+## 题目
+
+A string `s` is called **good** if there are no two different characters in `s` that have the same **frequency**.
+
+Given a string `s`, return *the **minimum** number of characters you need to delete to make* `s` ***good**.*
+
+The **frequency** of a character in a string is the number of times it appears in the string. For example, in the string `"aab"`, the **frequency** of `'a'` is `2`, while the **frequency** of `'b'` is `1`.
+
+**Example 1:**
+
+```
+Input: s = "aab"
+Output: 0
+Explanation: s is already good.
+
+```
+
+**Example 2:**
+
+```
+Input: s = "aaabbbcc"
+Output: 2
+Explanation: You can delete two 'b's resulting in the good string "aaabcc".
+Another way it to delete one 'b' and one 'c' resulting in the good string "aaabbc".
+```
+
+**Example 3:**
+
+```
+Input: s = "ceabaacb"
+Output: 2
+Explanation: You can delete both 'c's resulting in the good string "eabaab".
+Note that we only care about characters that are still in the string at the end (i.e. frequency of 0 is ignored).
+
+```
+
+**Constraints:**
+
+- `1 <= s.length <= 105`
+- `s` contains only lowercase English letters.
+
+## 题目大意
+
+如果字符串 s 中 不存在 两个不同字符 频次 相同的情况，就称 s 是 优质字符串 。
+
+给你一个字符串 s，返回使 s 成为优质字符串需要删除的最小字符数。
+
+字符串中字符的 频次 是该字符在字符串中的出现次数。例如，在字符串 "aab" 中，'a' 的频次是 2，而 'b' 的频次是 1 。
+
+**提示：**
+
+- `1 <= s.length <= 105`
+- `s` 仅含小写英文字母
+
+## 解题思路
+
+- 给出一个字符串 s，要求输出使 s 变成“优质字符串”需要删除的最小字符数。“优质字符串”的定义是：字符串 s 中不存在频次相同的两个不同字符。
+- 首先将 26 个字母在字符串中的频次分别统计出来，然后把频次从大到小排列，从频次大的开始，依次调整：例如，假设前一个和后一个频次相等，就把前一个字符删除一个，频次减一，再次排序，如果频次还相等，继续调整，如果频次不同了，游标往后移，继续调整后面的频次。直到所有的频次都不同了，就可以输出最终结果了。
+- 这里需要注意频次为 0 的情况，即字母都被删光了。频次为 0 以后，就不需要再比较了。
+
+## 代码
+
+```go
+package leetcode
+
+import (
+	"sort"
+)
+
+func minDeletions(s string) int {
+	frequency, res := make([]int, 26), 0
+	for i := 0; i < len(s); i++ {
+		frequency[s[i]-'a']++
+	}
+	sort.Sort(sort.Reverse(sort.IntSlice(frequency)))
+	for i := 1; i <= 25; i++ {
+		if frequency[i] == frequency[i-1] && frequency[i] != 0 {
+			res++
+			frequency[i]--
+			sort.Sort(sort.Reverse(sort.IntSlice(frequency)))
+			i--
+		}
+	}
+	return res
+}
+```

leetcode/1647.Minimum-Deletions-to-Make-Character-Frequencies-Unique/README.md

@@ -4,7 +4,55 @@ import (
 	"container/heap"
 )
 
+// 解法一 贪心 + 二分搜索
 func maxProfit(inventory []int, orders int) int {
+	maxItem, thresholdValue, count, res, mod := 0, -1, 0, 0, 1000000007
+	for i := 0; i < len(inventory); i++ {
+		if inventory[i] > maxItem {
+			maxItem = inventory[i]
+		}
+	}
+	low, high := 0, maxItem
+	for low <= high {
+		mid := low + ((high - low) >> 1)
+		for i := 0; i < len(inventory); i++ {
+			count += max(inventory[i]-mid, 0)
+		}
+		if count <= orders {
+			thresholdValue = mid
+			high = mid - 1
+		} else {
+			low = mid + 1
+		}
+		count = 0
+	}
+	count = 0
+	for i := 0; i < len(inventory); i++ {
+		count += max(inventory[i]-thresholdValue, 0)
+	}
+	count = orders - count
+	for i := 0; i < len(inventory); i++ {
+		if inventory[i] >= thresholdValue {
+			if count > 0 {
+				res += (thresholdValue + inventory[i]) * (inventory[i] - thresholdValue + 1) / 2
+				count--
+			} else {
+				res += (thresholdValue + 1 + inventory[i]) * (inventory[i] - thresholdValue) / 2
+			}
+		}
+	}
+	return res % mod
+}
+
+func max(a int, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+// 解法二 优先队列，超时！
+func maxProfit_(inventory []int, orders int) int {
 	res, mod := 0, 1000000007
 	q := PriorityQueue{}
 	for i := 0; i < len(inventory); i++ {