11 -分割回文串&回文子串&最长回文子串

1. 分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文串 。返回 s 所有可能的分割方案。回文串是正着读和反着读都一样的字符串。

回溯法

class Solution {
public:
    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return result;
    }
private:
    void backtracking(const string& s, int startIndex){
        if (startIndex >= s.size()){
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < s.size(); ++i){
            if(isHuiWen(s, startIndex, i)){
                path.push_back(s.substr(startIndex, i - startIndex + 1));
            }
            else{
                continue;
            }
            backtracking(s, i + 1);
            path.pop_back();
        }
    }
    //双指针判断是否是回文
    bool isHuiWen(const string& s, int start, int end){
        for(int i = start,j = end; i < j; ++i, --j){
            if(s[i] != s[j]){
                return false;
            }
        }
        return true;
    }

    vector<vector<string>> result;
    vector<string> path;
};

2. 分割回文串II

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文。返回符合要求的最少分割次数。

本题用回溯法会超时，用动态规划来解决。
先使用一个二维数组确定整个字符串的回文情况，然后再通过递推公式得到最小分割次数。如果要对长度为[0, i]的子串进行分割，分割点为j。那么如果分割后，区间[j + 1, i]是回文子串，那么dp[i] 就等于 dp[j] + 1。递推公式为：dp[i] = min(dp[i], dp[j] + 1);

class Solution {
public:
    int minCut(string s) {
    	//先用一个二维数组来保存整个字符串的回文情况
        vector<vector<int>> hw(s.size(), vector<int>(s.size(), 0));
        for(int i = s.size() - 1; i >= 0; --i){
            for(int j = i; j < s.size(); ++j){
                if(s[i] == s[j] && (j - i <= 1 || hw[i + 1][j - 1])){
                    hw[i][j] = 1;
                }
            }
        }
        //dp[i]：范围是[0, i]的回文子串，最少分割次数是dp[i]。
        vector<int> dp(s.size()); 
        //dp[i]的最大值就是i，也就是把每个字符分割出来。
        for(int i = 0; i < s.size(); ++i) dp[i] = i;
        //j是在[0，i]之间，所以遍历i的for循环一定在外层，这里遍历j的for循环在内层
        //才能通过计算过的dp[j]数值推导出dp[i]。
        for(int i = 0; i < s.size(); ++i){
            if(hw[0][i]){
                dp[i] = 0;
                continue;
            }
            for(int j = 0; j < i; ++j){
                if(hw[j + 1][i]) dp[i] = min(dp[j] + 1, dp[i]);
            }
        }
        return dp[s.size() - 1];
    }
};

3. 回文子串

给你一个字符串 s ，请你统计并返回这个字符串中回文子串的数目。子字符串是字符串中的由连续字符组成的一个序列。具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

• 动态规划

class Solution {
public:
    int countSubstrings(string s){
        int result = 0;
        vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
        //从下到上，从左到右遍历，这样可以保证dp[i + 1][j - 1]都是经过计算的
        for(int i = s.size() - 1; i >= 0; --i){
        	//j一定是大于等于i的，那么在填充dp[i][j]的时候一定是只填充右上半部分。
            for(int j = i; j < s.size(); ++j){
                if(s[i] == s[j] && (j - i <= 1 || dp[i + 1][j - 1])){
                    dp[i][j] = 1;
                    result++;
                }
            }
        }
        return result;
    }
};

• 双指针法
  找中心然后想两边扩散看是不是对称的，一个元素可以作为中心点，两个元素也可以作为中心点，三个元素也可以作为中心点，其实三个元素就可以由一个元素左右添加元素得到，四个元素也同理。所以我们在计算的时候，要注意一个元素为中心点和两个元素为中心点的情况。

class Solution {
public:
    int result = 0;
    int countSubstrings(string s) {
        for(int i = 0; i < s.size(); ++i){
            extend(s, i, i);
            extend(s, i, i + 1);
        }
        return result;
    }
    void extend(string s, int i, int j){
        while(i >= 0 && j < s.size() && s[i] == s[j]){
            result++;
            i--;
            j++;
        }
    }
};

4. 最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

和回文子串的思路一样。

• 动态规划

class Solution {
public:
    string longestPalindrome(string s) {
        vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
        int l = 0;
        int r = 0;
        int maxl = 0;
        for(int i = s.size() - 1; i >= 0; --i){
            for(int j = i; j < s.size(); ++j){
                if(s[i] == s[j] && (j - i <= 1 || dp[i + 1][j - 1])){
                    dp[i][j] = 1;
                }
                if(dp[i][j] && maxl < j - i + 1){
                    maxl = j - i + 1;
                    l = i;
                    r = j;
                }
            }
        }
        return s.substr(l, r - l + 1);
    }
};

• 双指针法

class Solution {
public:
    int l = 0;
    int r = 0;
    int maxl = 0;
    string longestPalindrome(string s){
        for(int i = 0; i < s.size(); ++i){
            extend(s, i, i);
            extend(s, i, i + 1);
        }
        return s.substr(l, maxl);
    }
    void extend(string s, int i, int j){
        while(i >= 0 && j < s.size() && s[i] == s[j]){
            if(maxl < j - i + 1){
                maxl = j - i + 1;
                l = i;
                r = j;
            }
            --i;
            ++j;
        }
    }
};