前端算法第一六六弹-分割回文串

一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第22天，点击查看活动详情。

给你一个字符串 s，请你将 **s **分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入： s = "aab"
输出： [["a","a","b"],["aa","b"]]

示例 2：

输入： s = "a"
输出： [["a"]]

提示：

• 1 <= s.length <= 16
• s 仅由小写英文字母组成

---

回溯 + 动态规划预处理

由于需要求出字符串 s 的所有分割方案，因此我们考虑使用搜索 + 回溯的方法枚举所有可能的分割方法并进行判断。

假设我们当前搜索到字符串的第 i 个字符，且 $s[0..i-1]$ 位置的所有字符已经被分割成若干个回文串，并且分割结果被放入了答案数组 $\textit{ans}$ 中，那么我们就需要枚举下一个回文串的右边界 $j$，使得 $s[i..j]$ 是一个回文串。

因此，我们可以从 $i$ 开始，从小到大依次枚举$j$。对于当前枚举的 $j$ 值，我们使用双指针的方法判断 $s[i..j]$ 是否为回文串：如果 $s[i..j]$ 是回文串，那么就将其加入答案数组 $\textit{ans}$ 中，并以 $j+1$ 作为新的 $i$ 进行下一层搜索，并在未来的回溯时将 $s[i..j]$ 从 $\textit{ans}$ 中移除。

如果我们已经搜索完了字符串的最后一个字符，那么就找到了一种满足要求的分割方法。

细节

当我们在判断$s[i..j]$ 是否为回文串时，常规的方法是使用双指针分别指向 $i$ 和 $j$，每次判断两个指针指向的字符是否相同，直到两个指针相遇。然而这种方法会产生重复计算，例如下面这个例子：

当 $s = \texttt{aaba}$时，对于前 2 个字符 $\texttt{aa}$，我们有 2 种分割方法 $[\texttt{aa}]$ 和$[\texttt{a}, \texttt{a}]$，当我们每一次搜索到字符串的第 $i=2$ 个字符 $\texttt{b}$时，都需要对于每个 $s[i..j]$ 使用双指针判断其是否为回文串，这就产生了重复计算。

因此，我们可以将字符串 s 的每个子串 $s[i..j]$ 是否为回文串预处理出来，使用动态规划即可。设 $f(i, j)$ 表示 $s[i..j]$ 是否为回文串，那么有状态转移方程：

其中 $\wedge$ 表示逻辑与运算，即 $s[i..j]$ 为回文串，当且仅当其为空串（$i>j$），其长度为 1（$i=j$），或者首尾字符相同且 $s[i+1..j−1]$ 为回文串。

预处理完成之后，我们只需要 $O(1)$ 的时间就可以判断任意 $s[i..j$ 是否为回文串了。

var partition = function(s) {
    const dfs = (i) => {
        if (i === n) {
            ret.push(ans.slice());
            return;
        }
        for (let j = i; j < n; ++j) {
            if (f[i][j]) {
                ans.push(s.slice(i, j + 1));
                dfs(j + 1);
                ans.pop();
            }
        }
    }
    
    const n = s.length;
    const f = new Array(n).fill(0).map(() => new Array(n).fill(true));
    let ret = [], ans = [];
    
    for (let i = n - 1; i >= 0; --i) {
        for (let j = i + 1; j < n; ++j) {
            f[i][j] = (s[i] === s[j]) && f[i + 1][j - 1];
        }
    }
    dfs(0);
    return ret;
};