问题

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

示例:

输入: “aab”
输出:
[
[“aa”,“b”],
[“a”,“a”,“b”]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-partitioning
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

一、官方是如何又一次站在大气层的？

我的思路和官方一样，也想过要用递归、搜索，但是写代码能力不行，一直有bug。
在深入思索了官方的DFS+动态规划的思路之后，我觉得这是一道好题，有很多知识点可以学习。

官方思路：

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

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

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

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

细节

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

​

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

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

官方代码如下：

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;//DFS的终止条件
        }
        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();
                //这个pop一开始很困惑，后来明白，这是把当前找的i到j的字符串去掉，
               //保证了j可以一直往后遍历，真的是想到了就是想到了，递归真的神了
            }
        }
    }

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

        for (int i = n-1; i >=0; --i) {//必须从n-1开始
            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;
    }


};

为了更深刻的了解DFS的思想内涵，我找到了我之前写的一个图的DFS的代码，加深一下印象

代码如下：

/*rooms为一个二维数组，储存图的顶点和边信息，
rooms[i]里面的数字都是与i相邻的顶点编号
*/
void travel(vector<vector<int>>& rooms)
    { 
        int len=rooms.size();
        for(int i=0;i<len;i++)
        {
            visited.push_back(false);
        }//初始化visited数组，均标记为为访问
        for(int i=0;i<len;i++)//防止不是连通图
        {
            if(visited[i]==false)
            {
                DFS(i,rooms);
            }
        }
    }
  
     void DFS(int i,vector<vector<int>>&rooms){
     visited[i]=true;//标记已经访问过
     int l=rooms[i].size();//顶点i连接的其它顶点
     cout<<i;//输出当前被访问的节点
        for(int j=0;j<l;j++)
        {
            if(visited[rooms[i][j]]==false)
              DFS(rooms[i][j],rooms);
        }
           
    }
    

2、动态规划判断回文子串：需要注意的是，动态规划如果想要知道ij，就必须要知道i+1，j-1，所以填矩阵的顺序一定是从下往上，从左往右，这是典型的动态规划的套路了。

二、我遇到了那些问题

我的失败代码如下：

```cpp
class Solution {
public:
    vector <string> temp;//回文分割子集
    vector<vector<string>> res;
    bool judge=true;
    
    string front,back;
    //判断s是否为回文，是返回0，否则为-1
    int help(string s){
    int n=s.size();
    string back;
    if(n==0) return 0;
    for(int i=0;i<n;i++){
        back.push_back(s[n-1-i]);
    }//将s反着复制一遍,笨办法
    if(s.compare(back)==0){
        return 0;
    }
    else return-1;
    }
    //还是写一个递归函数专门找回文吧
    void hui(int index,string s){
        int copy;//复制尾指针
        for(copy=index;copy<s.size();copy++){//生成回文集终止条件
            front.clear();
            for(i=index;i<copy+1;i++){
                front.push_back(s[i]);
            }//复制部分字符串
            //判断是否为回文
            int i=help(front);
            if(i==0){
            temp.push_back(front);//前面的已经时回文了，后面的同理
            hui(copy+1,string s)
            //头指针后移
               
            }
            else{
                copy--;
            }
    }
    //主函数
    vector<vector<string>> partition(string s) {
    int i;//循环
    int index=0;//角标，s某个回文开头
    int tail;//s某个回文结尾
    int copy;
    int count=s.size();//s的大小
   
    
    
    tail=count;
    if(count==1) {
        temp.push_back(s);
        res.push_back(temp);
        return res;
    }
   //目前不需要 if(count==0) return res;
   //两个指针，枚举方法：一开始的时候，一个固定在开头，另一个从尾端向前移动，发现回文，头指针向后移，尾端重新到最后
    //保证枚举的不重不漏（但是这是有漏的），为指针一个一个移动，每一次都判断
       while(tail!=-1)
       { index=0;
        
           
        }
        if(!temp.empty())
        res.push_back(temp);
        temp.clear();
       }
    return res;
    };
};

怎么说的，改了一个多小时，还是出现失败，我也佛了，感觉没用递归的纯循环就是死亡（大哭）

三、得与失的反思

有时候代码还是要积累和总结的
事后诸葛也很重要，要知道很多事前诸葛就是从事后诸葛过来的。