在O(n)时间判断回文的解法。

class Solution {
public:
    vector<vector<string>> res;
    vector<vector<string>> partition(string s) {
        vector<string> path;
        dfs(s,0,path);
        return res;
    }

    void dfs(string s, int index, vector<string> &path){
        if(index>=s.size()){
            res.push_back(path);
            return;
        }
        for(int i=index;i<s.size();i++){
            if(check(s.substr(index,i-index+1))){
                path.push_back(s.substr(index,i-index+1));
                dfs(s,i+1,path);
                path.pop_back();
            }
        }
    }

    bool check(string s){
        int left = 0, right = s.size()-1;
        while(left<right){
            if(s[left++]!=s[right--]) return false;
        }
        return true;
    }
};

可以通过dp预处理，在O(1)时间判断回文

class Solution {
public:
    bool check(string& s, int left, int right){
        while(left<right){
            if(s[left++]!=s[right--]) return false;
        }
        return true;
    }

    int minCut(string s) {
        int n = s.size();
        vector<int> dp(n+1,n+1);
        dp[0] = 0;
        for(int i=1;i<=n;i++){
            for(int j=0;j<i;j++){
                if(check(s,j,i-1)){
                    dp[i] = min(dp[i],dp[j]+1);
                }
            }
        }
        return dp[n]-1;
    }
};

用dp求解字符字串是否是回文的时候，先枚举长度，在做一些判断

class Solution {
public:
    int minCut(string s) {
        int n = s.size();
        vector<vector<bool>> f(n,vector<bool>(n));
        for(int l=1;l<=n;l++){
            for(int i=0;i<n;i++){
                int j = i+l-1;
                if(j<n){
                    if(i==j) f[i][j]=true;
                    else if(l==2&&s[i]==s[j]){
                        f[i][j] = true;
                    }else if(i+1<n&&s[i]==s[j]&&f[i+1][j-1]){
                        f[i][j] = true;
                    }
                }
            }
        }
        vector<int> dp(n+1,n+1);
        dp[0] = 0;
        for(int i=1;i<=n;i++){
            for(int j=0;j<i;j++){
                if(f[j][i-1]){
                    dp[i] = min(dp[i],dp[j]+1);
                }
            }
        }
        return dp[n]-1;
    }
};