LeetCode 131.分割回文串：回溯法与回文子串判定的结合

一、问题本质与解题框架

1.1 问题形式化定义

• 输入：字符串s（长度≤16）
• 输出：所有可能的将s分割为若干个回文子串的方案
• 示例：
  输入：s = "aab"
  输出：[["a","a","b"],["aa","b"]]

1.2 回溯法解题框架

回文串分割本质是组合搜索问题，可通过回溯法构建所有可能的分割方案：

void backtrack(路径, 选择列表, 起始位置) {
    if (终止条件) {
        记录结果;
        return;
    }
    for (选择 : 选择列表) {
        做选择;
        backtrack(路径, 选择列表, 新起始位置);
        撤销选择;
    }
}

在本题中：

• 路径：当前已分割出的回文子串列表temp
• 选择列表：从起始位置start开始的所有可能子串s[start..i]
• 终止条件：起始位置到达字符串末尾start == s.length()

二、递归回溯过程详解

2.1 核心递归逻辑

public void backtracking(String s, StringBuilder tempStr, int start) {
    // 终止条件：所有字符处理完毕
    if (start == s.length()) {
        res.add(new ArrayList<>(temp));
        return;
    }
    // 枚举所有可能的子串 [start, i]
    for (int i = start; i < s.length(); i++) {
        tempStr.append(s.charAt(i));
        // 检查当前子串是否为回文
        if (checkWord(tempStr)) {
            temp.add(tempStr.toString());
            // 递归处理剩余字符串
            backtracking(s, new StringBuilder(), i + 1);
            temp.removeLast(); // 回溯
        }
    }
}

2.2 回文判定优化

代码中的checkWord函数采用双指针法判定回文：

public boolean checkWord(StringBuilder s) {
    int l = 0, r = s.length() - 1;
    while (l <= r) {
        if (s.charAt(l) != s.charAt(r)) return false;
        l++;
        r--;
    }
    return true;
}

时间复杂度：每次判定需O(n)，总时间复杂度为O(n×2ⁿ)
优化方向：使用动态规划预处理所有子串的回文状态，将判定降为O(1)

三、模拟案例演示

3.1 输入s = "aab"的递归展开

初始调用：backtracking("aab", "", 0)

第一层(start=0):
i=0: 子串"a"（回文）→ temp=["a"] → 递归(start=1)
i=1: 子串"aa"（回文）→ temp=["aa"] → 递归(start=2)
i=2: 子串"aab"（非回文）→ 跳过

第二层(start=1):
i=1: 子串"a"（回文）→ temp=["a","a"] → 递归(start=2)
i=2: 子串"ab"（非回文）→ 跳过

第三层(start=2):
i=2: 子串"b"（回文）→ temp=["a","a","b"] → 记录结果 → 回溯

第二层(start=2):
i=2: 子串"b"（回文）→ temp=["aa","b"] → 记录结果 → 回溯

3.2 状态树可视化

                          root
                         /   \
                      [a]     [aa]
                     /  \       \
                   [a]  [ab]     [b]
                  /
                [b]

• 每个节点表示当前已分割的回文子串列表
• 树枝表示新加入的回文子串
• 叶子节点表示一种完整的分割方案

四、关键技术点解析

4.1 字符串处理优化

• 使用StringBuilder：
  代码中通过tempStr.append(s.charAt(i))动态构建子串，避免频繁创建新字符串对象
• 回溯时无需清理tempStr：
  每次递归传递new StringBuilder()，避免回溯时手动删除字符

4.2 结果记录的深拷贝

res.add(new ArrayList<>(temp));

• 必须使用深拷贝，否则后续回溯操作会修改已记录的结果

4.3 时间复杂度分析

• 最坏情况：所有可能的分割方案数为2ⁿ⁻¹（每个间隙可选切或不切）
• 每次判定回文：O(n)
• 总时间复杂度：O(n×2ⁿ)
• 空间复杂度：O(n)（递归栈深度+临时字符串）

五、常见误区与优化方案

5.1 重复计算回文子串

• 问题：当前代码每次递归都重新检查子串是否为回文
• 优化：使用动态规划预处理所有子串的回文状态

  boolean[][] dp = new boolean[n][n];
  for (int i = n - 1; i >= 0; i--) {
      for (int j = i; j < n; j++) {
          if (s.charAt(i) == s.charAt(j) && (j - i <= 1 || dp[i+1][j-1])) {
              dp[i][j] = true;
          }
      }
  }
  

  预处理后回文判定降为O(1)，总时间复杂度优化为O(2ⁿ)

5.2 字符串处理效率

• 当前方案：每次递归创建新的StringBuilder
• 优化方案：统一使用一个StringBuilder，回溯时删除最后添加的字符

  void backtrack(int start) {
      if (start == n) {
          res.add(new ArrayList<>(temp));
          return;
      }
      for (int i = start; i < n; i++) {
          if (isPalindrome(s, start, i)) {
              temp.add(s.substring(start, i + 1));
              backtrack(i + 1);
              temp.remove(temp.size() - 1);
          }
      }
  }
  

六、扩展问题与解题模板

6.1 通用回溯模板

List<List<String>> res = new ArrayList<>();
List<String> path = new ArrayList<>();

public List<List<String>> partition(String s) {
    backtrack(s, 0);
    return res;
}

private void backtrack(String s, int start) {
    if (start == s.length()) {
        res.add(new ArrayList<>(path));
        return;
    }
    for (int i = start; i < s.length(); i++) {
        if (isPalindrome(s, start, i)) {
            path.add(s.substring(start, i + 1));
            backtrack(s, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

private boolean isPalindrome(String s, int left, int right) {
    while (left < right) {
        if (s.charAt(left) != s.charAt(right)) {
            return false;
        }
        left++;
        right--;
    }
    return true;
}

6.2 相关问题拓展

1. 最小分割次数（LeetCode 132）：
   动态规划解法，dp[i]表示s[0…i]的最小分割次数
2. 分割回文串II（LeetCode 132）：
   需结合预处理回文状态和动态规划
3. 生成所有回文排列（LeetCode 267）：
   回溯法生成所有可能的回文排列

七、总结：回溯法解决分割问题的关键

1. 状态定义：

   • 使用start指针表示当前处理的起始位置
   • 使用temp列表记录当前已分割的回文子串

2. 选择逻辑：

   • 枚举从start开始的所有可能子串
   • 仅当子串为回文时继续递归

3. 优化方向：

   • 预处理回文状态矩阵，将判定复杂度降为O(1)
   • 合理使用StringBuilder减少字符串操作开销

掌握这套框架，可解决所有字符串分割相关的组合搜索问题，核心在于递归过程中如何正确维护状态并枚举所有可能的分割点。