补充第 900 ~ 999 题的题目解析（增加 69 道题）

Author: itcharge

docs/00_preface/00_05_solutions_list.md

@@ -1,5 +1,6 @@
 ## 2026-01
 
+- 2026-01-09 补充第 900 ~ 999 题的题目解析（增加 69 道题）
 - 2026-01-08 补充第 800 ~ 899 题的题目解析（增加 22 道题）
 - 2026-01-07 补充第 800 ~ 899 题的题目解析（增加 37 道题）
 - 2026-01-06 补充第 700 ~ 799 题的题目解析（增加 8 道题）

docs/others/update_time.md

@@ -15,7 +15,8 @@
 
 **要求**：
 
-实现 `Solution` 类：
+实现 Solution 类：
+
 - `Solution(ListNode head)` 使用整数数组初始化对象。
 - `int getRandom()` 从链表中随机选择一个节点并返回该节点的值。链表中所有节点被选中的概率相等。
 
@@ -33,12 +34,9 @@
 
 - 示例 1：
 
-```python
-示例：
-
 ![](https://assets.leetcode.com/uploads/2021/03/16/getrand-linked-list.jpg)
 
-
+```python
 输入
 ["Solution", "getRandom", "getRandom", "getRandom", "getRandom", "getRandom"]
 [[[1, 2, 3]], [], [], [], [], []]
@@ -55,13 +53,6 @@ solution.getRandom(); // 返回 3
 // getRandom() 方法应随机返回 1、2、3中的一个，每个元素被返回的概率相等。
 ```
 
-- 示例 2：
-
-```python
-输入：
-输出：
-```
-
 ## 解题思路
 
 ### 思路 1：水塘抽样算法

docs/solutions/0300-0399/linked-list-random-node.md

@@ -0,0 +1,116 @@
+# [0923. 三数之和的多种可能](https://leetcode.cn/problems/3sum-with-multiplicity/)
+
+- 标签：数组、哈希表、双指针、计数、排序
+- 难度：中等
+
+## 题目链接
+
+- [0923. 三数之和的多种可能 - 力扣](https://leetcode.cn/problems/3sum-with-multiplicity/)
+
+## 题目大意
+
+**描述**：
+
+给定一个整数数组 $arr$，以及一个整数 $target$ 作为目标值。
+
+**要求**：
+
+返回满足 $i < j < k$ 且 $arr[i] + arr[j] + arr[k] == target$ 的元组 $i, j, k$ 的数量。
+
+由于结果会非常大，请返回 $10^9 + 7$ 的模。
+
+**说明**：
+
+- $3 \le arr.length \le 3000$。
+- $0 \le arr[i] \le 10^{3}$。
+- $0 \le target \le 300$。
+
+**示例**：
+
+- 示例 1：
+
+```python
+输入：arr = [1,1,2,2,3,3,4,4,5,5], target = 8
+输出：20
+解释：
+按值枚举(arr[i], arr[j], arr[k])：
+(1, 2, 5) 出现 8 次；
+(1, 3, 4) 出现 8 次；
+(2, 2, 4) 出现 2 次；
+(2, 3, 3) 出现 2 次。
+```
+
+- 示例 2：
+
+```python
+输入：arr = [1,1,2,2,2,2], target = 5
+输出：12
+解释：
+arr[i] = 1, arr[j] = arr[k] = 2 出现 12 次：
+我们从 [1,1] 中选择一个 1，有 2 种情况，
+从 [2,2,2,2] 中选出两个 2，有 6 种情况。
+```
+
+## 解题思路
+
+### 思路 1：哈希表 + 双指针
+
+#### 思路
+
+这道题要求统计满足 $i < j < k$ 且 $arr[i] + arr[j] + arr[k] = target$ 的三元组数量。
+
+由于数组元素范围较小（$0 \le arr[i] \le 100$），我们可以使用哈希表统计每个数字的出现次数，然后枚举所有可能的三元组：
+
+1. **统计频次**：使用哈希表 $count$ 统计每个数字的出现次数。
+2. **枚举三元组**：枚举所有可能的 $(i, j, k)$ 组合，其中 $i \le j \le k$：
+   - 如果 $i + j + k = target$，计算该组合的方案数。
+   - 方案数的计算需要考虑三个数是否相同：
+     - 如果三个数都相同：$C(count[i], 3) = \frac{count[i] \times (count[i] - 1) \times (count[i] - 2)}{6}$
+     - 如果两个数相同：$C(count[i], 2) \times count[k] = \frac{count[i] \times (count[i] - 1)}{2} \times count[k]$
+     - 如果三个数都不同：$count[i] \times count[j] \times count[k]$
+3. 返回总方案数对 $10^9 + 7$ 取模的结果。
+
+#### 代码
+
+```python
+class Solution:
+    def threeSumMulti(self, arr: List[int], target: int) -> int:
+        MOD = 10**9 + 7
+        from collections import Counter
+        
+        # 统计每个数字的出现次数
+        count = Counter(arr)
+        res = 0
+        
+        # 枚举所有可能的三元组 (i, j, k)，其中 i <= j <= k
+        for i in range(101):
+            for j in range(i, 101):
+                k = target - i - j
+                if k < 0 or k > 100:
+                    continue
+                
+                if i == j == k:
+                    # 三个数都相同：C(count[i], 3)
+                    res += count[i] * (count[i] - 1) * (count[i] - 2) // 6
+                elif i == j:
+                    # 前两个数相同：C(count[i], 2) * count[k]
+                    if k > j:
+                        res += count[i] * (count[i] - 1) // 2 * count[k]
+                elif j == k:
+                    # 后两个数相同：count[i] * C(count[j], 2)
+                    if k > i:
+                        res += count[i] * count[j] * (count[j] - 1) // 2
+                else:
+                    # 三个数都不同
+                    if k > j:
+                        res += count[i] * count[j] * count[k]
+                
+                res %= MOD
+        
+        return res
+```
+
+#### 复杂度分析
+
+- **时间复杂度**：$O(n + C^2)$，其中 $n$ 是数组长度，$C = 101$ 是数字的范围。统计频次需要 $O(n)$，枚举三元组需要 $O(C^2)$。
+- **空间复杂度**：$O(C)$，需要哈希表存储每个数字的频次。

docs/solutions/0900-0999/3sum-with-multiplicity.md

@@ -0,0 +1,91 @@
+# [0989. 数组形式的整数加法](https://leetcode.cn/problems/add-to-array-form-of-integer/)
+
+- 标签：数组、数学
+- 难度：简单
+
+## 题目链接
+
+- [0989. 数组形式的整数加法 - 力扣](https://leetcode.cn/problems/add-to-array-form-of-integer/)
+
+## 题目大意
+
+**描述**：
+
+整数的「数组形式」$num$ 是按照从左到右的顺序表示其数字的数组。
+
+- 例如，对于 $num = 1321$ ，数组形式是 $[1,3,2,1]$。
+
+给定 $num$，整数的「数组形式」，和整数 $k$。
+
+**要求**：
+
+返回 整数 $num + k$ 的「数组形式」。
+
+**说明**：
+
+- $1 \le num.length \le 10^{4}$。
+- $0 \le num[i] \le 9$。
+- $num$ 不包含任何前导零，除了零本身。
+- $1 \le k \le 10^{4}$。
+
+**示例**：
+
+- 示例 1：
+
+```python
+输入：num = [1,2,0,0], k = 34
+输出：[1,2,3,4]
+解释：1200 + 34 = 1234
+```
+
+- 示例 2：
+
+```python
+输入：num = [2,7,4], k = 181
+输出：[4,5,5]
+解释：274 + 181 = 455
+```
+
+## 解题思路
+
+### 思路 1：模拟加法
+
+#### 思路
+
+这道题要求将数组形式的整数与整数 $k$ 相加，返回数组形式的结果。我们可以模拟加法的过程：
+
+1. 从数组 $num$ 的最后一位开始，与 $k$ 的个位相加。
+2. 计算当前位的和以及进位。
+3. 将当前位的结果插入到结果数组的开头。
+4. 更新 $k$ 为进位值（$k$ 除以 $10$）。
+5. 继续处理下一位，直到数组遍历完且 $k$ 为 $0$。
+
+#### 代码
+
+```python
+class Solution:
+    def addToArrayForm(self, num: List[int], k: int) -> List[int]:
+        res = []
+        n = len(num)
+        i = n - 1  # 从数组最后一位开始
+        
+        # 当数组还有位数或 k 不为 0 时继续
+        while i >= 0 or k > 0:
+            # 获取当前位的数字
+            digit = num[i] if i >= 0 else 0
+            # 计算当前位的和
+            total = digit + k % 10
+            # 将当前位结果插入到结果数组开头
+            res.append(total % 10)
+            # 计算进位
+            k = k // 10 + total // 10
+            i -= 1
+        
+        # 结果是逆序的，需要反转
+        return res[::-1]
+```
+
+#### 复杂度分析
+
+- **时间复杂度**：$O(\max(n, \log k))$，其中 $n$ 是数组 $num$ 的长度，$\log k$ 是整数 $k$ 的位数。需要遍历所有位数。
+- **空间复杂度**：$O(1)$，不考虑结果数组的空间，只使用了常数个额外变量。

docs/solutions/0900-0999/add-to-array-form-of-integer.md

@@ -0,0 +1,87 @@
+# [0954. 二倍数对数组](https://leetcode.cn/problems/array-of-doubled-pairs/)
+
+- 标签：贪心、数组、哈希表、排序
+- 难度：中等
+
+## 题目链接
+
+- [0954. 二倍数对数组 - 力扣](https://leetcode.cn/problems/array-of-doubled-pairs/)
+
+## 题目大意
+
+**描述**：
+
+给定一个长度为偶数的整数数组 $arr$。
+
+**要求**：
+
+只有对 $arr$ 进行重组后可以满足「对于每个 $0 \le i < len(arr) / 2$，都有 $arr[2 \times i + 1] = 2 \times arr[2 \times i]$」时，返回 true；否则，返回 false。
+
+**说明**：
+
+- $0 \le arr.length \le 3 \times 10^{4}$。
+- $arr.length$ 是偶数。
+- $-10^{5} \le arr[i] \le 10^{5}$。
+
+**示例**：
+
+- 示例 1：
+
+```python
+输入：arr = [3,1,3,6]
+输出：false
+```
+
+- 示例 2：
+
+```python
+输入：arr = [2,1,2,6]
+输出：false
+```
+
+## 解题思路
+
+### 思路 1：贪心 + 哈希表
+
+#### 思路
+
+这道题要求判断数组能否重组为二倍数对的形式，即 $arr[2 \times i + 1] = 2 \times arr[2 \times i]$。
+
+我们可以使用贪心策略：
+
+1. **统计频次**：使用哈希表统计每个数字出现的次数。
+2. **排序**：按绝对值从小到大排序。这样可以保证先处理较小的数，避免遗漏。
+3. **贪心匹配**：对于每个数 $x$，如果它还有剩余次数，就尝试找它的二倍 $2x$：
+   - 如果 $2x$ 的次数不足，返回 `False`。
+   - 否则，将 $x$ 和 $2x$ 的次数都减 $1$。
+4. 如果所有数都能成功匹配，返回 `True`。
+
+**注意**：需要按绝对值排序，因为负数的二倍关系是 $-4$ 和 $-2$，而不是 $-2$ 和 $-4$。
+
+#### 代码
+
+```python
+class Solution:
+    def canReorderDoubled(self, arr: List[int]) -> bool:
+        from collections import Counter
+        
+        # 统计每个数字的出现次数
+        count = Counter(arr)
+        
+        # 按绝对值从小到大排序
+        for x in sorted(count, key=abs):
+            # 如果 x 还有剩余次数
+            if count[x] > 0:
+                # 检查 2x 的次数是否足够
+                if count[2 * x] < count[x]:
+                    return False
+                # 匹配 x 和 2x
+                count[2 * x] -= count[x]
+        
+        return True
+```
+
+#### 复杂度分析
+
+- **时间复杂度**：$O(n \log n)$，其中 $n$ 是数组长度。主要时间消耗在排序上。
+- **空间复杂度**：$O(n)$，需要哈希表存储每个数字的频次。