6.5 模拟专题：LeetCode 38. 外观数列

1. 题目链接

LeetCode 38. 外观数列

---

2. 题目描述

给定一个正整数 n，生成外观数列的第 n 项。外观数列的定义如下：

• 第 1 项为 "1"。
• 第 n 项是对第 n-1 项的描述。例如，第 2 项描述第 1 项（"1"）为 "11"（即“1个1”），第 3 项描述第 2 项（"11"）为 "21"（即“2个1”），依次类推。

示例：

• 输入：n = 4 → 输出："1211"
• 输入：n = 5 → 输出："111221"

---

3. 示例分析

1. 基础案例：

   • n=1 → "1"
   • n=2 → "11"
   • n=3 → "21"
   • n=4 → "1211"（描述 "21" 为“1个2，1个1”）
   • n=5 → "111221"（描述 "1211" 为“1个1，1个2，2个1”）

2. 复杂案例：

   • n=6 → "312211"（描述 "111221" 为“3个1，2个2，1个1”）

---

4. 算法思路

核心思想：迭代生成 + 双指针统计

1. 初始化：从第 1 项 "1" 开始迭代。
2. 迭代生成：对当前项从左到右扫描，统计连续相同字符的数量。
3. 双指针统计：
   • left 指针标记当前字符的起始位置。
   • right 指针向右移动，直到遇到不同字符。
   • 统计长度 right - left，拼接成新字符串的 "数量+字符"。
4. 循环递推：重复上述过程 n-1 次，生成第 n 项。

时间复杂度：

• 外层循环 n-1 次，内层遍历字符串长度，总时间复杂度为 O(n·m)，其中 m 为字符串的平均长度。

---

5. 边界条件与注意事项

1. 输入范围：
   • n ≥ 1，需处理 n=1 直接返回 "1"。
2. 字符串拼接优化：
   • 使用 string 的 += 操作拼接字符，避免频繁创建新对象。
3. 指针越界检查：
   • 内层循环需确保 left 和 right 不超过字符串长度。
4. 大数问题：
   • 当 n 较大时（如 n=30），生成的字符串长度可能超过 1e5，需注意内存限制。

---

6. 代码实现

class Solution {
public:
    string countAndSay(int n) {
        string ret = "1";
        for (int i = 1; i < n; i++) { // 迭代生成前n-1项
            string tmp; // 临时存储当前项的下一项描述
            int len = ret.size();
            for (int left = 0, right = 0; right < len;) {
                // 移动right指针，统计连续相同字符的数量
                while (right < len && ret[right] == ret[left]) right++;
                // 拼接"数量+字符"
                tmp += to_string(right - left) + ret[left];
                left = right; // 更新left指针到下一个字符的起始位置
            }
            ret = tmp; // 更新当前项
        }
        return ret;
    }
};

---

关键代码解析

1. 外层循环控制迭代次数：

   for (int i = 1; i < n; i++)
   

   • 从第 1 项开始，生成到第 n 项需要迭代 n-1 次。

2. 双指针统计连续字符：

   while (right < len && ret[right] == ret[left]) right++;
   

   • right 指针右移，直到遇到不同字符或越界。此时 right - left 即为连续字符的数量。

3. 拼接描述字符串：

   tmp += to_string(right - left) + ret[left];
   

   • 将数量转换为字符串，并与当前字符拼接。例如，连续 2 个 '1' 拼接为 "21"。

4. 更新指针位置：

   left = right;
   

   • 将 left 移动到下一个待统计字符的起始位置。

---

与其他解法的对比

方法	时间复杂度	空间复杂度	核心思想
递归法	O(n·m)	O(n·m)	递归生成前一项，再描述
迭代法	O(n·m)	O(m)	双指针遍历，直接构造
动态规划法	O(n·m)	O(m)	存储中间结果，避免重复计算

---

总结

迭代法通过双指针高效统计连续字符，避免了递归的栈空间开销，是本题的最优解。其核心在于 逐层递推 和 双指针滑动窗口，以线性时间复杂度生成外观数列。

适用场景：

• 需要快速生成较大 n 值的结果（如 n ≤ 30）。
• 内存敏感场景，避免递归栈溢出。

关键点：

• 理解双指针在统计连续字符中的应用。
• 掌握字符串拼接的优化技巧。