＜leetcode＞5.最长回文子串——动态规划、中心扩散法

给你一个字符串 s，找到 s 中最长的回文子串。
解答一：暴力解法

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.size() < 2){
            return s;
        }
        int begin = 0;
        int maxL = 1;
        int n = s.size();
        for(int i = 0; i < n - 1; i++){
            for(int j = i + 1; j < n; j++){
                if(judgePalindrome(s,i,j) && (j - i + 1) > maxL){
                    maxL = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substr(begin, maxL);
    }

    bool judgePalindrome(string s, int i, int j){
        while(i < j){
            if(s[i] != s[j]){
            return false;
            }
            i++;
            j--;
        }
        return true;
    }
};

测试代码正确，但是超出时间范围，其他语言可以尝试这种解法，总的来说如果用到两层循环，C++一般都会超出时间限制。

解答二：动态规划
一般说如果当前问题的解答和上一状态问题的解答有关则可以使用动态规划。

class Solution {
public:
    string longestPalindrome(string s) {
       int begin = 0;
       int maxL = 1;
       int n = s.size();
       if(s.size() < 2) return s;
       vector<vector<bool>> dq(n, vector<bool>(n));
       for(int i = 0; i < n ;i++){//初始值
           dq[i][i] = true;
       }
       for(int j = 1; j < n; j++){
           for(int i = 0; i < j; i++){
               if(s[i] != s[j]){
                   dq[i][j] =  false;
               }else if(j - i < 3){//边界
                   dq[i][j] = true;
               }else{
                   dq[i][j] = dq[i + 1][j - 1];//状态转移方程
               }
               if(dq[i][j] && j - i + 1 > maxL){
                   maxL = j - i + 1;
                   begin = i;
               }
           }
       }
       return s.substr(begin, maxL);
    }
};

解答三：中心扩散法

class Solution {
public:
    pair<int, int> expandAroundCenter(string& s, int left, int right){
        while(left >= 0 && right < s.size() && s[left] == s[right]){
            left--;
            right++;
        }
        return {left + 1, right - 1};
    }

    string longestPalindrome(string s) {
       int begin = 0;
       int maxL = 1;
       int n = s.size();
       if(s.size() < 2) return s;
       for(int i = 0; i < n-1; i++){
           auto [left1, right1] = expandAroundCenter(s,i,i);
           auto [left2, right2] = expandAroundCenter(s,i,i+1);
           if(right1 - left1 + 1 > maxL){
               maxL = right1 - left1 + 1;
               begin = left1;
           }
           if(right2 - left2 + 1 > maxL){
               maxL = right2 - left2 + 1;
               begin = left2;
           }
       }
       return s.substr(begin, maxL);
    }
};

枚举所有中心（奇数回文子串的中心为一个数，偶数回文子串的中心为两个数），然后进行扩散，一直到扩散不了为止，返回左右边界。这个方法较动态规划可以大大减少时间和空间复杂度，非常推荐。