Backtracking on Hang Zhang

Non Decreasing Subsequences

Sat, 26 Apr 2025 00:00:00 +0000

491. 非递减子序列

分析

path 数组记录当前构建中的子序列
每当 path 长度大于等于 2，就加入答案集
每次从下标 u 开始向后枚举所有可能的数字：
- 若当前数字 nums[i] 可以接在 path 的末尾（即递增），就加入递归
- 用一个哈希集合 S 记录当前层用过的数字，避免同一层出现重复元素（防止结果中出现重复子序列）

时间复杂度

时间复杂度 O(2^n)

空间复杂度

空间复杂度 O(n)

C++代码

class Solution
{
public:
    std::vector<std::vector<int>> res; // 存储所有结果
    std::vector<int> path;             // 当前构建中的子序列

    void dfs(std::vector<int>& nums, int u)
    {
        // 如果子序列长度 >= 2，就加入结果集
        if (path.size() >= 2)
            res.push_back(path);

        if (u == nums.size()) return;

        std::unordered_set<int> S; // 当前层去重

        for (int i = u; i < nums.size(); ++ i)
        {
            // 满足递增条件且未在本层用过
            if ((path.empty() || path.back() <= nums[i]) && !S.count(nums[i]))
            {
                S.insert(nums[i]);      // 标记本层已使用
                path.push_back(nums[i]);
                dfs(nums, i + 1);       // 递归下一个位置
                path.pop_back();        // 回溯
            }
        }
    }

    vector<vector<int>> findSubsequences(vector<int>& nums)
    {
        dfs(nums, 0);
        return res;
    }
};

Partition to K Equal Sum Subsets

Fri, 25 Apr 2025 00:00:00 +0000

698. 划分为k个相等的子集

分析

目标和计算：
- 若 sum % k != 0，无法平均分配，直接返回 false
- 每个子集的目标和为 target = sum / k
DFS 搜索状态：
- 从第 u 个元素开始，递归地尝试将当前元素加入某个子集
- 当前子集的和为 cur，如果正好等于 target，递归下一个子集k - 1
- 使用 st[i] 记录第 i 个元素是否已被使用
剪枝优化：
- 排序数组后，跳过相同的数字，避免重复搜索
- 当前 cur + nums[i] > target 时剪枝

时间复杂度

时间复杂度 O(k * 2^n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int target = 0;               // 每个子集的目标和
    std::vector<bool> st;        // 标记数组：记录元素是否被使用

    // 回溯搜索函数
    bool dfs(std::vector<int>& nums, int u, int cur, int k)
    {
        if (k == 0) return true;                        // 成功划分成 k 个子集
        if (cur == target)                              // 当前子集满了，开始下一个
            return dfs(nums, 0, 0, k - 1);

        for (int i = u; i < nums.size(); ++ i)
        {
            if (!st[i])
            {
                if (cur + nums[i] <= target)            // 不超过目标和
                {
                    st[i] = true;
                    if (dfs(nums, i + 1, cur + nums[i], k))
                        return true;
                    st[i] = false;                      // 回溯
                }

                // 跳过重复数字，避免冗余递归
                while (i + 1 < nums.size() && nums[i] == nums[i + 1])
                    ++ i;
            }
        }
        return false;
    }

    bool canPartitionKSubsets(vector<int>& nums, int k)
    {
        int sum = 0;
        for (int x : nums) sum += x;
        if (sum % k) return false;                      // 不能整除，无法划分

        target = sum / k;
        st = std::vector<bool>(nums.size());

        sort(nums.begin(), nums.end());                 // 优化搜索顺序（方便剪枝）
        return dfs(nums, 0, 0, k);
    }
};

Restore IP Address

Thu, 03 Apr 2025 00:00:00 +0000

93. 复原IP地址

分析

有效 IP 地址的要求
- 由 4 个整数组成（范围 0 ~ 255）
- 整数之间用 . 分隔
- 不能有前导 0（如 "01" 是非法的）
- 所有字符必须被使用
dfs 递归逻辑
- u：当前扫描到的字符索引
- k：当前已解析出的 IP 段数
- path：当前已拼接的 IP 地址（尚未去除最后一个 .）
- 递归终止条件：
  - u == s.size()：如果字符串已经完全遍历：
    - 如果 k == 4，说明成功找到一个 IP 地址，去掉最后一个 .，加入结果集 res
    - 否则，返回（分段不足 4 段）
  - 如果 k == 4 且 s 还未遍历完，返回
遍历 1 ~ 3 位
- 循环遍历 i = u 到 i < s.size()，每次尝试截取 1 ~ 3 位：
  - 若存在前导 0，停止搜索
  - 转换成整数 t：t = t * 10 + s[i] - '0'
  - 如果 t > 255，停止搜索（数字超出 IP 地址范围）
  - 递归调用 dfs，继续尝试下一段

时间复杂度

最多有 4 段，每段最多 3 种选择，时间复杂度 O(3^4)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    std::vector<std::string> res;  // 存放所有合法 IP 地址

    void dfs(std::string& s, int u, int k, std::string path)
    {
        if (u == s.size())  // 如果字符串已遍历完
        {
            if (k == 4)  // 且正好分成了 4 段
            {
                path.pop_back();  // 去掉最后一个 '.'
                res.push_back(path);  // 加入结果集
            }
            return;
        }

        if (k == 4)  // 超过 4 段，直接返回
            return;

        for (int i = u, t = 0; i < s.size(); ++i)
        {
            if (i > u && s[u] == '0')  // 不能有前导 0
                break;

            t = t * 10 + s[i] - '0';  // 将字符转换成整数

            if (t > 255)  // 超出 255，直接停止
                break;

            dfs(s, i + 1, k + 1, path + std::to_string(t) + '.');  // 递归
        }
    }

    vector<string> restoreIpAddresses(string s)
    {
        dfs(s, 0, 0, "");
        return res;
    }
};

Combination Sum III

Mon, 06 Jan 2025 00:00:00 +0000

216. 组合总和III

分析

采用深度优先搜索（DFS）+ 回溯来解决问题：

递归函数设计：
- 参数：
  - 当前搜索起点 start（避免重复选择数字）
  - 当前目标和 n
  - 当前还需要选的数字个数 k
- 终止条件：
  - 如果 n == 0 且 k == 0 ，说明找到了一组符合条件的组合，将其加入结果列表
  - 如果 n != 0 且 k == 0 ，或者 n < 0 ，直接返回（剪枝）
递归遍历：
- 从 start 开始，依次尝试数字 i （范围 start 到 9
- 每次选择 i 后递归：将 i 加入路径，更新 n = n - i ，更新 k = k - 1
- 递归返回后撤销选择 i（回溯）
剪枝优化：
- 如果 i > n ，则跳过剩余数字，直接剪枝，因为后续数字只会更大

时间复杂度

最多有 9 / k 个组合，其中 n / k = n! / k!(n-k)!
每次递归需要 O(k) 的时间来复制路径

总时间复杂度为 O(k * 9 / k)

空间复杂度

路径 path 的最大深度为 k ，递归调用栈的深度也为 k

空间复杂度为 O(k)

C++代码

class Solution
{
public:
    std::vector<std::vector<int>> res; // 存储结果
    std::vector<int> path;             // 当前路径

    vector<vector<int>> combinationSum3(int k, int n)
    {
        dfs(1, n, k); // 从数字1开始搜索
        return res;
    }

    void dfs(int start, int n, int k)
    {
        if (n == 0)
        {
            if (k == 0)
                res.push_back(path); // 找到一个合法组合
            return;
        }
        if (k == 0) return; // 数字用完，但和未达到目标

        for (int i = start; i <= 9; ++i)
        {
            if (i > n) break; // 剪枝：当前数字大于目标和
            path.push_back(i); // 选择数字i
            dfs(i + 1, n - i, k - 1); // 递归搜索
            path.pop_back(); // 回溯，撤销选择
        }
    }
};

N Queens

Fri, 06 Dec 2024 00:00:00 +0000

51. N皇后

分析

棋盘表示：
- 使用一个长度为 n 的字符串数组 path 表示棋盘，每个字符串表示棋盘的一行，'.' 表示空格，'Q’ 表示皇后
- res 保存所有可能的棋盘方案
冲突检测：
- 使用三个布尔数组记录皇后占据的列和对角线：
  - col[i] 表示第 i 列是否有皇后
  - dg[i] 表示正对角线是否有皇后（从左上到右下，索引为 u - i + n）
    - 正对角线元素使用索引u - i来表示，因为正对角线上的元素都满足坐标x - y == 0
    - 棋盘上所有元素坐标之差范围是-(n - 1) ~ n - 1，加偏移量 n 将其映射为1 ~ 2n - 1
  - udg[i] 表示反对角线是否有皇后（从右上到左下，索引为 u + i）
    - 反对角线元素使用u + i来表示，因为反对角线上的元素都满足坐标x + y == n
    - 棋盘上所有元素坐标之和范围为0 ~ 2(n - 1)，因此不需要加偏移量
回溯放置皇后：
- 从第 u 行开始，尝试在每一列放置皇后
- 如果当前列、正对角线、反对角线均未被占用，则将皇后放置在对应位置，并标记这些区域为占用
- 递归尝试放置下一行的皇后
- 回溯时，将皇后移除，并恢复状态
结果保存：
- 当递归到最后一行 u == n 时，说明当前方案有效，将棋盘方案保存到结果中

时间复杂度

每一行最多有 n 个选择，搜索深度为 n，回溯过程的总时间复杂度约为 O(n!)

空间复杂度

需要存储棋盘状态 path 和标记数组（col、dg、udg），每个的大小为 O(n)

总空间复杂度为 O(n²)，主要用于存储结果

C++代码

class Solution
{
public:
    std::vector<std::vector<std::string>> res; // 存储所有有效的棋盘方案
    std::vector<std::string> path; // 当前棋盘状态
    std::vector<bool> col, dg, udg; // 列、正对角线、反对角线的占用状态

    vector<vector<string>> solveNQueens(int n)
    {
      // 初始化棋盘和标记数组
      path = std::vector<std::string>(n, std::string(n, '.'));
      col = std::vector<bool>(n);
      dg = std::vector<bool>(2 * n);
      udg = std::vector<bool>(2 * n);

      // 开始回溯
      dfs(n, 0);
      return res;
    }

    void dfs(int n, int u)
    {
      // 如果所有行都放置完成，保存当前棋盘方案
      if (u == n)
      {
        res.push_back(path);
        return;
      }

      // 遍历当前行的每一列，尝试放置皇后
      for (int i = 0; i < n; ++i)
      {
        if (!col[i] && !dg[u - i + n] && !udg[u + i]) // 检查是否冲突
        {
          // 放置皇后并标记状态
          col[i] = dg[u - i + n] = udg[u + i] = true;
          path[u][i] = 'Q';

          // 递归放置下一行
          dfs(n, u + 1);

          // 回溯：移除皇后并恢复状态
          path[u][i] = '.';
          col[i] = dg[u - i + n] = udg[u + i] = false;
        }
      }
    }
};

Combination Sum

Thu, 05 Dec 2024 00:00:00 +0000

39. 数组总和

分析

使用深度优先搜索（DFS）+ 回溯的方法
遍历候选数组 candidates 时，允许重复选择当前数字，目标值 target 减去选中的数字，直到达到目标（target == 0）
若 target 不为 0，但已遍历完数组，表示当前路径无解，返回上一层
回溯时移除已选择的数字

关键：每次递归时，既允许不选当前数字，也允许多次选取当前数字

时间复杂度

最坏情况下，candidates 长度为 n，每次递归中需要尝试所有可能的组合，时间复杂度为 O(2^n)

空间复杂度

递归深度为 target / min(candidates)，路径存储需要 O(target / min(candidates))

C++代码

class Solution
{
public:
    std::vector<std::vector<int>> res;  // 存储结果集
    std::vector<int> path;             // 当前路径

    vector<vector<int>> combinationSum(vector<int>& candidates, int target)
    {
        dfs(candidates, 0, target);    // 从第一个数字开始递归
        return res;
    }

    void dfs(std::vector<int>& candidates, int u, int target)
    {
        if (target == 0)
        {             // 目标值为0，找到一种组合
            res.push_back(path);
            return;
        }
        if (u == candidates.size())    // 遍历完所有数字
            return;

        // 尝试选择当前数字若干次
        for (int i = 0; i * candidates[u] <= target; ++i)
        {
            dfs(candidates, u + 1, target - i * candidates[u]);  // 递归
            path.push_back(candidates[u]); // 将当前数字加入路径
        }
        for (int i = 0; i * candidates[u] <= target; ++i)
        {
            path.pop_back();           // 回溯，移除当前数字
        }
    }
};

Palindrome Partitioning

Thu, 05 Dec 2024 00:00:00 +0000

131. 分割回文串

分析

预处理判断回文子串：
- 通过动态规划预处理所有可能的子串，判断每个子串是否是回文
- 定义二维数组 f[i][j]，表示从 i 到 j 的子串是否为回文：
  - 若 s[i] == s[j]，且内部的子串 s[i+1:j-1] 也是回文，则 f[i][j] = true
  - 特殊情况下（i == j 或 j == i+1），直接判断字符是否相等
回溯搜索分割方案：
- 从字符串的第一个字符开始尝试分割
- 若当前子串是回文，则将其加入路径中，继续搜索剩余部分
- 如果遍历完整个字符串，将当前路径保存为一种结果
- 搜索结束后，将最后加入路径的子串弹出，回溯到上一步继续尝试

时间复杂度

预处理回文数组：需要枚举所有子串，时间复杂度为 O(n²)
回溯搜索：每个字符有两种选择（分割或不分割），复杂度近似为 O(2ⁿ)

总体时间复杂度：O(n² + 2ⁿ)

空间复杂度

动态规划数组 f 占用 O(n²)
递归深度最多为字符串长度 n，路径数组和递归栈占用 O(n)

总体空间复杂度：O(n²)

C++代码

class Solution
{
public:
    std::vector<std::vector<std::string>> res; // 存储最终结果
    std::vector<std::string> path; // 当前路径
    std::vector<std::vector<bool>> f; // 动态规划存储回文判断结果

    vector<vector<string>> partition(string s)
    {
      int n = s.size();
      // 初始化回文判断数组
      f = std::vector<std::vector<bool>>(n, std::vector<bool>(n));

      // 动态规划预处理回文子串
      for (int j = 0; j < n; ++j)
        for (int i = 0; i <= j; ++i)
        {
          if (i == j) // 单个字符是回文
            f[i][j] = true;
          else if (s[i] == s[j]) // 判断两端字符是否相等
            if (i + 1 > j - 1 || f[i + 1][j - 1]) // 内部子串为空或回文
              f[i][j] = true;
        }

      // 开始回溯搜索
      dfs(s, 0);
      return res;
    }

    void dfs(std::string s, int u)
    {
      // 如果已经分割到字符串末尾，保存当前路径
      if (u == s.size())
      {
        res.push_back(path);
        return;
      }

      // 遍历从 u 开始的每个子串
      for (int i = u; i < s.size(); ++i)
        if (f[u][i]) // 如果当前子串是回文
        {
          path.push_back(s.substr(u, i - u + 1)); // 加入路径
          dfs(s, i + 1); // 递归处理剩余部分
          path.pop_back(); // 回溯
        }
    }
};

Word Search

Thu, 05 Dec 2024 00:00:00 +0000

79. 单词搜索

分析

从任意位置出发向下 dfs，只在搜到时，返回 true
若当前位置与 word 不等，返回 false
否则说明相等，检查是否搜到末尾，若搜到末尾返回 true
否则继续向下搜索
暂存当前字符
向四个方向向下 dfs
恢复现场

时间复杂度

每个网格单元都可能作为起点触发一次深度优先搜索。
搜索深度最多为 word.length。
最坏情况下，搜索路径为网格大小 m × n 的全部单元

时间复杂度为 O(m × n × 4^l)，其中 l 是单词的长度

空间复杂度

递归栈的深度最多为单词的长度 l，空间复杂度为 O(l)

C++代码

class Solution
{
public:
    bool exist(vector<vector<char>>& board, string word)
    {
      // 遍历整个网格
      for (int i = 0; i < board.size(); ++ i)
        for (int j = 0; j < board[0].size(); ++ j)
          if (dfs(board, word, 0, i, j))
            return true;
      return false; // 如果遍历完所有位置都未找到，返回false
    }

    bool dfs(std::vector<std::vector<char>>& board, std::string& word, int u, int x, int y)
    {
      // 当前字符与目标单词的字符不匹配
      if (board[x][y] != word[u])
        return false;

      // 匹配到单词的最后一个字符，返回true
      if (u == word.size() - 1)
        return true;

      // 标记当前字符已访问
      char temp = board[x][y];
      board[x][y] = '*';
      int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};

      for (int i = 0; i < 4; ++ i)
      {
        int a = x + dx[i], b = y + dy[i];
        // 确保新的位置不越界且未访问
        if (a < 0 || a >= board.size() || b < 0 || b >= board[0].size() || board[a][b] == '*')
         continue;
        // 递归检查下一字符是否匹配
        if (dfs(board, word, u + 1, a, b))
          return true;
      }

      // 恢复当前字符，继续尝试其他路径
      board[x][y] = temp;
      return false;
    }
};

Permutations

Wed, 04 Dec 2024 00:00:00 +0000

46. 全排列

分析

思路
- 每次递归选择一个未使用的数字加入当前路径，直到路径长度等于数组长度，记录当前排列
初始化
- 用 res 保存最终的所有排列结果
- 用 path 保存当前排列路径
- 用布尔数组 is_used 标记某个数字是否已被使用，避免重复选择
回溯逻辑 dfs
- 如果当前路径长度 u 等于数组长度，保存当前路径到结果集 res 中
- 遍历数组，对未使用的数字：
  - 标记为已使用
  - 将数字加入路径
  - 递归进入下一层
  - 回溯时取消标记并移除路径中的数字

时间复杂度

时间复杂度：O(n!)，因为共有 n! 种排列

空间复杂度

空间复杂度：O(n)，递归调用栈深度为 n，path 和 is_used 数组均为 O(n)

C++代码

class Solution
{
public:
    std::vector<std::vector<int>> res;   // 存储最终结果
    std::vector<int> path;              // 当前排列路径
    std::vector<bool> is_used;          // 标记是否使用过当前数字

    vector<vector<int>> permute(vector<int>& nums)
    {
        // 初始化 path 和 is_used 数组
        path = std::vector<int>(nums.size());
        is_used = std::vector<bool>(nums.size());

        // 调用回溯函数
        dfs(nums, 0);
        return res;
    }

    void dfs(std::vector<int>& nums, int u)
    {
        // 如果路径长度等于数组长度，保存结果
        if (u == nums.size())
        {
            res.push_back(path);
            return;
        }

        // 遍历所有数字，尝试加入当前路径
        for (int i = 0; i < nums.size(); ++i)
        {
            if (!is_used[i]) {           // 如果当前数字未使用
                is_used[i] = true;      // 标记当前数字已使用
                path[u] = nums[i];      // 加入当前路径
                dfs(nums, u + 1);       // 递归生成下一个位置的数字
                is_used[i] = false;     // 回溯时取消标记
            }
        }
    }
};

subsets

Wed, 04 Dec 2024 00:00:00 +0000

78. 子集

分析

回溯法

思路
- 每个元素都有两种状态：选入当前子集或不选入当前子集
- 对每个元素进行选择，并递归处理剩余元素
- 当递归到数组末尾时，将当前子集 path 加入结果集 res
步骤
- 用 res 存储所有子集结果
- 用 path 存储当前子集路径
- 用递归函数 dfs(nums, u) 表示从索引 u 开始构造子集
  - 如果索引到达数组末尾，将当前路径加入结果集
  - 否则：
    - 跳过当前元素，继续递归
    - 包含当前元素，继续递归，并在递归结束后回溯状态

位运算枚举

位运算思路
- 每个子集可以看作长度为 n 的二进制数，每一位 1 表示对应的数组元素被选中
- 枚举从 0 到 2^n - 1 的所有整数，用二进制表示子集选择情况
- 对于每个整数：
  - 遍历其二进制的每一位，若某一位为 1，将对应位置的数组元素加入当前子集
    - 将生成的子集加入结果集
步骤
- 初始化结果集 res
- 遍历从 0 到 2^n - 1 的整数，用位运算检查每一位是否为 1
- 若某位为 1，将对应的数组元素加入当前子集 path
- 枚举结束后返回结果集 res

时间复杂度

每个元素有两种状态（选或不选），总状态数为 2^n。遍历每个状态生成子集，总时间复杂度 O(n^2)

空间复杂度

递归调用栈深度为 O(n)，路径数组 path 最多占用 O(n)，总空间复杂度为 O(n)

C++代码

class Solution
{
public:
    std::vector<std::vector<int>> res;   // 存储所有子集
    std::vector<int> path;              // 当前子集路径

    vector<vector<int>> subsets(vector<int>& nums)
    {
        dfs(nums, 0);                   // 从索引 0 开始回溯
        return res;
    }

    void dfs(std::vector<int>& nums, int u)
    {
        // 递归终止条件：索引越界时，将当前路径加入结果集
        if (u == nums.size())
        {
            res.push_back(path);
            return;
        }

        // 不选择当前元素，继续递归
        dfs(nums, u + 1);

        // 选择当前元素，加入路径并继续递归
        path.push_back(nums[u]);
        dfs(nums, u + 1);

        // 回溯状态，移除当前元素
        path.pop_back();
    }
};


class Solution
{
public:
    vector<vector<int>> subsets(vector<int>& nums)
    {
        std::vector<std::vector<int>> res;  // 存储所有子集
        int n = nums.size();

        // 枚举所有可能的子集，用二进制表示
        for (int i = 0; i < (1 << n); ++i)
        {
            std::vector<int> path;          // 当前子集
            for (int j = 0; j < n; ++j)
            {
                if ((i >> j) & 1)           // 若第 j 位为 1，加入对应元素
                    path.push_back(nums[j]);
            }
            res.push_back(path);            // 将当前子集加入结果集
        }
        return res;
    }
};

Generate Parentheses

Sun, 24 Mar 2024 00:00:00 +0000

22. Generate Parentheses

分析

合法的括号组合需要满足：

左括号 ( 的数量不能超过 n
右括号 ) 的数量不能超过左括号的数量

递归函数在每一步根据当前左括号和右括号的数量，选择是否添加 ( 或 )

如果左括号数量小于 n，可以添加 (
如果右括号数量小于左括号，可以添加 )
当左右括号数量均达到 n 时，将当前路径 path 加入结果集

C++代码

class Solution
{
public:
    std::vector<std::string> res;   // 存储所有合法的括号组合
    std::string path;               // 当前生成的括号组合

    vector<string> generateParenthesis(int n)
    {
        dfs(n, 0, 0);               // 从 0 左括号和 0 右括号开始递归
        return res;
    }

    void dfs(int n, int l_p, int r_p)
    {
        // 如果左右括号都用完，生成一个合法组合
        if (l_p == n && r_p == n)
        {
            res.push_back(path);
            return;
        }

        // 尝试添加左括号
        if (l_p < n) {
            path.push_back('(');    // 添加左括号
            dfs(n, l_p + 1, r_p);  // 递归进入下一层
            path.pop_back();        // 回溯，移除左括号
        }

        // 尝试添加右括号
        if (r_p < n && r_p < l_p)
        {
            path.push_back(')');    // 添加右括号
            dfs(n, l_p, r_p + 1);  // 递归进入下一层
            path.pop_back();        // 回溯，移除右括号
        }
    }
};

Letter Combinations of a Phone Number

Tue, 19 Mar 2024 00:00:00 +0000

17. Letter Combinations of a Phone Number

分析

使用深度优先搜索（DFS）+ 回溯的方法。

遍历数字字符串，按每个数字对应的字母集依次尝试：
- 对当前数字的每个字母，将其加入组合路径中
- 递归进入下一个数字，直到遍历完所有数字，将当前组合加入结果集
回溯到上一步，尝试其他可能性

时间复杂度

数字字符串的长度为 n，每个数字对应最多 4 个字母。构造所有组合的时间复杂度为 O(4^n)

空间复杂度

递归深度为 n，路径存储需要 O(n)。
结果集存储需要 O(4^n * n)

C++代码

class Solution
{
public:
    std::vector<std::string> res;          // 存储结果集
    std::string path;                      // 当前路径
    std::vector<std::string> strs = {      // 数字对应的字母集
        "", "", "abc",
        "def", "ghi", "jkl",
        "mno", "pqrs", "tuv", "wxyz"
    };

    vector<string> letterCombinations(string digits)
    {
        if (digits.empty())                // 特殊情况处理：空字符串
            return res;
        dfs(digits, 0);                    // 从第一个数字开始递归
        return res;
    }

    void dfs(std::string& digits, int u)
    {
        if (u == digits.size())
        {
            res.push_back(path);           // 将当前路径加入结果集
            return;
        }
        for (char c : strs[digits[u] - '0']) // 遍历当前数字对应的字母集
        {
            path.push_back(c);             // 将当前字母加入路径
            dfs(digits, u + 1);            // 递归到下一个数字
            path.pop_back();               // 回溯，移除最后一个字母
        }
    }
};