当前位置：首页 > news >正文

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

news 来源：原创 2025/6/3 11:49:03

一、问题本质与解题框架

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;
}