leetcode 131. Palindrome Partitioning 、132. Palindrome Partitioning II

131. Palindrome Partitioning

一个字符串，通过不同的切分找到所有切分后的子字符串都是回文的可能性

substr使用的是坐标值，不使用.begin()、.end()这种迭代器

使用dfs，类似于subsets的题，每次判断要不要加入这个数

start每次是起始的位置，判断当前位置到起始位置是不是回文

class Solution {
public:
    vector<vector<string>> partition(string s) {
        vector<vector<string> > result;
        if(s.empty())
            return result;
        vector<string> res;
        int start = ;
        partition(s,result,res,start);
        return result;
    }
    void partition(string s,vector<vector<string>>& result,vector<string>& res,int start){
        if(start == s.size()){
            result.push_back(res);
            return;
        }
        for(int i = start;i < s.size();i++){
            if(!ispalindrome(s,start,i))
                continue;
            res.push_back(s.substr(start,i - start + ));
            partition(s,result,res,i+);
            res.pop_back();
        }
    }

    bool ispalindrome(string s,int start,int end){
        while(start < end){
            if(s[start++] != s[end--])
                return false;
        }
        return true;
    }
};

132. Palindrome Partitioning II

切分字符串，找到最小切分次数让所有的子字符串都是回文

这种方法是否回文和dp一起做了。dp[i]表示当前位置最小的切分次数。

每次先初始化先初始化为要切分i次，然后从前往后找，找到符合的然后更新最小值

class Solution {
public:
    int minCut(string s) {
        int n = s.size();
        vector<int> dp(n);
        vector<vector<bool> > flag(n,vector<bool>(n));
        for(int i = ;i < n;i++){
            dp[i] = i;
            for(int j = ;j <= i;j++){
                if(s[i] == s[j] && (i - j <  ||flag[i-][j+])){
                    flag[i][j] = true;
                    dp[i] = j ==  ?  :min(dp[i],dp[j-] + );
                }
            }
        }
        return dp[n-];
    }
};

老方法，这种方法是把所有子串的回文串先存储起来，然后再进行dp

class Solution {
public:
    int minCut(string s) {
        int length = s.length();
        if(length <= )
            return ;
        vector<vector<bool>> flag(length+,vector<bool>(length+));
        for(int i = ;i <= length;i++){
            flag[i][i] = true;
            if(i < length){
                if(s[i-] == s[i])
                    flag[i][i+] = true;
                else
                    flag[i][i+] = false;
            }
        }
        for(int j = ;j <= length-;j++){
            for(int k = ;k <= length-j-;k++){
                if(s[k-] == s[k+j] && flag[k+][k+j] == true)
                    flag[k][k+j+] = true;
                else
                    flag[k][k+j+] = false;
            }
        }
        vector<int> result(length+);
        result[] = -;
        for(int i = ;i <= length;i++){
            result[i] = i-;
            for(int j = i-;j >= ;j--){
                if(flag[j+][i] == true){
                    if(result[j] +  < result[i])
                        result[i] = result[j] + ;
                }
            }
        }
        return result[length];
    }
};