LeetCode131. 分割回文串（区间dp + 回溯）

131.分割回文串

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

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

示例 1：

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

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

来源：力扣（LeetCode）

读完题目发现是个分割子串的题目，这种题目就用回溯解决即可。
回溯代码如下

    void dfs(int l, string& s, vector<string>& res, vector<vector<string>>& ans){
        if(l == n){
            ans.push_back(res);
            return;
        }
        for(int i=l; i<n; i++){ 
            if(!OK) continue; // 区间 l-i 无回文串
            res.push_back(s.substr(l, (i-l)+1));
            dfs(i+1, s, res, ans);
            res.pop_back();
        }
    }

这个题目比较特殊，这里的子串要求是回文串。所以我们在搜索的时候，一定要该子串满足回文串的性质才可以。回文串的性质比较特殊可以用dp来事先记录所有子串是否满足回文串。
dp我们设置dp[i][j] 表示 s[i] – s[j] 这个子串是否满足回文串。
这样的话，dp[i][i] 即 s[i] – s[i] 一定为 true。即dp的初始状态。
转移方程的话，如果串 x——y 是不是回文串，需要满足两个条件，首先 x 要等于 y。 比如 a——a这样。其次是 x和y之间的 ** 也是回文串，比如abba这样。像acda这样就不行。所以我们可以写出转移方程。

dp[i][j] = dp[i+1][j-1] && (s[i] == s[j]);

再考虑一下特殊情况， 比如 aa这样的 当 j == i+ 1时， i+1 就 大于 j-1了。这时dp[i+1][j-1]就没有用了，所以只要 s[i] == s[j] 即可。
dp部分代码如下：

        // dp 初始化
        for(int i=0; i<n; i++){
            for(int j=0; j<n; j++){
                dp[i][j] = false;
            }
            dp[i][i] = true;
        }
        
        // 统计每个区间（i, j） 是否为回文串
        for(int i=n-2; i>=0; i--){
            for(int j=i+1; j<n; j++){
                if(j==(i+1)){       // 特殊情况，即（i+1） > (j-1) 特殊处理
                    dp[i][j] = (s[i]==s[j]);
                }else{
                    dp[i][j] = (dp[i+1][j-1] && (s[i]==s[j])); // 普通状态转移方程
                }
            }
        }

完整代码如下

class Solution {
public:
    int n = 0;
    vector<vector<bool>> dp;

    vector<vector<string>> partition(string s) {
        vector<string> res;
        vector<vector<string>> ans;
        n = s.size();
        dp.resize(n, vector<bool>(n));

        // dp 初始化
        for(int i=0; i<n; i++){
            for(int j=0; j<n; j++){
                dp[i][j] = false;
            }
            dp[i][i] = true;
        }
        
        // 统计每个区间（i, j） 是否为回文串
        for(int i=n-2; i>=0; i--){
            for(int j=i+1; j<n; j++){
                if(j==(i+1)){       // 特殊情况，即（i+1） > (j-1) 特殊处理
                    dp[i][j] = (s[i]==s[j]);
                }else{
                    dp[i][j] = (dp[i+1][j-1] && (s[i]==s[j])); // 普通状态转移方程
                }
            }
        }
        dfs(0, s, res, ans);

        return ans;
    }


    void dfs(int l, string& s, vector<string>& res, vector<vector<string>>& ans){
        if(l == n){
            ans.push_back(res);
            return;
        }
        for(int i=l; i<n; i++){ // 分别搜索 区间 l -- i;
            if(!dp[l][i]) continue; // 区间 l-i 无回文串
            res.push_back(s.substr(l, (i-l)+1));
            dfs(i+1, s, res, ans);
            res.pop_back();
        }
    }
};