feat: add new lc problems

Author: yanglbme

lcof/面试题55 - I. 二叉树的深度/README.md

@@ -69,7 +69,7 @@ class Solution:
                 return 0
             l, r = dfs(root.left), dfs(root.right)
             return 1 + max(l, r)
-        
+
         return dfs(root)
 ```
 

solution/0000-0099/0006.Zigzag Conversion/README.md

@@ -1,4 +1,4 @@
-# [6. Z 字形变换](https://leetcode.cn/problems/zigzag-conversion)
+# [6. N 字形变换](https://leetcode.cn/problems/zigzag-conversion)
 
 [English Version](/solution/0000-0099/0006.Zigzag%20Conversion/README_EN.md)
 

solution/0100-0199/0117.Populating Next Right Pointers in Each Node II/README.md

@@ -6,7 +6,7 @@
 
 <!-- 这里写题目描述 -->
 
-<p>给定一个二叉树</p>
+<p>给定一个二叉树：</p>
 
 <pre>
 struct Node {
@@ -16,40 +16,41 @@ struct Node {
   Node *next;
 }</pre>
 
-<p>填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 <code>NULL</code>。</p>
+<p>填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 <code>NULL</code> 。</p>
 
-<p>初始状态下，所有 next 指针都被设置为 <code>NULL</code>。</p>
+<p>初始状态下，所有&nbsp;next 指针都被设置为 <code>NULL</code> 。</p>
 
-<p> </p>
-
-<p><strong>进阶：</strong></p>
-
-<ul>
-	<li>你只能使用常量级额外空间。</li>
-	<li>使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。</li>
-</ul>
-
-<p> </p>
-
-<p><strong>示例：</strong></p>
-
-<p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0117.Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II/images/117_sample.png" style="height: 218px; width: 640px;" /></p>
+<p>&nbsp;</p>
 
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0117.Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II/images/117_sample.png" style="width: 500px; height: 171px;" />
 <pre>
 <strong>输入</strong>：root = [1,2,3,4,5,null,7]
 <strong>输出：</strong>[1,#,2,3,#,4,5,7,#]
 <strong>解释：</strong>给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。</pre>
 
-<p> </p>
+<p><strong class="example">示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>root = []
+<strong>输出：</strong>[]
+</pre>
+
+<p>&nbsp;</p>
 
 <p><strong>提示：</strong></p>
 
 <ul>
-	<li>树中的节点数小于 <code>6000</code></li>
-	<li><code>-100 <= node.val <= 100</code></li>
+	<li>树中的节点数在范围 <code>[0, 6000]</code> 内</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
 </ul>
 
-<p> </p>
+<p><strong>进阶：</strong></p>
+
+<ul>
+	<li>你只能使用常量级额外空间。</li>
+	<li>使用递归解题也符合要求，本题中递归程序的隐式栈空间不计入额外空间复杂度。</li>
+</ul>
 
 <ul>
 </ul>

solution/0100-0199/0189.Rotate Array/README.md

@@ -6,7 +6,7 @@
 
 <!-- 这里写题目描述 -->
 
-<p>给你一个数组，将数组中的元素向右轮转 <code>k</code><em>&nbsp;</em>个位置，其中&nbsp;<code>k</code><em>&nbsp;</em>是非负数。</p>
+<p>给定一个整数数组 <code>nums</code>，将数组中的元素向右轮转 <code>k</code><em>&nbsp;</em>个位置，其中&nbsp;<code>k</code><em>&nbsp;</em>是非负数。</p>
 
 <p>&nbsp;</p>
 
@@ -49,12 +49,6 @@
 	<li>你可以使用空间复杂度为&nbsp;<code>O(1)</code> 的&nbsp;<strong>原地&nbsp;</strong>算法解决这个问题吗？</li>
 </ul>
 
-<ul>
-</ul>
-
-<ul>
-</ul>
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->

solution/0300-0399/0381.Insert Delete GetRandom O(1) - Duplicates allowed/README.md

@@ -34,13 +34,18 @@
 
 <strong>解释</strong>
 RandomizedCollection collection = new RandomizedCollection();// 初始化一个空的集合。
-collection.insert(1);// 向集合中插入 1 。返回 true 表示集合不包含 1 。
-collection.insert(1);// 向集合中插入另一个 1 。返回 false 表示集合包含 1 。集合现在包含 [1,1] 。
-collection.insert(2);// 向集合中插入 2 ，返回 true 。集合现在包含 [1,1,2] 。
-collection.getRandom();// getRandom 应当有 2/3 的概率返回 1 ，1/3 的概率返回 2 。
-collection.remove(1);// 从集合中删除 1 ，返回 true 。集合现在包含 [1,2] 。
-collection.getRandom();// getRandom 应有相同概率返回 1 和 2 。
-</pre>
+collection.insert(1);   // 返回 true，因为集合不包含 1。
+                        // 将 1 插入到集合中。
+collection.insert(1);   // 返回 false，因为集合包含 1。
+&nbsp;                       // 将另一个 1 插入到集合中。集合现在包含 [1,1]。
+collection.insert(2);   // 返回 true，因为集合不包含 2。
+&nbsp;                       // 将 2 插入到集合中。集合现在包含 [1,1,2]。
+collection.getRandom(); // getRandom 应当:
+&nbsp;                       // 有 2/3 的概率返回 1,
+&nbsp;                       // 1/3 的概率返回 2。
+collection.remove(1);   // 返回 true，因为集合包含 1。
+&nbsp;                       // 从集合中移除 1。集合现在包含 [1,2]。
+collection.getRandom(); // getRandom 应该返回 1 或 2，两者的可能性相同。</pre>
 
 <p>&nbsp;</p>
 

solution/0800-0899/0858.Mirror Reflection/README.md

@@ -6,29 +6,34 @@
 
 <!-- 这里写题目描述 -->
 
-<p>有一个特殊的正方形房间，每面墙上都有一面镜子。除西南角以外，每个角落都放有一个接受器，编号为 <code>0</code>， <code>1</code>，以及 <code>2</code>。</p>
+<p>有一个特殊的正方形房间，每面墙上都有一面镜子。除西南角以外，每个角落都放有一个接受器，编号为&nbsp;<code>0</code>，&nbsp;<code>1</code>，以及&nbsp;<code>2</code>。</p>
 
-<p>正方形房间的墙壁长度为 <code>p</code>，一束激光从西南角射出，首先会与东墙相遇，入射点到接收器 <code>0</code> 的距离为 <code>q</code> 。</p>
+<p>正方形房间的墙壁长度为&nbsp;<code>p</code>，一束激光从西南角射出，首先会与东墙相遇，入射点到接收器 <code>0</code> 的距离为 <code>q</code> 。</p>
 
 <p>返回光线最先遇到的接收器的编号（保证光线最终会遇到一个接收器）。</p>
+&nbsp;
 
-<p> </p>
+<p><strong class="example">示例 1：</strong></p>
+<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0800-0899/0858.Mirror%20Reflection/images/reflection.png" style="width: 218px; height: 217px;" />
+<pre>
+<strong>输入：</strong>p = 2, q = 1
+<strong>输出：</strong>2
+<strong>解释：</strong>这条光线在第一次被反射回左边的墙时就遇到了接收器 2 。
+</pre>
 
-<p><strong>示例：</strong></p>
+<p><strong class="example">示例 2：</strong></p>
 
 <pre>
-<strong>输入： </strong>p = 2, q = 1
-<strong>输出： </strong>2
-<strong>解释： </strong>这条光线在第一次被反射回左边的墙时就遇到了接收器 2 。
-<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0800-0899/0858.Mirror%20Reflection/images/reflection.png" style="height: 217px; width: 218px;" /></pre>
+<strong>输入：</strong>p = 3, q = 1
+<strong>输入：</strong>1
+</pre>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>提示：</strong></p>
 
 <ul>
-	<li><code>1 <= p <= 1000</code></li>
-	<li><code>0 <= q <= p</code></li>
+	<li><code>1 &lt;= q &lt;= p &lt;= 1000</code></li>
 </ul>
 
 ## 解法

solution/1000-1099/1093.Statistics from a Large Sample/README.md

@@ -32,7 +32,7 @@
 <pre>
 <strong>输入：</strong>count = [0,1,3,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
 <strong>输出：</strong>[1.00000,3.00000,2.37500,2.50000,3.00000]
-<strong>解释：</strong>用count表示的样本为[1,2,2,2,3,3,3,3,3]。
+<strong>解释：</strong>用count表示的样本为[1,2,2,2,3,3,3,3]。
 最小值和最大值分别为1和3。
 均值是(1+2+2+2+3+3+3+3) / 8 = 19 / 8 = 2.375。
 因为样本的大小是偶数，所以中位数是中间两个元素2和3的平均值，也就是2.5。

solution/1100-1199/1145.Binary Tree Coloring Game/README.md

@@ -17,7 +17,7 @@
 
 <p>「一号」玩家给值为&nbsp;<code>x</code>&nbsp;的节点染上红色，而「二号」玩家给值为&nbsp;<code>y</code>&nbsp;的节点染上蓝色。</p>
 
-<p>之后两位玩家轮流进行操作，「一号」玩家先手。每一回合，玩家选择一个之前涂好颜色的节点，将所选节点一个 <strong>未着色 </strong>的邻节点（即左右子节点、或父节点）进行染色（「一号」玩家染红色，「二号」玩家染蓝色）。</p>
+<p>之后两位玩家轮流进行操作，「一号」玩家先手。每一回合，玩家选择一个被他染过色的节点，将所选节点一个 <strong>未着色 </strong>的邻节点（即左右子节点、或父节点）进行染色（「一号」玩家染红色，「二号」玩家染蓝色）。</p>
 
 <p>如果（且仅在此种情况下）当前玩家无法找到这样的节点来染色时，其回合就会被跳过。</p>
 

solution/1200-1299/1209.Remove All Adjacent Duplicates in String II/README.md

@@ -51,22 +51,143 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：栈**
+
+我们可以遍历字符串 $s$，维护一个栈，栈中存储的是字符和该字符出现的次数。当遍历到字符 $c$ 时，如果栈顶元素的字符和 $c$ 相同，则将栈顶元素的次数加一，否则将字符 $c$ 和次数 $1$ 入栈。当栈顶元素的次数等于 $k$ 时，将栈顶元素出栈。
+
+遍历完字符串 $s$ 后，栈中存储的就是最终结果。我们可以将栈中的元素依次弹出，拼接成字符串即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为字符串 $s$ 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Solution:
+    def removeDuplicates(self, s: str, k: int) -> str:
+        t = []
+        i, n = 0, len(s)
+        while i < n:
+            j = i
+            while j < n and s[j] == s[i]:
+                j += 1
+            cnt = j - i
+            cnt %= k
+            if t and t[-1][0] == s[i]:
+                t[-1][1] = (t[-1][1] + cnt) % k
+                if t[-1][1] == 0:
+                    t.pop()
+            elif cnt:
+                t.append([s[i], cnt])
+            i = j
+        ans = [c * v for c, v in t]
+        return "".join(ans)
+```
 
+```python
+class Solution:
+    def removeDuplicates(self, s: str, k: int) -> str:
+        stk = []
+        for c in s:
+            if stk and stk[-1][0] == c:
+                stk[-1][1] = (stk[-1][1] + 1) % k
+                if stk[-1][1] == 0:
+                    stk.pop()
+            else:
+                stk.append([c, 1])
+        ans = [c * v for c, v in stk]
+        return "".join(ans)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public String removeDuplicates(String s, int k) {
+        Deque<int[]> stk = new ArrayDeque<>();
+        for (int i = 0; i < s.length(); ++i) {
+            int j = s.charAt(i) - 'a';
+            if (!stk.isEmpty() && stk.peek()[0] == j) {
+                stk.peek()[1] = (stk.peek()[1] + 1) % k;
+                if (stk.peek()[1] == 0) {
+                    stk.pop();
+                }
+            } else {
+                stk.push(new int[] {j, 1});
+            }
+        }
+        StringBuilder ans = new StringBuilder();
+        for (var e : stk) {
+            char c = (char) (e[0] + 'a');
+            for (int i = 0; i < e[1]; ++i) {
+                ans.append(c);
+            }
+        }
+        ans.reverse();
+        return ans.toString();
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    string removeDuplicates(string s, int k) {
+        vector<pair<char, int>> stk;
+        for (char& c : s) {
+            if (stk.size() && stk.back().first == c) {
+                stk.back().second = (stk.back().second + 1) % k;
+                if (stk.back().second == 0) {
+                    stk.pop_back();
+                }
+            } else {
+                stk.push_back({c, 1});
+            }
+        }
+        string ans;
+        for (auto [c, v] : stk) {
+            ans += string(v, c);
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func removeDuplicates(s string, k int) string {
+    stk := []pair{}
+    for _, c := range s {
+        if len(stk) > 0 && stk[len(stk)-1].c == c {
+            stk[len(stk)-1].v = (stk[len(stk)-1].v + 1) % k
+            if stk[len(stk)-1].v == 0 {
+                stk = stk[:len(stk)-1]
+            }
+        } else {
+            stk = append(stk, pair{c, 1})
+        }
+    }
+    ans := []rune{}
+    for _, e := range stk {
+        for i := 0; i < e.v; i++ {
+            ans = append(ans, e.c)
+        }
+    }
+    return string(ans)
+}
+
+type pair struct {
+    c rune
+    v int
+}
 ```
 
 ### **...**