leetcode------分割回文串

解题思路：

这个简单的方法就是，用回溯，一个个的遍历。每一次从下一个遍历之前，都需要判断当前子串是不是回文串，这里的回文串检查可以用动态规划储存起来，加快速度：

dp[i][j]是不是回文串，判断s[i] == s[j] && ( j - i < 3 || dp[i+1][j-1])

class Solution {
public:

    bool IsHUIWEN(string s)
    {
        int l = 0;
        int r = s.size()-1;
        while(l sub,
                    vector> &res,
                    vector> &dp)
    {
        if(cur>=s.size())
        {
            res.push_back(sub);
            return ;
        }
        for(int i = cur;i> partition(string s) {
        vector> res ;
        vector> dp(s.size(),vector(s.size()));
        for(int i = 0;i temp;
        backthrough(s,0,temp,res,dp);
        
        return res;
    }

};

下面统计最小的分割回文串

如果沿着上一题的做法，就是将每一次分隔到最后将分割的次数记录下来，比较大小；但这样做还是重复记录了很多次，会超时，从而就再需要辅助空间来降低复杂度；

我们可以从前往后遍历,即自底向上，用dp[i] 记录前i个字符是回文串并且分割次数是最小的，如果j是从中的一次分割，那么dp[j]表示前j个字符分割回文最小的次数，从0开始遍历，如果i到j是回文的，

那么dp[j]=min(dp[j],dp[i]+1);意思就是说只要从i分割一刀，那么只要前i个字符串回文分割次数最小dp[i]再加上1，就表示从i分割，此时dp[j]最小。

class Solution {
public:

    bool IsHUIWEN(string s)
    {
        int l = 0;
        int r = s.size()-1;
        while(l> &dp)
    {
        if(cur>=s.size())
        {
            res=min(res,num);
            return ;
        }
        for(int i = cur;i> &dp,vector &f)
    {
        int n = s.size();
        for(int i = 1; i <= n; i++){
            //表示刚开始每一处都分割一次
            f[i] = i;
            for(int j = 0; j < i; j++){
                if(s[j]==s[i-1] && (i-1-j < 3 || dp[j+1][i-2])){
                    dp[j][i-1]=1;
                    f[i] = min(f[j] + 1, f[i]);
                }
            }
        }
    }

    int minCut(string s) {
        int res = 999;
        vector> dp(s.size(),vector(s.size()));
        for(int i = 0;i f(s.size()+1);
        f[0]=-1;
        //f[0]是-1很重要，表示从0开始到j就是回文的，那么f[0]+1 = 0表示不需要进行分割。
        cut(s,dp,f);
        
        return f[s.size()];;
    }
};