力扣第五题（最长回文子串）详解

这个题目，常用到的方法应该为动态规划，整体的思想为先假设回文字符串的长度为L（先假设其初始值为2），然后确定字符串的左边界，以此来得到回文字符串的右边界（即字符串的长度加上假设的回文字符串的左边界），进而一步步递归，判断是否为回文字符串，如果是，则假设的回文字符串长度L加一，如果不是则退出，同时记录下回文字符串的长度和起始下标。代码如下：

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        if(n < 2)return s;//判断初始字符串的长度需要大于1
        int maxLen = 1;//记录最长回文字符串的长度
        int begin = 0;//记录最长回文字符串的左下标
        vector<vector<int>> dp(n,vector<int>(n));
        for(int i = 0;i < n;i++){
            dp[i][i] = true;//初始化所有的字符串长度为1的都是回文字符串
        }
        for(int L = 2;L <= n;L++){ //初始化化回文字符串的长度为2
            for(int i = 0;i < n;i++){
                int j = L + i - 1;//回文字符串的右下标
                if(j >= n) break;//如果右下标大于字符串的长度，证明越界
                if(s[i] != s[j])dp[i][j] = false;
                else{
                    if(j - i < 3)dp[i][j] = true;//如果字符串长度小于3，将赋值为回文字符串
                    else dp[i][j] = dp[i + 1][j - 1];//如果长度大于3，递归
                }
                if(dp[i][j] && j - i + 1 > maxLen){//如果是回文字符串，且长度大于maxlen
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substr(begin,maxLen);//从原字符串中截取
    }
};

该方法的时间复杂度和空间复杂度都比较高，因为递归需要一定的时间复杂度，储存回文字符串需要一定的空间复杂度。

下面介绍中心扩展算法，算法的思想为枚举每一种可能的回文字符串中心，再从中心向外扩展，当扩展的两边不相等时，即可记为一个回文字符串，以此来取得回文字符串的最大值。代码如下：

class Solution {
public:
              //从回文字符串的中心向外扩展
    pair<int,int>expandAroundCenter(const 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 start = 0,end = 0;
       for(int i = 0;i < s.size();++i){//枚举回文字符串的中心
           auto [left1,right1] = expandAroundCenter(s,i,i);//判断形如abcbc型回文字符串
           auto [left2,right2] = expandAroundCenter(s,i,i+1);//判断形如abccbc型回文字符串
           if(right1 - left1 > end - start){
               start = left1;
               end = right1;
           }
           if(right2 - left2 > end - start){
               start = left2;
               end = right2;
           }
       }
       return s.substr(start,end - start + 1);
    }
};

该算法的空间复杂度都有很大的提升为O(1)，时间复杂度相较于动态规划好一点。