补全第 200 ~ 299 题的题目解析（增加 33 道题）

Author: itcharge

docs/00_preface/00_05_solutions_list.md

@@ -1,5 +1,6 @@
 ## 2025-10
 
+- 2025-10-20 补全第 200 ~ 299 题的题目解析（增加 33 道题）
 - 2025-10-19 补充第 200 ~ 299 题的题目解析（增加 8 道题）
 - 2025-10-17 补全第 100 ~ 199 题的题目解析（增加 12 道题）
 - 2025-10-16 补全第 1 ~ 99 题的题目解析（增加 13 道题）

docs/others/update_time.md

@@ -0,0 +1,130 @@
+# [0269. 火星词典](https://leetcode.cn/problems/alien-dictionary/)
+
+- 标签：深度优先搜索、广度优先搜索、图、拓扑排序、数组、字符串
+- 难度：困难
+
+## 题目链接
+
+- [0269. 火星词典 - 力扣](https://leetcode.cn/problems/alien-dictionary/)
+
+## 题目大意
+
+**描述**：
+
+现有一种使用英语字母的火星语言，这门语言的字母顺序对你来说是未知的。
+
+给定一个来自这种外星语言字典的字符串列表 $words$ ，$words$ 中的字符串已经「按这门新语言的字典序进行了排序」。
+
+**要求**：
+
+如果这种说法是错误的，并且给出的 $words$ 不能对应任何字母的顺序，则返回 `""`。
+
+否则，返回一个按新语言规则的「字典递增顺序」排序的独特字符串。如果有多个解决方案，则返回其中任意一个。
+
+**说明**：
+
+- $1 \le words.length \le 10^{3}$。
+- $1 \le words[i].length \le 10^{3}$。
+- $words[i]$ 仅由小写英文字母组成。
+
+**示例**：
+
+- 示例 1：
+
+```python
+输入：words = ["wrt","wrf","er","ett","rftt"]
+输出："wertf"
+```
+
+- 示例 2：
+
+```python
+输入：words = ["z","x"]
+输出："zx"
+```
+
+## 解题思路
+
+### 思路 1：拓扑排序 + 广度优先搜索
+
+使用拓扑排序来解决这个问题。我们需要构建一个图来表示字母之间的相对顺序关系，然后使用拓扑排序来找到字母的正确顺序。
+
+具体步骤如下：
+
+1. 构建图：遍历相邻的单词对 $(words[i], words[i+1])$，找到第一个不同的字符，建立字符 $c_1$ 到字符 $c_2$ 的边，表示 $c_1$ 在 $c_2$ 之前。
+2. 计算入度：统计每个字符的入度 $indegree[c]$。
+3. 拓扑排序：使用广度优先搜索，从入度为 $0$ 的字符开始，逐步构建字母顺序。
+4. 验证结果：检查是否所有字符都被包含在结果中。
+
+关键点：
+
+- 如果存在环，说明无法确定字母顺序，返回空字符串。
+- 如果拓扑排序后仍有字符未被访问，说明存在环。
+- 需要处理所有出现的字符，包括那些没有相对顺序关系的字符。
+
+### 思路 1：代码
+
+```python
+class Solution:
+    def alienOrder(self, words: List[str]) -> str:
+        # 构建图：字符到其后继字符的映射
+        graph = {}
+        # 统计每个字符的入度
+        indegree = {}
+        
+        # 初始化所有出现的字符
+        for word in words:
+            for char in word:
+                if char not in graph:
+                    graph[char] = set()
+                if char not in indegree:
+                    indegree[char] = 0
+        
+        # 构建图：比较相邻单词
+        for i in range(len(words) - 1):
+            word1, word2 = words[i], words[i + 1]
+            min_len = min(len(word1), len(word2))
+            
+            # 检查是否存在前缀关系
+            for j in range(min_len):
+                if word1[j] != word2[j]:
+                    # 找到第一个不同的字符，建立边关系
+                    char1, char2 = word1[j], word2[j]
+                    if char2 not in graph[char1]:
+                        graph[char1].add(char2)
+                        indegree[char2] += 1
+                    break
+            else:
+                # 如果所有字符都相同，但第一个单词更长，则无效
+                if len(word1) > len(word2):
+                    return ""
+        
+        # 拓扑排序：使用广度优先搜索
+        queue = []
+        # 找到所有入度为 0 的字符
+        for char in indegree:
+            if indegree[char] == 0:
+                queue.append(char)
+        
+        result = []
+        while queue:
+            char = queue.pop(0)
+            result.append(char)
+            
+            # 处理当前字符的所有后继字符
+            for next_char in graph[char]:
+                indegree[next_char] -= 1
+                if indegree[next_char] == 0:
+                    queue.append(next_char)
+        
+        # 检查是否所有字符都被访问（无环）
+        if len(result) != len(indegree):
+            return ""
+        
+        return ''.join(result)
+```
+
+### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(C)$，其中 $C$ 是所有单词中字符的总数。需要遍历所有字符来构建图和进行拓扑排序。
+- **空间复杂度**：$O(1)$，因为字符集大小固定为 $26$ 个字母，所以图的大小和入度数组都是常数级别。

docs/solutions/0200-0299/alien-dictionary.md

@@ -0,0 +1,119 @@
+# [0224. 基本计算器](https://leetcode.cn/problems/basic-calculator/)
+
+- 标签：栈、递归、数学、字符串
+- 难度：困难
+
+## 题目链接
+
+- [0224. 基本计算器 - 力扣](https://leetcode.cn/problems/basic-calculator/)
+
+## 题目大意
+
+**描述**：
+
+给定一个字符串表达式 $s$。
+
+**要求**：
+
+实现一个基本计算器来计算并返回它的值。
+
+**说明**：
+
+- 注意：不允许使用任何将字符串作为数学表达式计算的内置函数，比如 `eval()`。
+- $1 \le s.length \le 3 \times 10^{5}$。
+- $s$ 由数字、`'+'`、`'-'`、`'('、')'`、和 `' '` 组成。
+- $s$ 表示一个有效的表达式。
+- `'+'` 不能用作一元运算(例如， `"+1"` 和 `"+(2 + 3)"` 无效)。
+- `'-'` 可以用作一元运算(即 `"-1"` 和 `"-(2 + 3)"` 是有效的)。
+- 输入中不存在两个连续的操作符。
+- 每个数字和运行的计算将适合于一个有符号的 32 位整数。
+
+**示例**：
+
+- 示例 1：
+
+```python
+输入：s = "1 + 1"
+输出：2
+```
+
+- 示例 2：
+
+```python
+输入：s = " 2-1 + 2 "
+输出：3
+```
+
+## 解题思路
+
+### 思路 1：栈 + 递归
+
+使用栈来处理括号和运算符的优先级。由于只有加法和减法，我们可以通过维护一个符号栈来处理括号内的运算。
+
+具体步骤如下：
+
+1. 使用栈 $stack$ 来存储当前的计算结果和符号。
+2. 使用变量 $result$ 来存储当前的计算结果。
+3. 使用变量 $sign$ 来存储当前的符号（$+1$ 或 $-1$）。
+4. 遍历字符串 $s$：
+   - 如果遇到数字，则计算完整的数字值。
+   - 如果遇到 `+`，则设置 $sign = 1$。
+   - 如果遇到 `-`，则设置 $sign = -1$。
+   - 如果遇到 `(`，则将当前的 $result$ 和 $sign$ 压入栈中，并重置 $result$ 和 $sign$。
+   - 如果遇到 `)`，则从栈中弹出之前的结果和符号，与当前结果进行运算
+5. 最后返回 $result$。
+
+这种方法可以正确处理括号的嵌套和运算符的优先级。
+
+### 思路 1：代码
+
+```python
+class Solution:
+    def calculate(self, s: str) -> int:
+        # 使用栈来处理括号和运算符
+        stack = []
+        result = 0  # 当前计算结果
+        sign = 1    # 当前符号，1 表示正数，-1 表示负数
+        
+        i = 0
+        while i < len(s):
+            char = s[i]
+            
+            if char.isdigit():
+                # 计算完整的数字
+                num = 0
+                while i < len(s) and s[i].isdigit():
+                    num = num * 10 + int(s[i])
+                    i += 1
+                i -= 1  # 回退一位，因为外层循环会 i += 1
+                result += sign * num
+                
+            elif char == '+':
+                sign = 1
+                
+            elif char == '-':
+                sign = -1
+                
+            elif char == '(':
+                # 遇到左括号，将当前结果和符号压入栈
+                stack.append(result)
+                stack.append(sign)
+                # 重置结果和符号
+                result = 0
+                sign = 1
+                
+            elif char == ')':
+                # 遇到右括号，从栈中弹出之前的结果和符号
+                result *= stack.pop()  # 弹出符号
+                result += stack.pop()  # 弹出之前的结果
+                
+            # 跳过空格
+            i += 1
+            
+        return result
+```
+
+### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(n)$，其中 $n$ 是字符串 $s$ 的长度。需要遍历字符串一次。
+- **空间复杂度**：$O(n)$，最坏情况下栈的深度为 $O(n)$，例如当所有括号都嵌套时。

docs/solutions/0200-0299/basic-calculator.md

@@ -0,0 +1,103 @@
+# [0296. 最佳的碰头地点](https://leetcode.cn/problems/best-meeting-point/)
+
+- 标签：数组、数学、矩阵、排序
+- 难度：困难
+
+## 题目链接
+
+- [0296. 最佳的碰头地点 - 力扣](https://leetcode.cn/problems/best-meeting-point/)
+
+## 题目大意
+
+**描述**：
+
+给定一个 $m \times n$  的二进制网格 $grid$，其中 $1$ 表示某个朋友的家所处的位置。
+
+**要求**：
+
+返回「最小的」总行走距离。
+
+**说明**：
+
+- 总行走距离：指的是朋友们家到碰头地点的距离之和。使用「曼哈顿距离」来计算，其中 $distance(p1, p2) = |p2.x - p1.x| + |p2.y - p1.y|$。
+- $m == grid.length$。
+- $n == grid[i].length$。
+- $1 \le m, n \le 200$。
+- $grid[i][j]$ 等于 $0$ 或者 $1$。
+- $grid$ 中 至少 有两个朋友。
+
+**示例**：
+
+- 示例 1：
+
+![](https://assets.leetcode.com/uploads/2021/03/14/meetingpoint-grid.jpg)
+
+```python
+输入: grid = [[1,0,0,0,1],[0,0,0,0,0],[0,0,1,0,0]]
+输出: 6 
+解释: 给定的三个人分别住在(0,0)，(0,4) 和 (2,2):
+     (0,2) 是一个最佳的碰面点，其总行走距离为 2 + 2 + 2 = 6，最小，因此返回 6。
+```
+
+- 示例 2：
+
+```python
+输入: grid = [[1,1]]
+输出: 1
+```
+
+## 解题思路
+
+### 思路 1：中位数优化
+
+这是一个经典的数学优化问题。关键观察是：对于曼哈顿距离，$x$ 坐标和 $y$ 坐标可以独立优化。
+
+具体思路：
+1. 收集所有朋友的位置坐标，分别得到 $x$ 坐标数组 $X$ 和 $y$ 坐标数组 $Y$
+2. 对 $x$ 坐标和 $y$ 坐标分别排序
+3. 最优的碰头地点的 $x$ 坐标是 $X$ 的中位数，$y$ 坐标是 $Y$ 的中位数
+4. 计算所有朋友到最优碰头地点的曼哈顿距离之和
+
+**数学原理**：对于一维情况，中位数是最小化绝对偏差和的最优解。由于曼哈顿距离可以分解为 $x$ 坐标差和 $y$ 坐标差的和，所以可以分别优化。
+
+### 思路 1：代码
+
+```python
+class Solution:
+    def minTotalDistance(self, grid: List[List[int]]) -> int:
+        """
+        找到最佳的碰头地点，使所有朋友的总行走距离最小
+        """
+        m, n = len(grid), len(grid[0])
+        
+        # 收集所有朋友的位置坐标
+        x_coords = []
+        y_coords = []
+        
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == 1:
+                    x_coords.append(i)  # 行坐标
+                    y_coords.append(j)  # 列坐标
+        
+        # 对坐标进行排序
+        x_coords.sort()
+        y_coords.sort()
+        
+        # 计算中位数位置
+        k = len(x_coords)
+        median_x = x_coords[k // 2]  # x 坐标的中位数
+        median_y = y_coords[k // 2]  # y 坐标的中位数
+        
+        # 计算总距离
+        total_distance = 0
+        for i in range(k):
+            total_distance += abs(x_coords[i] - median_x) + abs(y_coords[i] - median_y)
+        
+        return total_distance
+```
+
+### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(m \times n + k \log k)$，其中 $m \times n$ 是遍历网格的时间，$k$ 是朋友的数量，$k \log k$ 是排序的时间。
+- **空间复杂度**：$O(k)$，用于存储所有朋友的坐标。