Palindrome Partitioning

Given a string s, partition s such that every substring of the partition is a palindrome.

Return all possible palindrome partitioning of s.

For example, given s = "aab",

Return

[
  ["aa","b"],
  ["a","a","b"]
]

解法一:

第一个方法用递归实现，下面是一个递归式partition(s[0,s.size()])=∑(partition(s[0,i])+s[i:s.size()])，其中partition(s[i,j])表示字符串s的第i个字符到第j个字符的回文划分，s[i:j]表示字符串s的第i个字符到第j个字符。但要注意的是s[i:s.size()]本身必须是一个回文字符串，否则的话就不需要对它求和。其实这个递归式很容易理解，就是将后面的回文串进行枚举，然后将大问题分解成小问题来进行递归。

复杂度分析，假设处于最极端的情况，任意子串都是回文串，那么复杂度为N(n)=∑（N(n-i)+i)=O(N^3),这样的复杂度其实是挺高的，如果字符串长度很大的时候，该方法会超时的。但这题的测试样例没那么变态，所以过了，代码如下

解法二：

其实从解法一，大家应该可以想到用递推式，进行递推，那么复杂度就是O（N^2）了，这里就不再实现了。

class Solution {
public:
    
    vector<vector<string>> dfs(string s,int index)
    {
         vector<vector<string>> res;
        
        if(index==0)
        {
            res.push_back(vector<string> ());
            return res;
        }
        
        
        for(int i=1;i<=index;++i)
        {
            vector<vector<string>> temp;
            if(p[index-i][index-1])
            {
                
                temp=dfs(s,index-i);
                for(int j=0;j<temp.size();++j)
                {
                    temp[j].push_back(s.substr(index-i,i));
                    res.push_back(temp[j]);
                }
            }
            
            
            
        }
        
        return res;
    }
    
    
    
    vector<vector<string>> partition(string s) {
        for(int i=0;i<s.size();++i)
            for(int j=0;j<s.size();++j)p[i][j]=false;
        
        for(int i=0;i<s.size();++i)
            for(int j=0;j<=s.size();++j)
            {
                if(i-j>=0&&i+j<s.size()&&s[i-j]==s[i+j])
                {
                    p[i-j][i+j]=true;
                  
                }
                else break;
            }
        
        for(int i=0;i<s.size();++i)
            for(int j=0;j<=s.size();++j)
            {
                if(i-j-1>=0&&i+j<s.size()&&s[i-j-1]==s[i+j])
                {
                    p[i-j-1][i+j]=true;
                    
                }
                else break;
            }
        
       
        vector<vector<string>> res=dfs(s,s.size());
        
        
        return res;
        
        
    }
    
     bool p[1000][1000];
    
};