[LeetCode]Palindromic String 回文串系列(三道题)

这里是LeeTioN的博客

在LeetCode做了三道经典的回文串的题目，分别是
5. Longest Palindromic Substring 最长回文子串
516. Longest Palindromic Subsequence 最长回文子序列
647. Palindromic Substrings 回文子串个数

最长回文子串

描述：给定一个字符串，找出它里面最长的回文子串，例如”cbbd”的最长回文子串为”bb”
思路：最明显的方法是按照顺序去遍历，每一次循环将array[i]作为中心，然后扩散到两边的字符，判断两边的字符是否相等，如果相等，则继续扩散，否则访问下一个字符，这里注意也要考虑不要超过字符串的边界。这种方法可以称作中心扩散法。
遍历的时候还要分两种情况讨论——一是最长回文子串的长度为奇数，二是它的长度为偶数。

class Solution {
public:
    string longestPalindrome(string s) {
        int max = 0;
        int left, right, i, j, count, start, end;
        for(i = 0; i < s.size(); i++){//长度为奇数的情况
            for(j = 0; i - j >= 0 && i + j < s.size(); j++ ){//注意不要超过边界
                if(s[i-j] != s[i+j]){
                    break;
                }
                count = 2 * j + 1;
                left = i - j;
                right = i + j;
            }
            if(max < count){
                max = count;
                start = left;//保存最长回文子串的起始点和终点
                end = right;
            }
        }
        for(i = 0; i < s.size(); i++){//长度为偶数的情况
            for(j = 0; i - j >= 0 && i + j + 1 < s.size(); j++ ){
                if(s[i-j] != s[i+j+1]){
                    break;
                }
                count = 2 * j + 2;
                left = i - j;
                right = i + j + 1;
            }
            if(max < count){
                max = count;
                start = left;
                end = right;
            }
        }
        return s.substr(start, end - start + 1);
    }
};

最长回文子序列

描述：相比于上一题，这里则没有对串的连续性有要求，只要序列是给定串的子集，并满足回文性质，就可以当做最长回文子序列。
思路：这里我们需要一个二维的状态矩阵来记录信息，dp[i][j]表示第i个字符到第j个字符满足的最长回文子串的长度。很明显，我们需要求的是dp[0][length]的长度。
细节：我们虽然申请了一个length*length的矩阵，但是我们只需要用到右上三角形的空间，因为dp[i][j]和dp[j][i]表示的是一个意思。还有一点就是我们在求这个状态矩阵的顺序时，是按对角线一条一条往右上方计算的。计算顺序如下图所示。

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int n = s.size();
        vector<vector<int>> dp(n, vector<int>(n, 0));
        for(int i = 0; i < n; i++){
            dp[i][i] = 1;
        }
        for(int len = 1; len < n; len++){
            for(int i = 0; i < n - len; i++){
                int j = i + len;
                if(s[i] == s[j]){
                    dp[i][j] = dp[i+1][j-1] + 2;
                }
                else{
                    dp[i][j] = max(dp[i+1][j], dp[i][j-1]);
                }
            }
        }
        return dp[0][n-1];
    }
};

回文子串个数

思路：跟上一题的思路基本一致，按照矩阵的斜线，从左下往右上更新状态矩阵。但是这里是子串，所以就是连续的。我们的状态矩阵则是一个布尔型的，dp[i][j]记录的是从i到j是否为一个回文串。最后更新完整个矩阵后，再重新遍历一遍，记录个数。

class Solution {
public:
    int countSubstrings(string s) {
        int n = s.size();
        int count = 0;
        vector<vector<bool>> dp(n, vector<bool>(n, false));
        for(int i = 0; i < n; i++){
            dp[i][i] = true;
        }
        for(int len = 1; len < n; len++){
            for(int i = 0; i < n - len; i++){
                int j = i + len;//按左上到右下的斜线往右上方遍历
                if(s[i] != s[j]){
                    dp[i][j] = false;
                }
                else{
                    dp[i][j] = isPalindromic(dp, i+1, j-1);
                }
            }
        }
        for(int i = 0; i < n; i++){
            for(int j = i; j < n; j++){
                if(dp[i][j]){
                    count++;
                }
            }
        }
        return count;
    }
    bool isPalindromic(vector<vector<bool>>& dp, int i, int j){
        if(i >= j){
            return true;//i和j之间不存在其他字符
        }
        else{
            return dp[i][j];
        }
    }
};