分割回文串-力扣

对于字符串abcdef：
组合问题：选取一个a之后，在bcdef中再去选取第二个，选取b之后在cdef中再选取第三个…。
切割问题：切割一个a之后，在bcdef中再去切割第二段，切割b之后在cdef中再切割第三段…。

• 因此切割问题也可以像组合问题一样，抽象成一个树形结构，只不过横向遍历，定义了起始位置startIndex，那么 [startIndex, i] 就是要截取的子串。而不是像组合问题，只需对 i 的元素进行操作。
• 同时需要一个函数来判断输入的字串是否是回文串。
• 当第一次切割切割到一个回文串后，就从此时切割位置的下一个元素开始，准备第二次切割
• 那么中止条件就显而易见了，当传入的起始位置，超过字符串的位置，说明已经将给定的字符串，切割成了一组回文串，将给定的数组，添加到返回数组即可。

class Solution {
private:
    vector<vector<string>> result;
    vector<string> vec;
public:
    bool isPalindromic(string& s, int left, int right){
        while(left <= right){
            if(s[left] != s[right]){
                return false;    
            }
            left++;
            right--;
        }
        return true;
    }
    void backtracking(string& s, int startIndex){
        if(startIndex >= s.size()){
            result.push_back(vec);
            return;
        }
        for(int i = startIndex; i < s.size(); i++){
            if(isPalindromic(s, startIndex, i)){
                string str = s.substr(startIndex, i - startIndex + 1);
                vec.push_back(str);
            }else{
                continue;
            }
            backtracking(s, i + 1);
            vec.pop_back();
        }
    }
    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return result;
    }
};

本题优化的点有 判断回文串处，会出现重复的判断，可以利用动态规划的思想，将给定字符串的字串的回文情况，提前计算出来保存到数组中，在后续直接使用即可。

    void computePalindrome(const string& s) {
        // isPalindrome[i][j] 代表 s[i:j](双边包括)是否是回文字串 
        isPalindrome.resize(s.size(), vector<bool>(s.size(), false)); // 根据字符串s, 刷新布尔矩阵的大小
        for (int i = s.size() - 1; i >= 0; i--) { 
            // 需要倒序计算, 保证在i行时, i+1行已经计算好了
            for (int j = i; j < s.size(); j++) {
                if (j == i) {isPalindrome[i][j] = true;}
                else if (j - i == 1) {isPalindrome[i][j] = (s[i] == s[j]);}
                else {isPalindrome[i][j] = (s[i] == s[j] && isPalindrome[i+1][j-1]);}
            }
        }
    }