feat: update lc problems (#3807)

Author: yanglbme

solution/0600-0699/0632.Smallest Range Covering Elements from K Lists/README.md

@@ -32,7 +32,7 @@ tags:
 <pre>
 <strong>输入：</strong>nums = [[4,10,15,24,26], [0,9,12,20], [5,18,22,30]]
 <strong>输出：</strong>[20,24]
-<strong>解释：</strong> 
+<strong>解释：</strong>
 列表 1：[4, 10, 15, 24, 26]，24 在区间 [20,24] 中。
 列表 2：[0, 9, 12, 20]，20 在区间 [20,24] 中。
 列表 3：[5, 18, 22, 30]，22 在区间 [20,24] 中。
@@ -67,13 +67,11 @@ tags:
 
 ### 方法一：排序 + 滑动窗口
 
-将每个数字 $v$ 及其所在的组 $i$，构成数据项 $(v, i)$，存放在一个新的列表或者数组中，记为 `t`。
+我们将每个数字 $x$ 及其所在的组 $i$，构成数据项 $(x, i)$，存放在一个新的数组 $t$ 中，然后对 $t$ 按照数字的大小进行排序（类似于将多个有序数组合并成一个新的有序数组）。
 
-对 `t` 按照数字的大小进行排序（类似于将多个有序数组合并成一个新的有序数组）。
+接下来，我们遍历 $t$ 中的每个数据项，只看其中数字所在的组，用哈希表记录滑动窗口内的数字出现的组，如果组数为 $k$，说明当前窗口满足题目要求，此时算出窗口的起始和结束位置，更新答案。
 
-然后遍历 `t` 中每个数据项，只看其中数字所在的组，用哈希表记录滑动窗口内的数字出现的组，如果组数为 $k$，说明当前窗口满足题目要求，此时算出窗口的起始和结束位置，更新答案。
-
-时间复杂度 $O(n\log n)$。其中 $n$ 是所有数字的总数。
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为所有数组中数字的个数。
 
 <!-- tabs:start -->
 
@@ -125,7 +123,7 @@ class Solution {
         for (int[] e : t) {
             int b = e[0];
             int v = e[1];
-            cnt.put(v, cnt.getOrDefault(v, 0) + 1);
+            cnt.merge(v, 1, Integer::sum);
             while (cnt.size() == k) {
                 int a = t[j][0];
                 int w = t[j][1];
@@ -134,8 +132,7 @@ class Solution {
                     ans[0] = a;
                     ans[1] = b;
                 }
-                cnt.put(w, cnt.get(w) - 1);
-                if (cnt.get(w) == 0) {
+                if (cnt.merge(w, -1, Integer::sum) == 0) {
                     cnt.remove(w);
                 }
                 ++j;

solution/0600-0699/0632.Smallest Range Covering Elements from K Lists/README_EN.md

@@ -61,7 +61,13 @@ List 3: [5, 18, 22, 30], 22 is in range [20,24].
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Sorting + Sliding Window
+
+We construct a data item $(x, i)$ for each number $x$ and its group $i$, and store these items in a new array $t$. Then, we sort $t$ by the value of the numbers (similar to merging multiple sorted arrays into a new sorted array).
+
+Next, we traverse each data item in $t$, focusing on the group to which each number belongs. We use a hash table to record the groups of numbers within the sliding window. If the number of groups is $k$, it means the current window meets the problem's requirements. At this point, we calculate the start and end positions of the window and update the answer.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Here, $n$ is the total number of numbers in all arrays.
 
 <!-- tabs:start -->
 
@@ -113,7 +119,7 @@ class Solution {
         for (int[] e : t) {
             int b = e[0];
             int v = e[1];
-            cnt.put(v, cnt.getOrDefault(v, 0) + 1);
+            cnt.merge(v, 1, Integer::sum);
             while (cnt.size() == k) {
                 int a = t[j][0];
                 int w = t[j][1];
@@ -122,8 +128,7 @@ class Solution {
                     ans[0] = a;
                     ans[1] = b;
                 }
-                cnt.put(w, cnt.get(w) - 1);
-                if (cnt.get(w) == 0) {
+                if (cnt.merge(w, -1, Integer::sum) == 0) {
                     cnt.remove(w);
                 }
                 ++j;

solution/0600-0699/0632.Smallest Range Covering Elements from K Lists/Solution.java

@@ -18,7 +18,7 @@ public int[] smallestRange(List<List<Integer>> nums) {
         for (int[] e : t) {
             int b = e[0];
             int v = e[1];
-            cnt.put(v, cnt.getOrDefault(v, 0) + 1);
+            cnt.merge(v, 1, Integer::sum);
             while (cnt.size() == k) {
                 int a = t[j][0];
                 int w = t[j][1];
@@ -27,13 +27,12 @@ public int[] smallestRange(List<List<Integer>> nums) {
                     ans[0] = a;
                     ans[1] = b;
                 }
-                cnt.put(w, cnt.get(w) - 1);
-                if (cnt.get(w) == 0) {
+                if (cnt.merge(w, -1, Integer::sum) == 0) {
                     cnt.remove(w);
                 }
                 ++j;
             }
         }
         return ans;
     }
-}
+}

solution/3300-3399/3360.Stone Removal Game/README.md

@@ -0,0 +1,165 @@
+---
+comments: true
+difficulty: 简单
+edit_url: https://github.com/doocs/leetcode/edit/main/solution/3300-3399/3360.Stone%20Removal%20Game/README.md
+---
+
+<!-- problem:start -->
+
+# [3360. 移除石头游戏](https://leetcode.cn/problems/stone-removal-game)
+
+[English Version](/solution/3300-3399/3360.Stone%20Removal%20Game/README_EN.md)
+
+## 题目描述
+
+<!-- description:start -->
+
+<p>Alice 和 Bob 在玩一个游戏，他们俩轮流从一堆石头中移除石头，Alice 先进行操作。</p>
+
+<ul>
+	<li>Alice 在第一次操作中移除 <strong>恰好</strong>&nbsp;10 个石头。</li>
+	<li>接下来的每次操作中，每位玩家移除的石头数 <strong>恰好</strong>&nbsp;为另一位玩家上一次操作的石头数减 1 。</li>
+</ul>
+
+<p>第一位没法进行操作的玩家输掉这个游戏。</p>
+
+<p>给你一个正整数&nbsp;<code>n</code>&nbsp;表示一开始石头的数目，如果 Alice 赢下这个游戏，请你返回&nbsp;<code>true</code>&nbsp;，否则返回 <code>false</code>&nbsp;。</p>
+
+<p>&nbsp;</p>
+
+<p><strong class="example">示例 1：</strong></p>
+
+<div class="example-block">
+<p><span class="example-io"><b>输入：</b>n = 12</span></p>
+
+<p><span class="example-io"><b>输出：</b>true</span></p>
+
+<p><strong>解释：</strong></p>
+
+<ul>
+	<li>Alice 第一次操作中移除 10 个石头，剩下 2 个石头给 Bob 。</li>
+	<li>Bob 无法移除 9 个石头，所以 Alice 赢下游戏。</li>
+</ul>
+</div>
+
+<p><strong class="example">示例 2：</strong></p>
+
+<div class="example-block">
+<p><span class="example-io"><b>输入：</b>n = 1</span></p>
+
+<p><span class="example-io"><b>输出：</b>false</span></p>
+
+<p><b>解释：</b></p>
+
+<ul>
+	<li>Alice 无法移除 10 个石头，所以 Alice 输掉游戏。</li>
+</ul>
+</div>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 50</code></li>
+</ul>
+
+<!-- description:end -->
+
+## 解法
+
+<!-- solution:start -->
+
+### 方法一：模拟
+
+我们根据题意模拟游戏的过程，直到无法继续游戏为止。
+
+具体地，我们维护两个变量 $x$ 和 $k$，分别表示当前可以移除的石头数和已经进行的操作次数。初始时 $x = 10$, $k = 0$。
+
+在每一轮操作中，如果当前可以移除的石头数 $x$ 不超过剩余的石头数 $n$，那么我们移除 $x$ 个石头，并将 $x$ 减小 $1$，然后将 $k$ 增加 $1$。否则，我们无法进行操作，游戏结束。
+
+最后，我们判断 $k$ 的奇偶性，如果 $k$ 是奇数，那么 Alice 赢得了游戏，否则 Bob 赢得了游戏。
+
+时间复杂度 $O(\sqrt{n})$。其中 $n$ 是石头的数目。空间复杂度 $O(1)$。
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def canAliceWin(self, n: int) -> bool:
+        x, k = 10, 0
+        while n >= x:
+            n -= x
+            x -= 1
+            k += 1
+        return k % 2 == 1
+```
+
+#### Java
+
+```java
+class Solution {
+    public boolean canAliceWin(int n) {
+        int x = 10, k = 0;
+        while (n >= x) {
+            n -= x;
+            --x;
+            ++k;
+        }
+        return k % 2 == 1;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    bool canAliceWin(int n) {
+        int x = 10, k = 0;
+        while (n >= x) {
+            n -= x;
+            --x;
+            ++k;
+        }
+        return k % 2;
+    }
+};
+```
+
+#### Go
+
+```go
+func canAliceWin(n int) bool {
+	x, k := 10, 0
+	for n >= x {
+		n -= x
+		x--
+		k++
+	}
+	return k%2 == 1
+}
+```
+
+#### TypeScript
+
+```ts
+function canAliceWin(n: number): boolean {
+    let [x, k] = [10, 0];
+    while (n >= x) {
+        n -= x;
+        --x;
+        ++k;
+    }
+    return k % 2 === 1;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
+<!-- problem:end -->