2021-8-3 131. 分割回文串（中心拓展+动态规划+回溯）

注：

题目：
给你一个字符串 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] 位置的所有字符已经被分割成若干个回文串，并且分割结果被放入了答案数组 ans 中，那么我们就需要枚举下一个回文串的右边界 j，使得 s[i…j]是一个回文串。

因此，我们可以从 i 开始，从小到大依次枚举 j ，并判断这一段是否是回文。对于当前枚举的 j 值，使用动态规划即可:

设f(i,j) 表示 s[i…j] 是否为回文串，那么有状态转移方程：

f(i,j)=True，i=j
f(i,j)=True，j-i=1∧s[i]=s[j]
f(i,j)=True，j-i>1∧s[i]=s[j]∧f(i+1,j-1)
​
其中 ∧ 表示逻辑与运算，即 s[i…j] 为回文串，当且仅当其长度为 1（i=j），首尾字符相同且长度为2，或者首尾字符相同且 s[i+1…j-1], 为回文串。

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

复杂度分析
时间复杂度：O(n2ⁿ)，其中 n 是字符串 s 的长度。在最坏情况下，s 包含 n 个完全相同的字符，因此它的任意一种划分方法都满足要求。而长度为 n 的字符串的划分方案数为 2^n-1=O(2ⁿ)，每一种划分方法需要 O(n) 的时间求出对应的划分结果并放入答案，因此总时间复杂度为 O(n2ⁿ)。尽管动态规划预处理需要 O(n²)的时间，但在渐进意义下小于 O(n*2ⁿ)，因此可以忽略。

空间复杂度：O(n²)，这里不计算返回答案占用的空间。数组 dp 需要使用的空间为 O(n²)，而在回溯的过程中，我们需要使用 O(n) 的栈空间以及 O(n) 的用来存储当前字符串分割方法的空间。由于 O(n) 在渐进意义下小于 O(n²)，因此空间复杂度为 O(n²)。

class Solution {
public:
    vector<vector<string>> result;
    vector<string> chars;
    int size=0;
    void dfs(int index,string& s,vector<vector<bool>> dp){
        if(index==size){
            result.push_back(chars);
            return ;
        }
        for(int i=index;i<size;i++){
            if(dp[index][i]==true){
                chars.push_back(s.substr(index,i-index+1));
                dfs(i+1,s,dp);
                chars.pop_back();
            }
        }
    }
    vector<vector<string>> partition(string s) {
        size=s.size();
        vector<vector<bool>> dp(size,vector<bool>(size));
        //对角线初始化为true(即只有一个元素的情况)
        for(int i=0;i<size;i++){
            dp[i][i]=true;
        }
        //状态转移方程：
        //如果right-left<2,则只需要比较是s[right]与s[left]
        //如果right-left>=2，在 s[i] == s[j] 的时候，dp[i][j] 参考 dp[i + 1][j - 1]
        for(int right=0;right<size;right++){
            for(int left=0;left<=right;left++){
                dp[left][right]=((s[left]==s[right])&&(right-left<2||(dp[left+1][right-1])));
            }
        }
        dfs(0,s,dp);
        return result;
    }
};