@@ -1,7 +1,8 @@
 ## 2026-01
 
-- 2026-01-01 补充第 500 ~ 599 题的题目解析（增加 34 道题）
+- 2026-01-03 补充第 700 ~ 799 题的题目解析（增加 27 道题）
 - 2026-01-02 补充第 600 ~ 699 题的题目解析（增加 34 道题）
+- 2026-01-01 补充第 500 ~ 599 题的题目解析（增加 34 道题）
 
 ## 2025-10
 
 
@@ -0,0 +1,92 @@
+# [0717. 1 比特与 2 比特字符](https://leetcode.cn/problems/1-bit-and-2-bit-characters/)
+
+- 标签：数组
+- 难度：简单
+
+## 题目链接
+
+- [0717. 1 比特与 2 比特字符 - 力扣](https://leetcode.cn/problems/1-bit-and-2-bit-characters/)
+
+## 题目大意
+
+**描述**：
+
+有两种特殊字符：
+
+- 第一种字符可以用一比特 $0$ 表示
+- 第二种字符可以用两比特（$10$ 或 $11$）表示
+
+给定一个以 $0$ 结尾的二进制数组 $bits$。
+
+**要求**：
+
+如果最后一个字符必须是一个一比特字符，则返回 true。
+
+**说明**：
+
+- $1 \le bits.length \le 10^{3}$。
+- $bits[i]$ 为 $0$ 或 $1$。
+
+**示例**：
+
+- 示例 1：
+
+```python
+输入: bits = [1, 0, 0]
+输出: true
+解释: 唯一的解码方式是将其解析为一个两比特字符和一个一比特字符。
+所以最后一个字符是一比特字符。
+```
+
+- 示例 2：
+
+```python
+输入：bits = [1,1,1,0]
+输出：false
+解释：唯一的解码方式是将其解析为两比特字符和两比特字符。
+所以最后一个字符不是一比特字符。
+```
+
+## 解题思路
+
+### 思路 1：贪心算法
+
+这道题的关键在于理解字符的编码规则：
+
+- 一比特字符：`0`
+- 两比特字符：`10` 或 `11`
+
+由于数组以 `0` 结尾，我们需要判断这个 `0` 是作为一比特字符单独存在，还是作为两比特字符的一部分。
+
+**解题步骤**：
+
+1. 从数组开头开始遍历，使用指针 $i$ 记录当前位置。
+2. 如果 $bits[i] = 1$，说明当前是两比特字符，跳过两位（$i$ 增加 $2$）。
+3. 如果 $bits[i] = 0$，说明当前是一比特字符，跳过一位（$i$ 增加 $1$）。
+4. 当 $i$ 到达倒数第二个位置时停止遍历。
+5. 如果 $i$ 正好等于 $n - 1$（最后一个位置），说明最后一个 `0` 是一比特字符，返回 `True`。
+6. 如果 $i$ 超过了 $n - 1$，说明最后一个 `0` 是两比特字符的一部分，返回 `False`。
+
+### 思路 1：代码
+
+```python
+class Solution:
+    def isOneBitCharacter(self, bits: List[int]) -> bool:
+        n = len(bits)
+        i = 0
+        
+        # 遍历到倒数第二个位置
+        while i < n - 1:
+            if bits[i] == 1:  # 两比特字符
+                i += 2
+            else:  # 一比特字符
+                i += 1
+        
+        # 如果 i 正好等于 n - 1，说明最后一个 0 是一比特字符
+        return i == n - 1
+```
+
+### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(n)$，其中 $n$ 是数组 $bits$ 的长度。需要遍历整个数组一次。
+- **空间复杂度**：$O(1)$。只使用了常数个额外变量。
@@ -0,0 +1,126 @@
+# [0721. 账户合并](https://leetcode.cn/problems/accounts-merge/)
+
+- 标签：深度优先搜索、广度优先搜索、并查集、数组、哈希表、字符串、排序
+- 难度：中等
+
+## 题目链接
+
+- [0721. 账户合并 - 力扣](https://leetcode.cn/problems/accounts-merge/)
+
+## 题目大意
+
+**描述**：
+
+给定一个列表 $accounts$，每个元素 $accounts[i]$ 是一个字符串列表，其中第一个元素 $accounts[i][0]$ 是名称($name$)，其余元素是 $emails$ 表示该账户的邮箱地址。
+
+现在，我们想合并这些账户。如果两个账户都有一些共同的邮箱地址，则两个账户必定属于同一个人。请注意，即使两个账户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有任意数量的账户，但其所有账户都具有相同的名称。
+
+**要求**：
+
+合并账户后，按以下格式返回账户：每个账户的第一个元素是名称，其余元素是按字符 ASCII 顺序排列的邮箱地址。账户本身可以以任意顺序返回。
+
+**说明**：
+
+- $1 \le accounts.length \le 10^{3}$。
+- $2 \le accounts[i].length \le 10$。
+- $1 \le accounts[i][j].length \le 30$。
+- $accounts[i][0]$ 由英文字母组成。
+- $accounts[i][j] (for j \gt 0)$ 是有效的邮箱地址。
+
+**示例**：
+
+- 示例 1：
+
+```python
+输入：accounts = [["John", "johnsmith@mail.com", "john00@mail.com"], ["John", "johnnybravo@mail.com"], ["John", "johnsmith@mail.com", "john_newyork@mail.com"], ["Mary", "mary@mail.com"]]
+输出：[["John", 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com'],  ["John", "johnnybravo@mail.com"], ["Mary", "mary@mail.com"]]
+解释：
+第一个和第三个 John 是同一个人，因为他们有共同的邮箱地址 "johnsmith@mail.com"。 
+第二个 John 和 Mary 是不同的人，因为他们的邮箱地址没有被其他帐户使用。
+可以以任何顺序返回这些列表，例如答案 [['Mary'，'mary@mail.com']，['John'，'johnnybravo@mail.com']，
+['John'，'john00@mail.com'，'john_newyork@mail.com'，'johnsmith@mail.com']] 也是正确的。
+```
+
+- 示例 2：
+
+```python
+输入：accounts = [["Gabe","Gabe0@m.co","Gabe3@m.co","Gabe1@m.co"],["Kevin","Kevin3@m.co","Kevin5@m.co","Kevin0@m.co"],["Ethan","Ethan5@m.co","Ethan4@m.co","Ethan0@m.co"],["Hanzo","Hanzo3@m.co","Hanzo1@m.co","Hanzo0@m.co"],["Fern","Fern5@m.co","Fern1@m.co","Fern0@m.co"]]
+输出：[["Ethan","Ethan0@m.co","Ethan4@m.co","Ethan5@m.co"],["Gabe","Gabe0@m.co","Gabe1@m.co","Gabe3@m.co"],["Hanzo","Hanzo0@m.co","Hanzo1@m.co","Hanzo3@m.co"],["Kevin","Kevin0@m.co","Kevin3@m.co","Kevin5@m.co"],["Fern","Fern0@m.co","Fern1@m.co","Fern5@m.co"]]
+```
+
+## 解题思路
+
+### 思路 1：并查集
+
+这道题的核心是将具有相同邮箱的账户合并在一起。可以使用并查集来解决。
+
+**解题步骤**：
+
+1. 将每个邮箱看作一个节点，如果两个邮箱属于同一个账户，就将它们连接起来。
+2. 使用哈希表 $email\_to\_id$ 记录每个邮箱对应的账户索引。
+3. 使用并查集将属于同一个人的邮箱合并到同一个集合中。
+4. 遍历所有账户，对于每个账户中的邮箱：
+   - 如果邮箱第一次出现，记录其账户索引。
+   - 如果邮箱已经出现过，将当前账户与之前的账户合并。
+5. 最后，将同一集合中的所有邮箱归类到一起，并按字典序排序。
+
+### 思路 1：代码
+
+```python
+class Solution:
+    def accountsMerge(self, accounts: List[List[str]]) -> List[List[str]]:
+        # 并查集
+        parent = {}
+        
+        def find(x):
+            if x not in parent:
+                parent[x] = x
+            if parent[x] != x:
+                parent[x] = find(parent[x])
+            return parent[x]
+        
+        def union(x, y):
+            root_x = find(x)
+            root_y = find(y)
+            if root_x != root_y:
+                parent[root_x] = root_y
+        
+        # 邮箱到账户索引的映射
+        email_to_id = {}
+        # 邮箱到姓名的映射
+        email_to_name = {}
+        
+        # 遍历所有账户，建立邮箱之间的连接
+        for account in accounts:
+            name = account[0]
+            for i in range(1, len(account)):
+                email = account[i]
+                email_to_name[email] = name
+                
+                if email not in email_to_id:
+                    email_to_id[email] = email
+                
+                # 将当前账户的所有邮箱合并到第一个邮箱的集合中
+                union(account[1], email)
+        
+        # 将同一集合的邮箱归类
+        merged = {}
+        for email in email_to_id:
+            root = find(email)
+            if root not in merged:
+                merged[root] = []
+            merged[root].append(email)
+        
+        # 构建结果
+        result = []
+        for emails in merged.values():
+            name = email_to_name[emails[0]]
+            result.append([name] + sorted(emails))
+        
+        return result
+```
+
+### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(n \log n)$，其中 $n$ 是所有邮箱的总数。并查集操作的时间复杂度接近 $O(1)$，主要时间消耗在排序上。
+- **空间复杂度**：$O(n)$。需要存储并查集、哈希表等数据结构。
@@ -0,0 +1,94 @@
+# [0799. 香槟塔](https://leetcode.cn/problems/champagne-tower/)
+
+- 标签：动态规划
+- 难度：中等
+
+## 题目链接
+
+- [0799. 香槟塔 - 力扣](https://leetcode.cn/problems/champagne-tower/)
+
+## 题目大意
+
+**描述**：
+
+我们把玻璃杯摆成金字塔的形状，其中第一层有 $1$ 个玻璃杯，第二层有 $2$ 个，依次类推到第 $100$ 层，每个玻璃杯将盛有香槟。
+
+从顶层的第一个玻璃杯开始倾倒一些香槟，当顶层的杯子满了，任何溢出的香槟都会立刻等流量的流向左右两侧的玻璃杯。当左右两边的杯子也满了，就会等流量的流向它们左右两边的杯子，依次类推。（当最底层的玻璃杯满了，香槟会流到地板上）
+
+例如，在倾倒一杯香槟后，最顶层的玻璃杯满了。倾倒了两杯香槟后，第二层的两个玻璃杯各自盛放一半的香槟。在倒三杯香槟后，第二层的香槟满了 - 此时总共有三个满的玻璃杯。在倒第四杯后，第三层中间的玻璃杯盛放了一半的香槟，他两边的玻璃杯各自盛放了四分之一的香槟，如下图所示。
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/03/09/tower.png)
+
+**要求**：
+
+现在当倾倒了非负整数杯香槟后，返回第 $i$ 行 $j$ 个玻璃杯所盛放的香槟占玻璃杯容积的比例（ $i$ 和 $j$ 都从 $0$ 开始）。
+
+**说明**：
+
+- $0 \le poured \le 10^{9}$。
+- $0 \le query\_glass \le query\_row \lt 10^{3}$。
+
+**示例**：
+
+- 示例 1：
+
+```python
+示例 1:
+输入: poured(倾倒香槟总杯数) = 1, query_glass(杯子的位置数) = 1, query_row(行数) = 1
+输出: 0.00000
+解释: 我们在顶层（下标是（0，0））倒了一杯香槟后，没有溢出，因此所有在顶层以下的玻璃杯都是空的。
+```
+
+- 示例 2：
+
+```python
+输入: poured(倾倒香槟总杯数) = 2, query_glass(杯子的位置数) = 1, query_row(行数) = 1
+输出: 0.50000
+解释: 我们在顶层（下标是（0，0）倒了两杯香槟后，有一杯量的香槟将从顶层溢出，位于（1，0）的玻璃杯和（1，1）的玻璃杯平分了这一杯香槟，所以每个玻璃杯有一半的香槟。
+```
+
+## 解题思路
+
+### 思路 1：动态规划 + 模拟
+
+这道题可以使用动态规划来模拟香槟倾倒的过程。
+
+**解题步骤**：
+
+1. 定义 $dp[i][j]$ 表示第 $i$ 行第 $j$ 个杯子中的香槟量（可能超过 $1$）。
+2. 初始时，将所有香槟倒入顶层杯子：$dp[0][0] = poured$。
+3. 对于每个杯子 $dp[i][j]$：
+   - 如果 $dp[i][j] > 1$，说明有香槟溢出。
+   - 溢出的香槟量为 $overflow = (dp[i][j] - 1) / 2$。
+   - 将溢出的香槟平均分配给下一层的两个杯子：$dp[i+1][j]$ 和 $dp[i+1][j+1]$。
+4. 最后返回 $\min(1, dp[query\_row][query\_glass])$，因为杯子最多只能装 $1$ 杯香槟。
+
+**优化**：由于只需要计算到第 $query\_row$ 行，所以只需要模拟到该行即可。
+
+### 思路 1：代码
+
+```python
+class Solution:
+    def champagneTower(self, poured: int, query_row: int, query_glass: int) -> float:
+        # dp[i][j] 表示第 i 行第 j 个杯子中的香槟量
+        dp = [[0.0] * (query_row + 2) for _ in range(query_row + 2)]
+        dp[0][0] = poured
+        
+        # 模拟香槟倾倒过程
+        for i in range(query_row + 1):
+            for j in range(i + 1):
+                if dp[i][j] > 1:
+                    # 计算溢出的香槟量
+                    overflow = (dp[i][j] - 1) / 2.0
+                    # 将溢出的香槟平均分配给下一层的两个杯子
+                    dp[i + 1][j] += overflow
+                    dp[i + 1][j + 1] += overflow
+        
+        # 返回目标杯子中的香槟量，最多为 1
+        return min(1.0, dp[query_row][query_glass])
+```
+
+### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(query\_row^2)$。需要遍历前 $query\_row + 1$ 行的所有杯子。
+- **空间复杂度**：$O(query\_row^2)$。需要存储前 $query\_row + 1$ 行的所有杯子的状态。