diff --git "a/lcof2/\345\211\221\346\214\207 Offer II 065. \346\234\200\347\237\255\347\232\204\345\215\225\350\257\215\347\274\226\347\240\201/README.md" "b/lcof2/\345\211\221\346\214\207 Offer II 065. \346\234\200\347\237\255\347\232\204\345\215\225\350\257\215\347\274\226\347\240\201/README.md"
index 07b44e6fab882..bf5ca8aaf2923 100644
--- "a/lcof2/\345\211\221\346\214\207 Offer II 065. \346\234\200\347\237\255\347\232\204\345\215\225\350\257\215\347\274\226\347\240\201/README.md"
+++ "b/lcof2/\345\211\221\346\214\207 Offer II 065. \346\234\200\347\237\255\347\232\204\345\215\225\350\257\215\347\274\226\347\240\201/README.md"
@@ -228,7 +228,7 @@ class Trie {
class Solution {
func minimumLengthEncoding(_ words: [String]) -> Int {
let root = Trie()
-
+
for word in words {
var current = root
for char in word.reversed() {
@@ -239,25 +239,25 @@ class Solution {
current = current.children[index]!
}
}
-
+
return dfs(root, 1)
}
-
+
private func dfs(_ current: Trie, _ length: Int) -> Int {
var isLeaf = true
var result = 0
-
+
for child in current.children {
if let child = child {
isLeaf = false
result += dfs(child, length + 1)
}
}
-
+
if isLeaf {
result += length
}
-
+
return result
}
}
diff --git a/solution/0200-0299/0251.Flatten 2D Vector/README.md b/solution/0200-0299/0251.Flatten 2D Vector/README.md
index fa3c2b976b810..479e7b3b4bb43 100644
--- a/solution/0200-0299/0251.Flatten 2D Vector/README.md
+++ b/solution/0200-0299/0251.Flatten 2D Vector/README.md
@@ -19,34 +19,50 @@ tags:
-请设计并实现一个能够展开二维向量的迭代器。该迭代器需要支持 next 和 hasNext 两种操作。
+请设计并实现一个能够展开二维向量的迭代器。该迭代器需要支持 next 和 hasNext 两种操作。
-
+实现 Vector2D 类：
-示例：
+
+ Vector2D(int[][] vec) 使用二维向量 vec 初始化对象next() 从二维向量返回下一个元素并将指针移动到下一个位置。你可以假设对 next 的所有调用都是合法的。hasNext() 当向量中还有元素返回 true，否则返回 false。
+
+
+
+示例 1：
-Vector2D iterator = new Vector2D([[1,2],[3],[4]]);
-
-iterator.next(); // 返回 1
-iterator.next(); // 返回 2
-iterator.next(); // 返回 3
-iterator.hasNext(); // 返回 true
-iterator.hasNext(); // 返回 true
-iterator.next(); // 返回 4
-iterator.hasNext(); // 返回 false
+输入：
+["Vector2D", "next", "next", "next", "hasNext", "hasNext", "next", "hasNext"]
+[[[[1, 2], [3], [4]]], [], [], [], [], [], [], []]
+输出：
+[null, 1, 2, 3, true, true, 4, false]
+
+解释：
+Vector2D vector2D = new Vector2D([[1, 2], [3], [4]]);
+vector2D.next(); // return 1
+vector2D.next(); // return 2
+vector2D.next(); // return 3
+vector2D.hasNext(); // return True
+vector2D.hasNext(); // return True
+vector2D.next(); // return 4
+vector2D.hasNext(); // return False
-
+
-注意：
+提示：
-
- - 请记得 重置 在 Vector2D 中声明的类变量（静态变量），因为类变量会 在多个测试用例中保持不变，影响判题准确。请 查阅 这里。
- - 你可以假定
next() 的调用总是合法的，即当 next() 被调用时，二维向量总是存在至少一个后续元素。
-
+
+ 0 <= vec.length <= 2000 <= vec[i].length <= 500-500 <= vec[i][j] <= 500- 最多调用
next 和 hasNext 105 次。
+
-
+
进阶：尝试在代码中仅使用 C++ 提供的迭代器 或 Java 提供的迭代器。
diff --git a/solution/0200-0299/0271.Encode and Decode Strings/README.md b/solution/0200-0299/0271.Encode and Decode Strings/README.md
index 9cc79cdfed43a..34cef582151f7 100644
--- a/solution/0200-0299/0271.Encode and Decode Strings/README.md
+++ b/solution/0200-0299/0271.Encode and Decode Strings/README.md
@@ -22,14 +22,16 @@ tags:
1 号机（发送方）有如下函数：
-string encode(vector<string> strs) {
+
+string encode(vector<string> strs) {
// ... your code
return encoded_string;
}
2 号机（接收方）有如下函数：
-vector<string> decode(string s) {
+
+vector<string> decode(string s) {
//... your code
return strs;
}
@@ -37,26 +39,61 @@ tags:
1 号机（发送方）执行：
-string encoded_string = encode(strs);
+
+string encoded_string = encode(strs);
2 号机（接收方）执行：
-vector<string> strs2 = decode(encoded_string);
+
+vector<string> strs2 = decode(encoded_string);
此时，2 号机（接收方）的 strs2 需要和 1 号机（发送方）的 strs 相同。
请你来实现这个 encode 和 decode 方法。
-注意：
+不允许使用任何序列化方法解决这个问题（例如 eval）。
+
+
+
+示例 1：
+
+
+输入：dummy_input = ["Hello","World"]
+输出：["Hello","World"]
+解释：
+1 号机：
+Codec encoder = new Codec();
+String msg = encoder.encode(strs);
+Machine 1 ---msg---> Machine 2
+
+2 号机：
+Codec decoder = new Codec();
+String[] strs = decoder.decode(msg);
+
+
+示例 2：
+
+
+输入：dummy_input = [""]
+输出：[""]
+
+
+
+
+提示：
- - 因为字符串可能会包含 256 个合法 ascii 字符中的任何字符，所以您的算法必须要能够处理任何可能会出现的字符。
- - 请勿使用 “类成员”、“全局变量” 或 “静态变量” 来存储这些状态，您的编码和解码算法应该是非状态依赖的。
- - 请不要依赖任何方法库，例如
eval 又或者是 serialize 之类的方法。本题的宗旨是需要您自己实现 “编码” 和 “解码” 算法。
+ 1 <= strs.length <= 2000 <= strs[i].length <= 200strs[i] 包含 256 个有效 ASCII 字符中的任何可能字符。
+
+
+进阶：你能编写一个通用算法来处理任何可能的字符集吗？
+
## 解法
diff --git a/solution/0500-0599/0553.Optimal Division/README.md b/solution/0500-0599/0553.Optimal Division/README.md
index 12f5ca390f051..64f2c4f175588 100644
--- a/solution/0500-0599/0553.Optimal Division/README.md
+++ b/solution/0500-0599/0553.Optimal Division/README.md
@@ -18,7 +18,7 @@ tags:
-给定一正整数数组 nums，nums 中的相邻整数将进行浮点除法。例如， [2,3,4] -> 2 / 3 / 4 。
+给定一正整数数组 nums，nums 中的相邻整数将进行浮点除法。
- 例如，
nums = [2,3,4]，我们将求表达式的值 "2/3/4"。
diff --git a/solution/0700-0799/0720.Longest Word in Dictionary/README.md b/solution/0700-0799/0720.Longest Word in Dictionary/README.md
index 9e22d310677f5..8f441c16a01eb 100644
--- a/solution/0700-0799/0720.Longest Word in Dictionary/README.md
+++ b/solution/0700-0799/0720.Longest Word in Dictionary/README.md
@@ -24,6 +24,8 @@ tags:
若其中有多个可行的答案，则返回答案中字典序最小的单词。若无答案，则返回空字符串。
+请注意，单词应该从左到右构建，每个额外的字符都添加到前一个单词的结尾。
+
示例 1：
diff --git a/solution/1200-1299/1236.Web Crawler/README.md b/solution/1200-1299/1236.Web Crawler/README.md
index 45784a53ca3d2..b8576d0677d3b 100644
--- a/solution/1200-1299/1236.Web Crawler/README.md
+++ b/solution/1200-1299/1236.Web Crawler/README.md
@@ -19,7 +19,7 @@ tags:
-给定一个链接 startUrl 和一个接口 HtmlParser ，请你实现一个网络爬虫，以实现爬取同 startUrl 拥有相同 域名标签 的全部链接。
+给定一个链接 startUrl 和一个接口 HtmlParser ，请你实现一个网络爬虫，以实现爬取同 startUrl 拥有相同 主机名 的全部链接。
该爬虫得到的全部链接可以 任何顺序 返回结果。
@@ -98,8 +98,8 @@ startUrl = "http://news.google.com"
1 <= urls.length <= 10001 <= urls[i].length <= 300startUrl 为 urls 中的一个。- 域名标签的长为1到63个字符（包括点），只能包含从‘a’到‘z’的ASCII字母、‘0’到‘9’的数字以及连字符即减号（‘-’）。
- - 域名标签不会以连字符即减号（‘-’）开头或结尾。
+ - 主机名的长为1到63个字符（包括点），只能包含从‘a’到‘z’的ASCII字母、‘0’到‘9’的数字以及连字符即减号（‘-’）。
+ - 主机名不会以连字符即减号（‘-’）开头或结尾。
- 关于域名有效性的约束可参考: https://en.wikipedia.org/wiki/Hostname#Restrictions_on_valid_hostnames
- 你可以假定url库中不包含重复项。
diff --git a/solution/1200-1299/1240.Tiling a Rectangle with the Fewest Squares/README.md b/solution/1200-1299/1240.Tiling a Rectangle with the Fewest Squares/README.md
index 86d73e72495d8..c49f1058fbf8c 100644
--- a/solution/1200-1299/1240.Tiling a Rectangle with the Fewest Squares/README.md
+++ b/solution/1200-1299/1240.Tiling a Rectangle with the Fewest Squares/README.md
@@ -18,13 +18,7 @@ tags:
-你是一位施工队的工长，根据设计师的要求准备为一套设计风格独特的房子进行室内装修。
-
-房子的客厅大小为 n x m，为保持极简的风格，需要使用尽可能少的 正方形 瓷砖来铺盖地面。
-
-假设正方形瓷砖的规格不限，边长都是整数。
-
-请你帮设计师计算一下，最少需要用到多少块方形瓷砖？
+给定一个大小为 n x m 的长方形，返回贴满矩形所需的整数边正方形的最小数量。
@@ -35,9 +29,9 @@ tags:
输入：n = 2, m = 3
输出：3
-解释：3 块地砖就可以铺满卧室。
- 2 块 1x1 地砖
- 1 块 2x2 地砖
+解释：需要 3 个正方形来覆盖长方形。
+ 2 个 1x1 的正方形
+ 1 个 2x2 的正方形
示例 2：
diff --git a/solution/1700-1799/1797.Design Authentication Manager/README.md b/solution/1700-1799/1797.Design Authentication Manager/README.md
index 2200c7f358588..dc8ada2c71010 100644
--- a/solution/1700-1799/1797.Design Authentication Manager/README.md
+++ b/solution/1700-1799/1797.Design Authentication Manager/README.md
@@ -7,6 +7,8 @@ source: 第 48 场双周赛 Q2
tags:
- 设计
- 哈希表
+ - 链表
+ - 双向链表
---
diff --git a/solution/1700-1799/1797.Design Authentication Manager/README_EN.md b/solution/1700-1799/1797.Design Authentication Manager/README_EN.md
index 49fc711dd514b..708ddcac61149 100644
--- a/solution/1700-1799/1797.Design Authentication Manager/README_EN.md
+++ b/solution/1700-1799/1797.Design Authentication Manager/README_EN.md
@@ -7,6 +7,8 @@ source: Biweekly Contest 48 Q2
tags:
- Design
- Hash Table
+ - Linked List
+ - Doubly-Linked List
---
diff --git a/solution/1900-1999/1940.Longest Common Subsequence Between Sorted Arrays/README.md b/solution/1900-1999/1940.Longest Common Subsequence Between Sorted Arrays/README.md
index 6385d3225b2d4..42fead4048c98 100644
--- a/solution/1900-1999/1940.Longest Common Subsequence Between Sorted Arrays/README.md
+++ b/solution/1900-1999/1940.Longest Common Subsequence Between Sorted Arrays/README.md
@@ -18,7 +18,7 @@ tags:
-给定一个由整数数组组成的数组 arrays，其中 arrays[i] 是 严格递增 排序的，返回一个表示 所有 数组之间的 最长公共子序列 的整数数组。
+给定一个由整数数组组成的数组 arrays，其中 arrays[i] 是 严格递增 排序的，返回一个 所有 数组均包含的 最长公共子序列 的整数数组。
子序列 是从另一个序列派生出来的序列，删除一些元素或不删除任何元素，而不改变其余元素的顺序。
diff --git a/solution/2800-2899/2806.Account Balance After Rounded Purchase/README_EN.md b/solution/2800-2899/2806.Account Balance After Rounded Purchase/README_EN.md
index 9f655c2f61cf3..ca089f3b76f0d 100644
--- a/solution/2800-2899/2806.Account Balance After Rounded Purchase/README_EN.md
+++ b/solution/2800-2899/2806.Account Balance After Rounded Purchase/README_EN.md
@@ -18,35 +18,57 @@ tags:
-Initially, you have a bank account balance of 100 dollars.
+Initially, you have a bank account balance of 100 dollars.
-You are given an integer purchaseAmount representing the amount you will spend on a purchase in dollars.
+You are given an integer purchaseAmount representing the amount you will spend on a purchase in dollars, in other words, its price.
-At the store where you will make the purchase, the purchase amount is rounded to the nearest multiple of 10. In other words, you pay a non-negative amount, roundedAmount, such that roundedAmount is a multiple of 10 and abs(roundedAmount - purchaseAmount) is minimized.
+When making the purchase, first the purchaseAmount is rounded to the nearest multiple of 10. Let us call this value roundedAmount. Then, roundedAmount dollars are removed from your bank account.
-If there is more than one nearest multiple of 10, the largest multiple is chosen.
+Return an integer denoting your final bank account balance after this purchase.
-Return an integer denoting your account balance after making a purchase worth purchaseAmount dollars from the store.
+Notes:
-Note: 0 is considered to be a multiple of 10 in this problem.
+
+ - 0 is considered to be a multiple of 10 in this problem.
+ - When rounding, 5 is rounded upward (5 is rounded to 10, 15 is rounded to 20, 25 to 30, and so on).
+
Example 1:
-
-Input: purchaseAmount = 9
-Output: 90
-Explanation: In this example, the nearest multiple of 10 to 9 is 10. Hence, your account balance becomes 100 - 10 = 90.
-
+
+
Input: purchaseAmount = 9
+
+
Output: 90
+
+
Explanation:
+
+
The nearest multiple of 10 to 9 is 10. So your account balance becomes 100 - 10 = 90.
+
Example 2:
-
-Input: purchaseAmount = 15
-Output: 80
-Explanation: In this example, there are two nearest multiples of 10 to 15: 10 and 20. So, the larger multiple, 20, is chosen.
-Hence, your account balance becomes 100 - 20 = 80.
-
+
+
Input: purchaseAmount = 15
+
+
Output: 80
+
+
Explanation:
+
+
The nearest multiple of 10 to 15 is 20. So your account balance becomes 100 - 20 = 80.
+
Example 3:
+
+
+
Input: purchaseAmount = 10
+
+
Output: 90
+
+
Explanation:
+
+
10 is a multiple of 10 itself. So your account balance becomes 100 - 10 = 90.
+
Constraints:
diff --git a/solution/2800-2899/2811.Check if it is Possible to Split Array/README.md b/solution/2800-2899/2811.Check if it is Possible to Split Array/README.md
index 2ad93a41d524c..d8d9dfbb86282 100644
--- a/solution/2800-2899/2811.Check if it is Possible to Split Array/README.md
+++ b/solution/2800-2899/2811.Check if it is Possible to Split Array/README.md
@@ -22,51 +22,69 @@ tags:
给你一个长度为 n 的数组 nums 和一个整数 m 。请你判断能否执行一系列操作，将数组拆分成 n 个 非空 数组。
-在每一步操作中，你可以选择一个 长度至少为 2 的现有数组（之前步骤的结果） 并将其拆分成 2 个子数组，而得到的 每个 子数组，至少 需要满足以下条件之一：
+一个数组被称为 好 的，如果：
- 子数组的长度为 1 ，或者
- 子数组元素之和 大于或等于
m 。
-如果你可以将给定数组拆分成 n 个满足要求的数组，返回 true ；否则，返回 false 。
+在每一步操作中，你可以选择一个 长度至少为 2 的现有数组（之前步骤的结果） 并将其拆分成 2 个子数组，而得到的 每个 子数组都需要是好的。
-注意：子数组是数组中的一个连续非空元素序列。
+如果你可以将给定数组拆分成 n 个满足要求的数组，返回 true ；否则，返回 false 。
-示例 1：
-
-
-输入：nums = [2, 2, 1], m = 4
-输出：true
-解释：
-第 1 步，将数组 nums 拆分成 [2, 2] 和 [1] 。
-第 2 步，将数组 [2, 2] 拆分成 [2] 和 [2] 。
-因此，答案为 true 。
-
-示例 2：
-
-
-输入：nums = [2, 1, 3], m = 5
-输出：false
-解释：
-存在两种不同的拆分方法：
-第 1 种，将数组 nums 拆分成 [2, 1] 和 [3] 。
-第 2 种，将数组 nums 拆分成 [2] 和 [1, 3] 。
-然而，这两种方法都不满足题意。因此，答案为 false 。
-
-示例 3：
-
-
-输入：nums = [2, 3, 3, 2, 3], m = 6
-输出：true
-解释：
-第 1 步，将数组 nums 拆分成 [2, 3, 3, 2] 和 [3] 。
-第 2 步，将数组 [2, 3, 3, 2] 拆分成 [2, 3, 3] 和 [2] 。
-第 3 步，将数组 [2, 3, 3] 拆分成 [2] 和 [3, 3] 。
-第 4 步，将数组 [3, 3] 拆分成 [3] 和 [3] 。
-因此，答案为 true 。
+示例 1：
+
+
+
输入：nums = [2, 2, 1], m = 4
+
+
输出：true
+
+
解释：
+
+
+ - 将
[2, 2, 1] 切分为 [2, 2] 和 [1]。数组 [1] 的长度为 1，数组 [2, 2] 的元素之和等于 4 >= m，所以两者都是好的数组。
+ - 将
[2, 2] 切分为 [2] 和 [2]。两个数组的长度都是 1，所以都是好的数组。
+
+
示例 2：
+
+
+
输入：nums = [2, 1, 3], m = 5
+
+
输出：false
+
+
解释：
+
+
第一步必须是以下之一：
+
+
+ - 将
[2, 1, 3] 切分为 [2, 1] 和 [3]。数组 [2, 1] 既不是长度为 1，也没有大于或等于 m 的元素和。
+ - 将
[2, 1, 3] 切分为 [2] 和 [1, 3]。数组 [1, 3] 既不是长度为 1，也没有大于或等于 m 的元素和。
+
+
+
因此，由于这两个操作都无效（它们没有将数组分成两个好的数组），因此我们无法将 nums 分成 n 个大小为 1 的数组。
+
示例 3：
+
+
+
输入：nums = [2, 3, 3, 2, 3], m = 6
+
+
输出：true
+
+
解释：
+
+
+ - 将
[2, 3, 3, 2, 3] 切分为 [2] 和 [3, 3, 2, 3]。
+ - 将
[3, 3, 2, 3] 切分为 [3, 3, 2] 和 [3]。
+ - 将
[3, 3, 2] 切分为 [3, 3] 和 [2]。
+ - 将
[3, 3] 切分为 [3] 和 [3]。
+
+
diff --git a/solution/2800-2899/2811.Check if it is Possible to Split Array/README_EN.md b/solution/2800-2899/2811.Check if it is Possible to Split Array/README_EN.md
index 2ff6f893464c1..5d2afa2c413a6 100644
--- a/solution/2800-2899/2811.Check if it is Possible to Split Array/README_EN.md
+++ b/solution/2800-2899/2811.Check if it is Possible to Split Array/README_EN.md
@@ -20,41 +20,70 @@ tags:
-You are given an array nums of length n and an integer m. You need to determine if it is possible to split the array into n non-empty arrays by performing a series of steps.
+You are given an array nums of length n and an integer m. You need to determine if it is possible to split the array into n arrays of size 1 by performing a series of steps.
-In each step, you can select an existing array (which may be the result of previous steps) with a length of at least two and split it into two subarrays, if, for each resulting subarray, at least one of the following holds:
+An array is called good if:
- - The length of the subarray is one, or
- - The sum of elements of the subarray is greater than or equal to
m.
+ - The length of the array is one, or
+ - The sum of the elements of the array is greater than or equal to
m.
-Return true if you can split the given array into n arrays, otherwise return false.
+In each step, you can select an existing array (which may be the result of previous steps) with a length of at least two and split it into two arrays, if both resulting arrays are good.
-Note: A subarray is a contiguous non-empty sequence of elements within an array.
+Return true if you can split the given array into n arrays, otherwise return false.
Example 1:
-
-Input: nums = [2, 2, 1], m = 4
-Output: true
-Explanation: We can split the array into [2, 2] and [1] in the first step. Then, in the second step, we can split [2, 2] into [2] and [2]. As a result, the answer is true.
+
+
Input: nums = [2, 2, 1], m = 4
+
+
Output: true
+
+
Explanation:
+
+
+ - Split
[2, 2, 1] to [2, 2] and [1]. The array [1] has a length of one, and the array [2, 2] has the sum of its elements equal to 4 >= m, so both are good arrays.
+ - Split
[2, 2] to [2] and [2]. both arrays have the length of one, so both are good arrays.
+
+
Example 2:
-
-Input: nums = [2, 1, 3], m = 5
-Output: false
-Explanation: We can try splitting the array in two different ways: the first way is to have [2, 1] and [3], and the second way is to have [2] and [1, 3]. However, both of these ways are not valid. So, the answer is false.
+
+
Input: nums = [2, 1, 3], m = 5
+
+
Output: false
+
+
Explanation:
+
+
The first move has to be either of the following:
+
+
+ - Split
[2, 1, 3] to [2, 1] and [3]. The array [2, 1] has neither length of one nor sum of elements greater than or equal to m.
+ - Split
[2, 1, 3] to [2] and [1, 3]. The array [1, 3] has neither length of one nor sum of elements greater than or equal to m.
+
+
+
So as both moves are invalid (they do not divide the array into two good arrays), we are unable to split nums into n arrays of size 1.
+
Example 3:
-
-Input: nums = [2, 3, 3, 2, 3], m = 6
-Output: true
-Explanation: We can split the array into [2, 3, 3, 2] and [3] in the first step. Then, in the second step, we can split [2, 3, 3, 2] into [2, 3, 3] and [2]. Then, in the third step, we can split [2, 3, 3] into [2] and [3, 3]. And in the last step we can split [3, 3] into [3] and [3]. As a result, the answer is true.
-
+
+
Input: nums = [2, 3, 3, 2, 3], m = 6
+
+
Output: true
+
+
Explanation:
+
+
+ - Split
[2, 3, 3, 2, 3] to [2] and [3, 3, 2, 3].
+ - Split
[3, 3, 2, 3] to [3, 3, 2] and [3].
+ - Split
[3, 3, 2] to [3, 3] and [2].
+ - Split
[3, 3] to [3] and [3].
+
+
Constraints:
diff --git a/solution/3000-3099/3003.Maximize the Number of Partitions After Operations/README.md b/solution/3000-3099/3003.Maximize the Number of Partitions After Operations/README.md
index 7945e57b62d6b..18c1e2d54aaa0 100644
--- a/solution/3000-3099/3003.Maximize the Number of Partitions After Operations/README.md
+++ b/solution/3000-3099/3003.Maximize the Number of Partitions After Operations/README.md
@@ -26,63 +26,63 @@ tags:
你需要执行以下分割操作，直到字符串 s 变为 空：
- - 选择
s 的最长前缀，该前缀最多包含 k 个 不同 字符。
+ - 选择
s 的最长 前缀，该前缀最多包含 k 个 不同 字符。
- 删除 这个前缀，并将分割数量加一。如果有剩余字符，它们在
s 中保持原来的顺序。
执行操作之 前 ，你可以将 s 中 至多一处 下标的对应字符更改为另一个小写英文字母。
-在最优选择情形下改变至多一处下标对应字符后，用整数表示并返回操作结束时得到的最大分割数量。
+在最优选择情形下改变至多一处下标对应字符后，用整数表示并返回操作结束时得到的 最大 分割数量。
示例 1：
-
-输入：s = "accca", k = 2
-输出：3
-解释：在此示例中，为了最大化得到的分割数量，可以将 s[2] 改为 'b'。
-s 变为 "acbca"。
-按照以下方式执行操作，直到 s 变为空：
-- 选择最长且至多包含 2 个不同字符的前缀，"acbca"。
-- 删除该前缀，s 变为 "bca"。现在分割数量为 1。
-- 选择最长且至多包含 2 个不同字符的前缀，"bca"。
-- 删除该前缀，s 变为 "a"。现在分割数量为 2。
-- 选择最长且至多包含 2 个不同字符的前缀，"a"。
-- 删除该前缀，s 变为空。现在分割数量为 3。
-因此，答案是 3。
-可以证明，分割数量不可能超过 3。
+
+
输入：s = "accca", k = 2
+
+
输出：3
+
+
解释：
+
+
最好的方式是把 s[2] 变为除了 a 和 c 之外的东西，比如 b。然后它变成了 "acbca"。
+
+
然后我们执行以下操作：
+
+
+ - 最多包含 2 个不同字符的最长前缀是
"ac"，我们删除它然后 s 变为 "bca"。
+ - 现在最多包含 2 个不同字符的最长前缀是
"bc"，所以我们删除它然后 s 变为 "a"。
+ - 最后，我们删除
"a" 并且 s 变成空串，所以该过程结束。
+
+
+
进行操作时，字符串被分成 3 个部分，所以答案是 3。
+
示例 2：
-
-输入：s = "aabaab", k = 3
-输出：1
-解释：在此示例中，为了最大化得到的分割数量，可以保持 s 不变。
-按照以下方式执行操作，直到 s 变为空：
-- 选择最长且至多包含 3 个不同字符的前缀，"aabaab"。
-- 删除该前缀，s 变为空。现在分割数量为 1。
-因此，答案是 1。
-可以证明，分割数量不可能超过 1。
+
+
输入：s = "aabaab", k = 3
+
+
输出：1
+
+
解释：
+
+
一开始 s 包含 2 个不同的字符，所以无论我们改变哪个， 它最多包含 3 个不同字符，因此最多包含 3 个不同字符的最长前缀始终是所有字符，因此答案是 1。
+
示例 3：
-
-输入：s = "xxyz", k = 1
-输出：4
-解释：在此示例中，为了最大化得到的分割数量，可以将 s[1] 改为 'a'。
-s 变为 "xayz"。
-按照以下方式执行操作，直到 s 变为空：
-- 选择最长且至多包含 1 个不同字符的前缀，"xayz"。
-- 删除该前缀，s 变为 "ayz"。现在分割数量为 1。
-- 选择最长且至多包含 1 个不同字符的前缀，"ayz"。
-- 删除该前缀，s 变为 "yz"，现在分割数量为 2。
-- 选择最长且至多包含 1 个不同字符的前缀，"yz"。
-- 删除该前缀，s 变为 "z"。现在分割数量为 3。
-- 选择最且至多包含 1 个不同字符的前缀，"z"。
-- 删除该前缀，s 变为空。现在分割数量为 4。
-因此，答案是 4。
-可以证明，分割数量不可能超过 4。
+
+
输入：s = "xxyz", k = 1
+
+
输出：4
+
+
解释：
+
+
最好的方式是将 s[0] 或 s[1] 变为 s 中字符以外的东西，例如将 s[0] 变为 w。
+
+
然后 s 变为 "wxyz"，包含 4 个不同的字符，所以当 k 为 1，它将分为 4 个部分。
+
diff --git a/solution/3000-3099/3003.Maximize the Number of Partitions After Operations/README_EN.md b/solution/3000-3099/3003.Maximize the Number of Partitions After Operations/README_EN.md
index 963eb2f4f2e59..68a74034f013e 100644
--- a/solution/3000-3099/3003.Maximize the Number of Partitions After Operations/README_EN.md
+++ b/solution/3000-3099/3003.Maximize the Number of Partitions After Operations/README_EN.md
@@ -21,68 +21,67 @@ tags:
-You are given a 0-indexed string s and an integer k.
+You are given a string s and an integer k.
-You are to perform the following partitioning operations until s is empty:
+First, you are allowed to change at most one index in s to another lowercase English letter.
+
+After that, do the following partitioning operation until s is empty:
- Choose the longest prefix of
s containing at most k distinct characters.
- Delete the prefix from
s and increase the number of partitions by one. The remaining characters (if any) in s maintain their initial order.
-Before the operations, you are allowed to change at most one index in s to another lowercase English letter.
+Return an integer denoting the maximum number of resulting partitions after the operations by optimally choosing at most one index to change.
-Return an integer denoting the maximum number of resulting partitions after the operations by optimally choosing at most one index to change.
Example 1:
-
-Input: s = "accca", k = 2
-Output: 3
-Explanation: In this example, to maximize the number of resulting partitions, s[2] can be changed to 'b'.
-s becomes "acbca".
-The operations can now be performed as follows until s becomes empty:
-- Choose the longest prefix containing at most 2 distinct characters, "acbca".
-- Delete the prefix, and s becomes "bca". The number of partitions is now 1.
-- Choose the longest prefix containing at most 2 distinct characters, "bca".
-- Delete the prefix, and s becomes "a". The number of partitions is now 2.
-- Choose the longest prefix containing at most 2 distinct characters, "a".
-- Delete the prefix, and s becomes empty. The number of partitions is now 3.
-Hence, the answer is 3.
-It can be shown that it is not possible to obtain more than 3 partitions.
+
+
Input: s = "accca", k = 2
+
+
Output: 3
+
+
Explanation:
+
+
The optimal way is to change s[2] to something other than a and c, for example, b. then it becomes "acbca".
+
+
Then we perform the operations:
+
+
+ - The longest prefix containing at most 2 distinct characters is
"ac", we remove it and s becomes "bca".
+ - Now The longest prefix containing at most 2 distinct characters is
"bc", so we remove it and s becomes "a".
+ - Finally, we remove
"a" and s becomes empty, so the procedure ends.
+
+
+
Doing the operations, the string is divided into 3 partitions, so the answer is 3.
+
Example 2:
-
-Input: s = "aabaab", k = 3
-Output: 1
-Explanation: In this example, to maximize the number of resulting partitions we can leave s as it is.
-The operations can now be performed as follows until s becomes empty:
-- Choose the longest prefix containing at most 3 distinct characters, "aabaab".
-- Delete the prefix, and s becomes empty. The number of partitions becomes 1.
-Hence, the answer is 1.
-It can be shown that it is not possible to obtain more than 1 partition.
-
+
+
Input: s = "aabaab", k = 3
+
+
Output: 1
+
+
Explanation:
+
+
Initially s contains 2 distinct characters, so whichever character we change, it will contain at most 3 distinct characters, so the longest prefix with at most 3 distinct characters would always be all of it, therefore the answer is 1.
+
Example 3:
-
-Input: s = "xxyz", k = 1
-Output: 4
-Explanation: In this example, to maximize the number of resulting partitions, s[1] can be changed to 'a'.
-s becomes "xayz".
-The operations can now be performed as follows until s becomes empty:
-- Choose the longest prefix containing at most 1 distinct character, "xayz".
-- Delete the prefix, and s becomes "ayz". The number of partitions is now 1.
-- Choose the longest prefix containing at most 1 distinct character, "ayz".
-- Delete the prefix, and s becomes "yz". The number of partitions is now 2.
-- Choose the longest prefix containing at most 1 distinct character, "yz".
-- Delete the prefix, and s becomes "z". The number of partitions is now 3.
-- Choose the longest prefix containing at most 1 distinct character, "z".
-- Delete the prefix, and s becomes empty. The number of partitions is now 4.
-Hence, the answer is 4.
-It can be shown that it is not possible to obtain more than 4 partitions.
-
+
+
Input: s = "xxyz", k = 1
+
+
Output: 4
+
+
Explanation:
+
+
The optimal way is to change s[0] or s[1] to something other than characters in s, for example, to change s[0] to w.
+
+
Then s becomes "wxyz", which consists of 4 distinct characters, so as k is 1, it will divide into 4 partitions.
+
Constraints:
diff --git a/solution/3000-3099/3025.Find the Number of Ways to Place People I/README.md b/solution/3000-3099/3025.Find the Number of Ways to Place People I/README.md
index b285c4000491a..28038238a58f8 100644
--- a/solution/3000-3099/3025.Find the Number of Ways to Place People I/README.md
+++ b/solution/3000-3099/3025.Find the Number of Ways to Place People I/README.md
@@ -24,57 +24,68 @@ tags:
给你一个 n x 2 的二维数组 points ，它表示二维平面上的一些点坐标，其中 points[i] = [xi, yi] 。
-我们定义 x 轴的正方向为 右 （x 轴递增的方向），x 轴的负方向为 左 （x 轴递减的方向）。类似的，我们定义 y 轴的正方向为 上 （y 轴递增的方向），y 轴的负方向为 下 （y 轴递减的方向）。
-
-你需要安排这 n 个人的站位，这 n 个人中包括 Alice 和 Bob 。你需要确保每个点处 恰好 有 一个 人。同时，Alice 想跟 Bob 单独玩耍，所以 Alice 会以 Alice 的坐标为 左上角 ， Bob 的坐标为 右下角 建立一个矩形的围栏（注意，围栏可能 不 包含任何区域，也就是说围栏可能是一条线段）。如果围栏的 内部 或者 边缘 上有任何其他人，Alice 都会难过。
-
-请你在确保 Alice 不会 难过的前提下，返回 Alice 和 Bob 可以选择的 点对 数目。
+
-注意，Alice 建立的围栏必须确保 Alice 的位置是矩形的左上角，Bob 的位置是矩形的右下角。比方说，以 (1, 1) ，(1, 3) ，(3, 1) 和 (3, 3) 为矩形的四个角，给定下图的两个输入，Alice 都不能建立围栏，原因如下：
+计算点对 (A, B) 的数量，其中
- - 图一中，Alice 在
(3, 3) 且 Bob 在 (1, 1) ，Alice 的位置不是左上角且 Bob 的位置不是右下角。
- - 图二中，Alice 在
(1, 3) 且 Bob 在 (1, 1) ，Bob 的位置不是在围栏的右下角。
+ A 在 B 的左上角，并且- 它们形成的长方形中（或直线上）没有其它点（包括边界）。
-
+
+返回数量。
+
示例 1：
-
+
+
输入：points = [[1,1],[2,2],[3,3]]
-
-输入：points = [[1,1],[2,2],[3,3]]
-输出：0
-解释：没有办法可以让 Alice 的围栏以 Alice 的位置为左上角且 Bob 的位置为右下角。所以我们返回 0 。
-
+
输出：0
+
+
解释：
+
+
+
+
没有办法选择 A 和 B，使得 A 在 B 的左上角。
+
示例 2：
-
+
+
输入：points = [[6,2],[4,4],[2,6]]
+
+
输出：2
+
+
解释：
-
-输入：points = [[6,2],[4,4],[2,6]]
-输出：2
-解释：总共有 2 种方案安排 Alice 和 Bob 的位置，使得 Alice 不会难过：
-- Alice 站在 (4, 4) ，Bob 站在 (6, 2) 。
-- Alice 站在 (2, 6) ，Bob 站在 (4, 4) 。
-不能安排 Alice 站在 (2, 6) 且 Bob 站在 (6, 2) ，因为站在 (4, 4) 的人处于围栏内。
-
+
+
+
+ - 左边的是点对
(points[1], points[0])，其中 points[1] 在 points[0] 的左上角，并且形成的长方形内部是空的。
+ - 中间的是点对
(points[2], points[1])，和左边的一样是合法的点对。
+ - 右边的是点对
(points[2], points[0])，其中 points[2] 在 points[0] 的左上角，但 points[1] 在长方形内部，所以不是一个合法的点对。
+
+
示例 3：
-
-
-
-输入：points = [[3,1],[1,3],[1,1]]
-输出：2
-解释：总共有 2 种方案安排 Alice 和 Bob 的位置，使得 Alice 不会难过：
-- Alice 站在 (1, 1) ，Bob 站在 (3, 1) 。
-- Alice 站在 (1, 3) ，Bob 站在 (1, 1) 。
-不能安排 Alice 站在 (1, 3) 且 Bob 站在 (3, 1) ，因为站在 (1, 1) 的人处于围栏内。
-注意围栏是可以不包含任何面积的，上图中第一和第二个围栏都是合法的。
-
+
+
输入：points = [[3,1],[1,3],[1,1]]
+
+
输出：2
+
+
解释：
+
+
+
+
+ - 左边的是点对
(points[2], points[0])，其中 points[2] 在 points[0] 的左上角并且在它们形成的直线上没有其它点。注意两个点形成一条线的情况是合法的。
+ - 中间的是点对
(points[1], points[2])，和左边一样也是合法的点对。
+ - 右边的是点对
(points[1], points[0])，它不是合法的点对，因为 points[2] 在长方形的边上。
+
+
diff --git a/solution/3000-3099/3025.Find the Number of Ways to Place People I/README_EN.md b/solution/3000-3099/3025.Find the Number of Ways to Place People I/README_EN.md
index 4ff37de556ffc..df423c1d7da44 100644
--- a/solution/3000-3099/3025.Find the Number of Ways to Place People I/README_EN.md
+++ b/solution/3000-3099/3025.Find the Number of Ways to Place People I/README_EN.md
@@ -22,52 +22,67 @@ tags:
-You are given a 2D array points of size n x 2 representing integer coordinates of some points on a 2D-plane, where points[i] = [xi, yi].
+You are given a 2D array points of size n x 2 representing integer coordinates of some points on a 2D plane, where points[i] = [xi, yi].
-We define the right direction as positive x-axis (increasing x-coordinate) and the left direction as negative x-axis (decreasing x-coordinate). Similarly, we define the up direction as positive y-axis (increasing y-coordinate) and the down direction as negative y-axis (decreasing y-coordinate)
-
-You have to place n people, including Alice and Bob, at these points such that there is exactly one person at every point. Alice wants to be alone with Bob, so Alice will build a rectangular fence with Alice's position as the upper left corner and Bob's position as the lower right corner of the fence (Note that the fence might not enclose any area, i.e. it can be a line). If any person other than Alice and Bob is either inside the fence or on the fence, Alice will be sad.
-
-Return the number of pairs of points where you can place Alice and Bob, such that Alice does not become sad on building the fence.
-
-Note that Alice can only build a fence with Alice's position as the upper left corner, and Bob's position as the lower right corner. For example, Alice cannot build either of the fences in the picture below with four corners (1, 1), (1, 3), (3, 1), and (3, 3), because:
+Count the number of pairs of points (A, B), where
- - With Alice at
(3, 3) and Bob at (1, 1), Alice's position is not the upper left corner and Bob's position is not the lower right corner of the fence.
- - With Alice at
(1, 3) and Bob at (1, 1), Bob's position is not the lower right corner of the fence.
+ A is on the upper left side of B, and- there are no other points in the rectangle (or line) they make (including the border).
-
+
+Return the count.
+
Example 1:
-
-
-Input: points = [[1,1],[2,2],[3,3]]
-Output: 0
-Explanation: There is no way to place Alice and Bob such that Alice can build a fence with Alice's position as the upper left corner and Bob's position as the lower right corner. Hence we return 0.
-
+
+
+
Input: points = [[1,1],[2,2],[3,3]]
+
+
Output: 0
+
+
Explanation:
+
+
+
+
There is no way to choose A and B so A is on the upper left side of B.
+
Example 2:
-
-
-Input: points = [[6,2],[4,4],[2,6]]
-Output: 2
-Explanation: There are two ways to place Alice and Bob such that Alice will not be sad:
-- Place Alice at (4, 4) and Bob at (6, 2).
-- Place Alice at (2, 6) and Bob at (4, 4).
-You cannot place Alice at (2, 6) and Bob at (6, 2) because the person at (4, 4) will be inside the fence.
-
+
+
+
Input: points = [[6,2],[4,4],[2,6]]
+
+
Output: 2
+
+
Explanation:
+
+
+
+
+ - The left one is the pair
(points[1], points[0]), where points[1] is on the upper left side of points[0] and the rectangle is empty.
+ - The middle one is the pair
(points[2], points[1]), same as the left one it is a valid pair.
+ - The right one is the pair
(points[2], points[0]), where points[2] is on the upper left side of points[0], but points[1] is inside the rectangle so it's not a valid pair.
+
+
Example 3:
-
-
-Input: points = [[3,1],[1,3],[1,1]]
-Output: 2
-Explanation: There are two ways to place Alice and Bob such that Alice will not be sad:
-- Place Alice at (1, 1) and Bob at (3, 1).
-- Place Alice at (1, 3) and Bob at (1, 1).
-You cannot place Alice at (1, 3) and Bob at (3, 1) because the person at (1, 1) will be on the fence.
-Note that it does not matter if the fence encloses any area, the first and second fences in the image are valid.
-
+
+
+
Input: points = [[3,1],[1,3],[1,1]]
+
+
Output: 2
+
+
Explanation:
+
+
+
+
+ - The left one is the pair
(points[2], points[0]), where points[2] is on the upper left side of points[0] and there are no other points on the line they form. Note that it is a valid state when the two points form a line.
+ - The middle one is the pair
(points[1], points[2]), it is a valid pair same as the left one.
+ - The right one is the pair
(points[1], points[0]), it is not a valid pair as points[2] is on the border of the rectangle.
+
+
Constraints:
diff --git a/solution/3000-3099/3030.Find the Grid of Region Average/README_EN.md b/solution/3000-3099/3030.Find the Grid of Region Average/README_EN.md
index ca8da739fddae..736b2f173980d 100644
--- a/solution/3000-3099/3030.Find the Grid of Region Average/README_EN.md
+++ b/solution/3000-3099/3030.Find the Grid of Region Average/README_EN.md
@@ -19,43 +19,62 @@ tags:
-You are given a 0-indexed m x n grid image which represents a grayscale image, where image[i][j] represents a pixel with intensity in the range[0..255]. You are also given a non-negative integer threshold.
+You are given m x n grid image which represents a grayscale image, where image[i][j] represents a pixel with intensity in the range [0..255]. You are also given a non-negative integer threshold.
-Two pixels image[a][b] and image[c][d] are said to be adjacent if |a - c| + |b - d| == 1.
+Two pixels are adjacent if they share an edge.
A region is a 3 x 3 subgrid where the absolute difference in intensity between any two adjacent pixels is less than or equal to threshold.
-All pixels in a region belong to that region, note that a pixel can belong to multiple regions.
+All pixels in a region belong to that region, note that a pixel can belong to multiple regions.
-You need to calculate a 0-indexed m x n grid result, where result[i][j] is the average intensity of the region to which image[i][j] belongs, rounded down to the nearest integer. If image[i][j] belongs to multiple regions, result[i][j] is the average of the rounded down average intensities of these regions, rounded down to the nearest integer. If image[i][j] does not belong to any region, result[i][j] is equal to image[i][j].
+You need to calculate a m x n grid result, where result[i][j] is the average intensity of the regions to which image[i][j] belongs, rounded down to the nearest integer. If image[i][j] belongs to multiple regions, result[i][j] is the average of the rounded-down average intensities of these regions, rounded down to the nearest integer. If image[i][j] does not belong to any region, result[i][j] is equal to image[i][j].
-Return the grid result.
+Return the grid result.
Example 1:
-
-
-Input: image = [[5,6,7,10],[8,9,10,10],[11,12,13,10]], threshold = 3
-Output: [[9,9,9,9],[9,9,9,9],[9,9,9,9]]
-Explanation: There exist two regions in the image, which are shown as the shaded areas in the picture. The average intensity of the first region is 9, while the average intensity of the second region is 9.67 which is rounded down to 9. The average intensity of both of the regions is (9 + 9) / 2 = 9. As all the pixels belong to either region 1, region 2, or both of them, the intensity of every pixel in the result is 9.
-Please note that the rounded-down values are used when calculating the average of multiple regions, hence the calculation is done using 9 as the average intensity of region 2, not 9.67.
-
+
+
+
Input: image = [[5,6,7,10],[8,9,10,10],[11,12,13,10]], threshold = 3
+
+
Output: [[9,9,9,9],[9,9,9,9],[9,9,9,9]]
+
+
Explanation:
+
+
+
+
There are two regions as illustrated above. The average intensity of the first region is 9, while the average intensity of the second region is 9.67 which is rounded down to 9. The average intensity of both of the regions is (9 + 9) / 2 = 9. As all the pixels belong to either region 1, region 2, or both of them, the intensity of every pixel in the result is 9.
+
+
Please note that the rounded-down values are used when calculating the average of multiple regions, hence the calculation is done using 9 as the average intensity of region 2, not 9.67.
+
Example 2:
-
-
-Input: image = [[10,20,30],[15,25,35],[20,30,40],[25,35,45]], threshold = 12
-Output: [[25,25,25],[27,27,27],[27,27,27],[30,30,30]]
-Explanation: There exist two regions in the image, which are shown as the shaded areas in the picture. The average intensity of the first region is 25, while the average intensity of the second region is 30. The average intensity of both of the regions is (25 + 30) / 2 = 27.5 which is rounded down to 27. All the pixels in row 0 of the image belong to region 1, hence all the pixels in row 0 in the result are 25. Similarly, all the pixels in row 3 in the result are 30. The pixels in rows 1 and 2 of the image belong to region 1 and region 2, hence their assigned value is 27 in the result.
-
+
+
+
Input: image = [[10,20,30],[15,25,35],[20,30,40],[25,35,45]], threshold = 12
+
+
Output: [[25,25,25],[27,27,27],[27,27,27],[30,30,30]]
+
+
Explanation:
+
+
+
+
There are two regions as illustrated above. The average intensity of the first region is 25, while the average intensity of the second region is 30. The average intensity of both of the regions is (25 + 30) / 2 = 27.5 which is rounded down to 27.
+
+
All the pixels in row 0 of the image belong to region 1, hence all the pixels in row 0 in the result are 25. Similarly, all the pixels in row 3 in the result are 30. The pixels in rows 1 and 2 of the image belong to region 1 and region 2, hence their assigned value is 27 in the result.
+
Example 3:
-
-Input: image = [[5,6,7],[8,9,10],[11,12,13]], threshold = 1
-Output: [[5,6,7],[8,9,10],[11,12,13]]
-Explanation: There does not exist any region in image, hence result[i][j] == image[i][j] for all the pixels.
-
+
+
Input: image = [[5,6,7],[8,9,10],[11,12,13]], threshold = 1
+
+
Output: [[5,6,7],[8,9,10],[11,12,13]]
+
+
Explanation:
+
+
There is only one 3 x 3 subgrid, while it does not have the condition on difference of adjacent pixels, for example, the difference between image[0][0] and image[1][0] is |5 - 8| = 3 > threshold = 1. None of them belong to any valid regions, so the result should be the same as image.
+
Constraints:
diff --git a/solution/3100-3199/3198.Find Cities in Each State/README.md b/solution/3100-3199/3198.Find Cities in Each State/README.md
index d340f3d27c5d0..85cb818fc9b84 100644
--- a/solution/3100-3199/3198.Find Cities in Each State/README.md
+++ b/solution/3100-3199/3198.Find Cities in Each State/README.md
@@ -2,6 +2,8 @@
comments: true
difficulty: 简单
edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3198.Find%20Cities%20in%20Each%20State/README.md
+tags:
+ - 数据库
---
diff --git a/solution/3100-3199/3198.Find Cities in Each State/README_EN.md b/solution/3100-3199/3198.Find Cities in Each State/README_EN.md
index 996bb54bffad1..6ab2b5c2afa5b 100644
--- a/solution/3100-3199/3198.Find Cities in Each State/README_EN.md
+++ b/solution/3100-3199/3198.Find Cities in Each State/README_EN.md
@@ -2,6 +2,8 @@
comments: true
difficulty: Easy
edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3198.Find%20Cities%20in%20Each%20State/README_EN.md
+tags:
+ - Database
---
diff --git a/solution/3100-3199/3199.Count Triplets with Even XOR Set Bits I/README.md b/solution/3100-3199/3199.Count Triplets with Even XOR Set Bits I/README.md
index c7eb7ebe1b196..34d390b223bb2 100644
--- a/solution/3100-3199/3199.Count Triplets with Even XOR Set Bits I/README.md
+++ b/solution/3100-3199/3199.Count Triplets with Even XOR Set Bits I/README.md
@@ -2,6 +2,9 @@
comments: true
difficulty: 简单
edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3199.Count%20Triplets%20with%20Even%20XOR%20Set%20Bits%20I/README.md
+tags:
+ - 位运算
+ - 数组
---
diff --git a/solution/3100-3199/3199.Count Triplets with Even XOR Set Bits I/README_EN.md b/solution/3100-3199/3199.Count Triplets with Even XOR Set Bits I/README_EN.md
index 4695368ed8316..de27cc5e8acfd 100644
--- a/solution/3100-3199/3199.Count Triplets with Even XOR Set Bits I/README_EN.md
+++ b/solution/3100-3199/3199.Count Triplets with Even XOR Set Bits I/README_EN.md
@@ -2,6 +2,9 @@
comments: true
difficulty: Easy
edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3199.Count%20Triplets%20with%20Even%20XOR%20Set%20Bits%20I/README_EN.md
+tags:
+ - Bit Manipulation
+ - Array
---
diff --git a/solution/3200-3299/3200.Maximum Height of a Triangle/README.md b/solution/3200-3299/3200.Maximum Height of a Triangle/README.md
index acf9ad4a05cff..a2d75a955a96d 100644
--- a/solution/3200-3299/3200.Maximum Height of a Triangle/README.md
+++ b/solution/3200-3299/3200.Maximum Height of a Triangle/README.md
@@ -2,6 +2,9 @@
comments: true
difficulty: 简单
edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3200.Maximum%20Height%20of%20a%20Triangle/README.md
+tags:
+ - 数组
+ - 枚举
---
diff --git a/solution/3200-3299/3200.Maximum Height of a Triangle/README_EN.md b/solution/3200-3299/3200.Maximum Height of a Triangle/README_EN.md
index 515796ae752a4..de3101a17171a 100644
--- a/solution/3200-3299/3200.Maximum Height of a Triangle/README_EN.md
+++ b/solution/3200-3299/3200.Maximum Height of a Triangle/README_EN.md
@@ -2,6 +2,9 @@
comments: true
difficulty: Easy
edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3200.Maximum%20Height%20of%20a%20Triangle/README_EN.md
+tags:
+ - Array
+ - Enumeration
---
diff --git a/solution/3200-3299/3201.Find the Maximum Length of Valid Subsequence I/README.md b/solution/3200-3299/3201.Find the Maximum Length of Valid Subsequence I/README.md
index 1672826fd2806..a98471f360059 100644
--- a/solution/3200-3299/3201.Find the Maximum Length of Valid Subsequence I/README.md
+++ b/solution/3200-3299/3201.Find the Maximum Length of Valid Subsequence I/README.md
@@ -2,6 +2,9 @@
comments: true
difficulty: 中等
edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3201.Find%20the%20Maximum%20Length%20of%20Valid%20Subsequence%20I/README.md
+tags:
+ - 数组
+ - 动态规划
---
diff --git a/solution/3200-3299/3201.Find the Maximum Length of Valid Subsequence I/README_EN.md b/solution/3200-3299/3201.Find the Maximum Length of Valid Subsequence I/README_EN.md
index 9f83f55be3589..39dfc41a73f54 100644
--- a/solution/3200-3299/3201.Find the Maximum Length of Valid Subsequence I/README_EN.md
+++ b/solution/3200-3299/3201.Find the Maximum Length of Valid Subsequence I/README_EN.md
@@ -2,6 +2,9 @@
comments: true
difficulty: Medium
edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3201.Find%20the%20Maximum%20Length%20of%20Valid%20Subsequence%20I/README_EN.md
+tags:
+ - Array
+ - Dynamic Programming
---
diff --git a/solution/3200-3299/3202.Find the Maximum Length of Valid Subsequence II/README.md b/solution/3200-3299/3202.Find the Maximum Length of Valid Subsequence II/README.md
index a000115d89510..54b682ad38c54 100644
--- a/solution/3200-3299/3202.Find the Maximum Length of Valid Subsequence II/README.md
+++ b/solution/3200-3299/3202.Find the Maximum Length of Valid Subsequence II/README.md
@@ -2,6 +2,9 @@
comments: true
difficulty: 中等
edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3202.Find%20the%20Maximum%20Length%20of%20Valid%20Subsequence%20II/README.md
+tags:
+ - 数组
+ - 动态规划
---
diff --git a/solution/3200-3299/3202.Find the Maximum Length of Valid Subsequence II/README_EN.md b/solution/3200-3299/3202.Find the Maximum Length of Valid Subsequence II/README_EN.md
index 2d450203c4cfd..fb4b41acfbcf5 100644
--- a/solution/3200-3299/3202.Find the Maximum Length of Valid Subsequence II/README_EN.md
+++ b/solution/3200-3299/3202.Find the Maximum Length of Valid Subsequence II/README_EN.md
@@ -2,6 +2,9 @@
comments: true
difficulty: Medium
edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3202.Find%20the%20Maximum%20Length%20of%20Valid%20Subsequence%20II/README_EN.md
+tags:
+ - Array
+ - Dynamic Programming
---
diff --git a/solution/3200-3299/3203.Find Minimum Diameter After Merging Two Trees/README.md b/solution/3200-3299/3203.Find Minimum Diameter After Merging Two Trees/README.md
index 02054aa84204a..7a69f88cf67a8 100644
--- a/solution/3200-3299/3203.Find Minimum Diameter After Merging Two Trees/README.md
+++ b/solution/3200-3299/3203.Find Minimum Diameter After Merging Two Trees/README.md
@@ -2,6 +2,11 @@
comments: true
difficulty: 困难
edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3203.Find%20Minimum%20Diameter%20After%20Merging%20Two%20Trees/README.md
+tags:
+ - 树
+ - 深度优先搜索
+ - 广度优先搜索
+ - 图
---
diff --git a/solution/3200-3299/3203.Find Minimum Diameter After Merging Two Trees/README_EN.md b/solution/3200-3299/3203.Find Minimum Diameter After Merging Two Trees/README_EN.md
index 32c2f016c0510..2cb3f266d16db 100644
--- a/solution/3200-3299/3203.Find Minimum Diameter After Merging Two Trees/README_EN.md
+++ b/solution/3200-3299/3203.Find Minimum Diameter After Merging Two Trees/README_EN.md
@@ -2,6 +2,11 @@
comments: true
difficulty: Hard
edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3203.Find%20Minimum%20Diameter%20After%20Merging%20Two%20Trees/README_EN.md
+tags:
+ - Tree
+ - Depth-First Search
+ - Breadth-First Search
+ - Graph
---
diff --git a/solution/3200-3299/3204.Bitwise User Permissions Analysis/README.md b/solution/3200-3299/3204.Bitwise User Permissions Analysis/README.md
new file mode 100644
index 0000000000000..a47d53384c22f
--- /dev/null
+++ b/solution/3200-3299/3204.Bitwise User Permissions Analysis/README.md
@@ -0,0 +1,123 @@
+---
+comments: true
+difficulty: 中等
+edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3204.Bitwise%20User%20Permissions%20Analysis/README.md
+tags:
+ - 数据库
+---
+
+
+
+# [3204. 按位用户权限分析 🔒](https://leetcode.cn/problems/bitwise-user-permissions-analysis)
+
+[English Version](/solution/3200-3299/3204.Bitwise%20User%20Permissions%20Analysis/README_EN.md)
+
+## 题目描述
+
+
+
+表：user_permissions
+
+
++-------------+---------+
+| Column Name | Type |
++-------------+---------+
+| user_id | int |
+| permissions | int |
++-------------+---------+
+user_id 是主键。
+这张表的每一行包含用户 ID 和他们的权限，编码为一个整数。
+
+
+permissions 整数中的每一个二进制位代表一个用户拥有的一个不同的访问级别或功能。
+
+编写一个解决方案来计算以下内容：
+
+
+ - common_perms：授予 所有用户 的访问级别。在
permissions 列上使用 按位与 操作来计算。
+ - any_perms：授予 任一用户 的访问级别。在
permissions 列上使用 按位或 操作来计算。
+
+
+以 任意 顺序返回结果表。
+
+结果格式如下所示。
+
+
+
+示例：
+
+
+
输入：
+
+
user_permissions 表：
+
+
++---------+-------------+
+| user_id | permissions |
++---------+-------------+
+| 1 | 5 |
+| 2 | 12 |
+| 3 | 7 |
+| 4 | 3 |
++---------+-------------+
+
+
+
输出：
+
+
++-------------+--------------+
+| common_perms | any_perms |
++--------------+-------------+
+| 0 | 15 |
++--------------+-------------+
+
+
+
解释：
+
+
+ - common_perms: 代表所有权限的按位与结果：
+
+
+ - 对于用户 1 (5): 5 (二进制 0101)
+ - 对于用户 2 (12): 12 (二进制 1100)
+ - 对于用户 3 (7): 7 (二进制 0111)
+ - 对于用户 4 (3): 3 (二进制 0011)
+ - 按位与：5 & 12 & 7 & 3 = 0 (二进制 0000)
+
+
+ - any_perms: 代表所有权限的按位或结果：
+
+ - 按位或：5 | 12 | 7 | 3 = 15 (二进制 1111)
+
+
+
+
+
Table: user_permissions
+
+
++-------------+---------+
+| Column Name | Type |
++-------------+---------+
+| user_id | int |
+| permissions | int |
++-------------+---------+
+user_id is the primary key.
+Each row of this table contains the user ID and their permissions encoded as an integer.
+
+
+Consider that each bit in the permissions integer represents a different access level or feature that a user has.
+
+Write a solution to calculate the following:
+
+
+ - common_perms: The access level granted to all users. This is computed using a bitwise AND operation on the
permissions column.
+ - any_perms: The access level granted to any user. This is computed using a bitwise OR operation on the
permissions column.
+
+
+Return the result table in any order.
+
+The result format is shown in the following example.
+
+
+Example:
+
+
+
Input:
+
+
user_permissions table:
+
+
++---------+-------------+
+| user_id | permissions |
++---------+-------------+
+| 1 | 5 |
+| 2 | 12 |
+| 3 | 7 |
+| 4 | 3 |
++---------+-------------+
+
+
+
Output:
+
+
++-------------+--------------+
+| common_perms | any_perms |
++--------------+-------------+
+| 0 | 15 |
++--------------+-------------+
+
+
+
Explanation:
+
+
+ - common_perms: Represents the bitwise AND result of all permissions:
+
+
+ - For user 1 (5): 5 (binary 0101)
+ - For user 2 (12): 12 (binary 1100)
+ - For user 3 (7): 7 (binary 0111)
+ - For user 4 (3): 3 (binary 0011)
+ - Bitwise AND: 5 & 12 & 7 & 3 = 0 (binary 0000)
+
+
+ - any_perms: Represents the bitwise OR result of all permissions:
+
+ - Bitwise OR: 5 | 12 | 7 | 3 = 15 (binary 1111)
+
+
+
+
+