5. 最长回文子串

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        if(n < 2) return s;
        
        vector<vector<bool>> dp(n, vector<bool>(n)); 
        int maxLen = 1, start = 0;
        for(int i = n-1; i >= 0; i--){
            for(int j = i+1; j < n; j++){
                dp[i][j] = s[i]==s[j] && (j-i<3 || dp[i+1][j-1]);
                int len = j-i+1;
                if(dp[i][j] && len > maxLen){
                    maxLen = len;
                    start = i;
                }
            }
        }
        return s.substr(start, maxLen);
    }
};

时间复杂度：O（n²）

空间复杂度：O（n²）

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        if(n < 2) return s;
        
        vector<bool> dp(n, 0); 
        int maxLen = 1, start = 0;
        for(int i = n-1; i >= 0; i--){
            bool bottomLeft = false, temp;
            for(int j = i+1; j < n; j++){
                temp = dp[j];
                dp[j] = s[i]==s[j] && (j-i<3 || bottomLeft);
                int len = j-i+1;
                if(dp[j] && len > maxLen){
                    maxLen = len;
                    start = i;
                }
                bottomLeft = temp;
            }
        }
        return s.substr(start, maxLen);
    }
};

时间复杂度：O（n²）

空间复杂度：O（n）

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size(), mlen = 0, start = 0;
        for(int i = 0; i < n; i++){
            int len = max(expandAroundCenter(s, i, i), expandAroundCenter(s, i, i+1));
            if(len > mlen){
                mlen = len;
                start = i-(mlen-1)/2;
            }
        }
        return s.substr(start, mlen);
    }
    int expandAroundCenter(string s, int left, int right){
        int l = left, r = right;
        while(l >= 0 && r < s.size() && s[l]==s[r]){
            l--;
            r++;
        }
        return r-l-1;
    }
};

中心扩展法

时间复杂度：O（n²）

空间复杂度：O（1）

 

516. 最长回文子序列

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 i = n-2; i >= 0; i--){
            for(int j = i+1; j < n; j++){
                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];
    }
};

时间复杂度：O（n²）

空间复杂度：O（n²）

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int n = s.size();
        vector<int> dp(n, 0);
        
        // 多开辟一个变量bottemLeft存储左下角的元素，较精简
        for(int i = n-1; i >= 0; i--){
            int bottomLeft = 0, temp;
            dp[i] = 1;
            for(int j = i+1; j < n; j++){
                temp = dp[j];
                if(s[i] == s[j])
                    dp[j] = bottomLeft + 2;
                else
                    dp[j] = max(dp[j-1], dp[j]);
                bottomLeft = temp;
            }
        }
        return dp[n-1];
    }
};

时间复杂度：O（n²）

空间复杂度：O（n）

 

647. 回文子串

class Solution {
public:
    int countSubstrings(string s) {
        int n = s.size(), ans = 0;
        vector<vector<bool>> dp(n, vector<bool>(n));
        for(int j = 1; j < n; j++){
            for(int i = 0; i < j; i++){
                if(s[i] == s[j] && (j-i<3 || dp[i+1][j-1])){
                    dp[i][j] = true;
                    ans++;
                }
            }
        }
        return ans+n;
    }
};

时间复杂度：O（n²）

空间复杂度：O（n²）

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

时间复杂度：O（n²）

空间复杂度：O（n）

class Solution {
public:
    int countSubstrings(string s) {
        int n = s.size(), ans = 0;
        for(int i = 0; i < 2*n-1; i++){
            int left = i / 2, right = left + i % 2;
            while(left >= 0 && right < n && s[left] == s[right]){
                ans++;
                left--;
                right++;
            }
        }
        return ans;
    }
};

中心扩展法

时间复杂度：O（n²）

空间复杂度：O（1）