补充第 600 ~ 699 题的题目解析（增加 34 道题）

Author: itcharge

docs/00_preface/00_05_solutions_list.md

@@ -1,6 +1,7 @@
 ## 2026-01
 
 - 2026-01-01 补充第 500 ~ 599 题的题目解析（增加 34 道题）
+- 2026-01-02 补充第 600 ~ 699 题的题目解析（增加 34 道题）
 
 ## 2025-10
 

docs/others/update_time.md

@@ -0,0 +1,118 @@
+# [0679. 24 点游戏](https://leetcode.cn/problems/24-game/)
+
+- 标签：数组、数学、回溯
+- 难度：困难
+
+## 题目链接
+
+- [0679. 24 点游戏 - 力扣](https://leetcode.cn/problems/24-game/)
+
+## 题目大意
+
+**描述**：
+
+给定一个长度为4的整数数组 $cards$。你有 $4$ 张卡片，每张卡片上都包含一个范围在 $[1,9]$ 的数字。您应该使用运算符 `['+', '-', '*', '/']` 和括号 `'('` 和 `')'` 将这些卡片上的数字排列成数学表达式，以获得值 $24$。
+
+你须遵守以下规则:
+
+- 除法运算符 `/` 表示实数除法，而不是整数除法。
+- 例如， `"4 / (1 - 2 / 3)= 4 / (1 / 3) = 12"`。
+- 每个运算都在两个数字之间。特别是，不能使用 `-` 作为一元运算符。
+- 例如，如果 $cards =[1,1,1,1]$，则表达式 `"-1 -1 -1 -1"` 是 不允许 的。
+- 你不能把数字串在一起
+- 例如，如果 $cards =[1,2,1,2]$，则表达式 `"12 + 12"` 无效。
+
+**要求**：
+
+如果可以得到这样的表达式，其计算结果为 24，则返回 true ，否则返回 false。
+
+**说明**：
+
+- $cards.length == 4$。
+- $1 \le cards[i] \le 9$。
+
+**示例**：
+
+- 示例 1：
+
+```python
+输入: cards = [4, 1, 8, 7]
+输出: true
+解释: (8-4) * (7-1) = 24
+```
+
+- 示例 2：
+
+```python
+输入: cards = [1, 2, 1, 2]
+输出: false
+```
+
+## 解题思路
+
+### 思路 1：回溯算法
+
+#### 思路 1：算法描述
+
+这道题目要求判断是否可以通过四则运算和括号将四个数字组合成 $24$。
+
+我们可以使用回溯算法来枚举所有可能的运算顺序和运算符组合。每次从数组中选择两个数字进行运算，将运算结果放回数组，然后递归处理剩余的数字，直到数组中只剩下一个数字，判断是否等于 $24$。
+
+具体步骤如下：
+
+1. 如果数组中只剩下一个数字，判断是否等于 $24$（考虑浮点数误差，判断是否在 $24$ 的附近）。
+2. 枚举数组中的任意两个数字 $a$ 和 $b$，以及四种运算符 $+$、$-$、$\times$、$\div$。
+3. 计算 $a$ 和 $b$ 的运算结果，将结果放回数组，递归处理剩余的数字。
+4. 如果找到一种方案使得最终结果为 $24$，返回 $True$。
+5. 回溯，尝试其他的数字组合和运算符。
+
+注意：除法运算需要判断除数是否为 $0$。
+
+#### 思路 1：代码
+
+```python
+class Solution:
+    def judgePoint24(self, cards: List[int]) -> bool:
+        TARGET = 24
+        EPSILON = 1e-6  # 浮点数误差范围
+        
+        def backtrack(nums):
+            # 如果只剩下一个数字，判断是否等于 24
+            if len(nums) == 1:
+                return abs(nums[0] - TARGET) < EPSILON
+            
+            # 枚举任意两个数字进行运算
+            n = len(nums)
+            for i in range(n):
+                for j in range(n):
+                    if i == j:
+                        continue
+                    
+                    a, b = nums[i], nums[j]
+                    # 剩余的数字
+                    remaining = [nums[k] for k in range(n) if k != i and k != j]
+                    
+                    # 枚举四种运算符
+                    # 加法
+                    if backtrack(remaining + [a + b]):
+                        return True
+                    # 减法
+                    if backtrack(remaining + [a - b]):
+                        return True
+                    # 乘法
+                    if backtrack(remaining + [a * b]):
+                        return True
+                    # 除法（需要判断除数是否为 0）
+                    if abs(b) > EPSILON and backtrack(remaining + [a / b]):
+                        return True
+            
+            return False
+        
+        # 将整数转换为浮点数
+        return backtrack([float(card) for card in cards])
+```
+
+#### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(1)$。虽然看起来是指数级别的复杂度，但由于数组长度固定为 $4$，所以时间复杂度是常数级别的。
+- **空间复杂度**：$O(1)$。递归调用栈的深度最多为 $4$，空间复杂度是常数级别的。

docs/solutions/0600-0699/24-game.md

@@ -0,0 +1,127 @@
+# [0623. 在二叉树中增加一行](https://leetcode.cn/problems/add-one-row-to-tree/)
+
+- 标签：树、深度优先搜索、广度优先搜索、二叉树
+- 难度：中等
+
+## 题目链接
+
+- [0623. 在二叉树中增加一行 - 力扣](https://leetcode.cn/problems/add-one-row-to-tree/)
+
+## 题目大意
+
+**描述**：
+
+给定一个二叉树的根 $root$ 和两个整数 $val$ 和 $depth$。
+
+**要求**：
+
+在给定的深度 $depth$ 处添加一个值为 $val$ 的节点行。
+
+注意，根节点 $root$ 位于深度 1。
+
+**说明**：
+
+- 加法规则如下:
+   - 给定整数 $depth$，对于深度为 $depth - 1$ 的每个非空树节点 $cur$ ，创建两个值为 $val$ 的树节点作为 $cur$ 的左子树根和右子树根。
+   - $cur$ 原来的左子树应该是新的左子树根的左子树。
+   - $cur$ 原来的右子树应该是新的右子树根的右子树。
+   - 如果 $depth == 1$ 意味着 $depth - 1$ 根本没有深度，那么创建一个树节点，值 $val$ 作为整个原始树的新根，而原始树就是新根的左子树。
+- 节点数在 $[1, 10^{4}]$ 范围内。
+- 树的深度在 $[1, 10^{4}]$ 范围内。
+- $-10^{3} \le Node.val \le 10^{3}$。
+- $-10^{5} \le val \le 10^{5}$。
+- $1 \le depth \le the depth of tree + 1$。
+
+**示例**：
+
+- 示例 1：
+
+![](https://assets.leetcode.com/uploads/2021/03/15/addrow-tree.jpg)
+
+```python
+输入: root = [4,2,6,3,1,5], val = 1, depth = 2
+输出: [4,1,1,2,null,null,6,3,1,5]
+```
+
+- 示例 2：
+
+![](https://assets.leetcode.com/uploads/2021/03/11/add2-tree.jpg)
+
+```python
+输入: root = [4,2,null,3,1], val = 1, depth = 3
+输出:  [4,2,null,1,1,3,null,null,1]
+```
+
+## 解题思路
+
+### 思路 1：广度优先搜索
+
+#### 思路 1：算法描述
+
+这道题目要求在二叉树的指定深度 $depth$ 处添加一行值为 $val$ 的节点。
+
+我们可以使用广度优先搜索（BFS）来找到深度为 $depth - 1$ 的所有节点，然后为这些节点添加新的左右子节点。
+
+特殊情况：如果 $depth = 1$，则需要创建一个新的根节点，原来的树作为新根节点的左子树。
+
+具体步骤如下：
+
+1. 如果 $depth = 1$，创建一个新的根节点，值为 $val$，原来的根节点作为新根节点的左子节点，返回新根节点。
+2. 使用 BFS 遍历二叉树，找到深度为 $depth - 1$ 的所有节点。
+3. 对于深度为 $depth - 1$ 的每个节点 $node$：
+   - 创建两个新节点 $left\_node$ 和 $right\_node$，值都为 $val$。
+   - 将 $node$ 的原左子节点作为 $left\_node$ 的左子节点。
+   - 将 $node$ 的原右子节点作为 $right\_node$ 的右子节点。
+   - 将 $left\_node$ 和 $right\_node$ 分别设置为 $node$ 的左右子节点。
+4. 返回根节点。
+
+#### 思路 1：代码
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def addOneRow(self, root: Optional[TreeNode], val: int, depth: int) -> Optional[TreeNode]:
+        # 特殊情况：在根节点前添加一行
+        if depth == 1:
+            new_root = TreeNode(val)
+            new_root.left = root
+            return new_root
+        
+        # 使用 BFS 找到深度为 depth - 1 的所有节点
+        queue = [root]
+        current_depth = 1
+        
+        while queue and current_depth < depth - 1:
+            size = len(queue)
+            for _ in range(size):
+                node = queue.pop(0)
+                if node.left:
+                    queue.append(node.left)
+                if node.right:
+                    queue.append(node.right)
+            current_depth += 1
+        
+        # 为深度为 depth - 1 的所有节点添加新的左右子节点
+        for node in queue:
+            # 创建新的左子节点
+            left_node = TreeNode(val)
+            left_node.left = node.left
+            node.left = left_node
+            
+            # 创建新的右子节点
+            right_node = TreeNode(val)
+            right_node.right = node.right
+            node.right = right_node
+        
+        return root
+```
+
+#### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(n)$，其中 $n$ 是二叉树的节点数。最坏情况下需要遍历所有节点。
+- **空间复杂度**：$O(n)$。队列中最多存储 $n$ 个节点。

docs/solutions/0600-0699/add-one-row-to-tree.md

@@ -0,0 +1,109 @@
+# [0637. 二叉树的层平均值](https://leetcode.cn/problems/average-of-levels-in-binary-tree/)
+
+- 标签：树、深度优先搜索、广度优先搜索、二叉树
+- 难度：简单
+
+## 题目链接
+
+- [0637. 二叉树的层平均值 - 力扣](https://leetcode.cn/problems/average-of-levels-in-binary-tree/)
+
+## 题目大意
+
+**描述**：
+
+给定一个非空二叉树的根节点 $root$。
+
+**要求**：
+
+ 以数组的形式返回每一层节点的平均值。与实际答案相差 $10^{-5}$ 以内的答案可以被接受。
+
+**说明**：
+
+- 树中节点数量在 $[1, 10^{4}]$ 范围内。
+- $-2^{31} \le Node.val \le 2^{31} - 1$。
+
+**示例**：
+
+- 示例 1：
+
+![](https://assets.leetcode.com/uploads/2021/03/09/avg1-tree.jpg)
+
+```python
+输入：root = [3,9,20,null,null,15,7]
+输出：[3.00000,14.50000,11.00000]
+解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
+因此返回 [3, 14.5, 11] 。
+```
+
+- 示例 2：
+
+![](https://assets.leetcode.com/uploads/2021/03/09/avg2-tree.jpg)
+
+```python
+输入：root = [3,9,20,15,7]
+输出：[3.00000,14.50000,11.00000]
+```
+
+## 解题思路
+
+### 思路 1：广度优先搜索
+
+#### 思路 1：算法描述
+
+这道题目要求返回二叉树每一层节点的平均值。我们可以使用广度优先搜索（BFS）来层序遍历二叉树。
+
+具体步骤如下：
+
+1. 初始化结果数组 $ans$ 和队列 $queue$，将根节点加入队列。
+2. 当队列不为空时，执行以下操作：
+   - 记录当前层的节点数量 $size$。
+   - 初始化当前层的节点值之和 $level\_sum = 0$。
+   - 遍历当前层的所有节点：
+     - 从队列中取出节点，将其值加到 $level\_sum$ 中。
+     - 如果节点有左子节点，将左子节点加入队列。
+     - 如果节点有右子节点，将右子节点加入队列。
+   - 计算当前层的平均值 $level\_sum / size$，加入结果数组 $ans$。
+3. 返回结果数组 $ans$。
+
+#### 思路 1：代码
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
+        if not root:
+            return []
+        
+        ans = []
+        queue = [root]
+        
+        while queue:
+            size = len(queue)  # 当前层的节点数量
+            level_sum = 0      # 当前层的节点值之和
+            
+            # 遍历当前层的所有节点
+            for _ in range(size):
+                node = queue.pop(0)
+                level_sum += node.val
+                
+                # 将下一层的节点加入队列
+                if node.left:
+                    queue.append(node.left)
+                if node.right:
+                    queue.append(node.right)
+            
+            # 计算当前层的平均值
+            ans.append(level_sum / size)
+        
+        return ans
+```
+
+#### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(n)$，其中 $n$ 是二叉树的节点数。需要遍历所有节点。
+- **空间复杂度**：$O(n)$。队列中最多存储 $n$ 个节点。