【每日一题】131. 分割回文串

---

题目

题目链接：131. 分割回文串

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

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

示例 1：

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

示例 2：

输入：s = “a”
输出：[[“a”]]

提示：

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

解题思路

今天估计状态有点问题，写了好几题脑袋都是乱的，这题我卡了好久才写出来，虽然这题不算太难。

👉递归

开始我想的是用 for 循环做，但尝试了两三次都没写出来。最后我用递归写才写出来。

题目的意思就是把所给的字符串分割，分割后的所有子串都必须是回文串，如果存在不是回文串的子串那就不满足条件。所以我们有两个问题需要解决：

1. 如何分割字符串
2. 判断字符串是否为回文串

对于第二个问题还是很好解决的，估计初学语言的入门就有判断是否是回文数这样的例子。那么第一个问题如何解决？

由于题目要求找出字符串的每个字串都是回文串的分割方式，所以每种分割方式都是在整个字符串上进行的，那么字符串的长度就可以作为递归的深度。每递归一次就是分割一次，每次分割都必须分割出一个回文串才能进入下一次分割，那么递归的宽度应该是可以分割的字符串的长度。这是大概的思路，下面看看具体的：

• 递归函数的参数：题目给的字符串，已经分割的字符串长度（应为每次递归都要分割一次，但分割的字符串不能包含前面的子串）
• 递归函数的返回条件：当已经分割的字符串长度等于整个字符串长度时就需要返回，因为此时已经没有可以分割的了。由于每次进入下一次递归都需要分割出一个回文串，那么此时证明所有子串都时回文串了，可以将其放入数组中
• 递归函数的功能：功能其实已经讲了很多次了，就是分割字符串。从还可以分割的子串上遍历判断是否为回文串，如果是，则放入数组进入递归。否则继续遍历。

也许讲的有点不好理解，但是看了代码估计就懂了。

👉动态规划

动态规划的方法感觉和递归差不多，只是用了动态规划的思想把每种子串是否为回文串进行标记，然后进入递归逐个把是回文串的子串放入数组中。

动态规划的思想：每个子串都可以由一个中心字母逐个加上字母变成，也就是说，可以先标记一个字母，然后再逐个算上这个字母的左右侧的字母，判断是否为回文串，进行标记。

当所有的子串都标记好了，就进入和上面一样的递归中，只是上面的递归函数里的判断是否为回文串的代码变成了标记数组是否为 true 。

可以对比一下两种方法的代码，还是很相似的。

代码（C++）

递归

class Solution {
public:
    vector<vector<string>> str;
    vector<string> ch;

    bool ishuiwen(string s) {
        if (s.size() == 1)
            return true;
        int j = s.size();
        for (int i = 0; i < j / 2; ++ i) {
            if (s[i] != s[j - i - 1])
                return false;
        }
        return true;
    }

    void dfs(string s, int n) {
        if (n == s.size()) {
            str.push_back(ch);
            return ;
        }
        string ss;
        for (int i = n; i < s.size(); ++ i) {
            ss += s[i];
            if (ishuiwen(ss)) {
                ch.push_back(ss);
                dfs(s, i + 1);
                ch.pop_back();
            }
        }
    }

    vector<vector<string>> partition(string s) {
        dfs(s, 0);
        return str;
    }
};

动态规划

class Solution {
private:
    vector<vector<int>> f;
    vector<vector<string>> ret;
    vector<string> ans;
    int n;

public:
    void dfs(const string& s, int i) {
        if (i == n) {
            ret.push_back(ans);
            return;
        }
        for (int j = i; j < n; ++j) {
            if (f[i][j]) {
                ans.push_back(s.substr(i, j - i + 1));
                dfs(s, j + 1);
                ans.pop_back();
            }
        }
    }

    vector<vector<string>> partition(string s) {
        n = s.size();
        f.assign(n, vector<int>(n, true));

        for (int i = n - 1; i >= 0; --i) {
            for (int j = i + 1; j < n; ++j) {
                f[i][j] = (s[i] == s[j]) && f[i + 1][j - 1];
            }
        }

        dfs(s, 0);
        return ret;
    }
};

总结

这题如果只看代码可以说真的不难，但是自己想可能不太容易。但这题作为中等题是完全够了的，把递归回溯掌握到一定程度，这题应该是很简单的，甚至是秒出思路。动态规划的思路确实很难想到，这种情况下能想到动态规划真的很厉害。