给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

本文一共说明两重方法：中心扩展算法和动态规划算法

根据官方题解中的提示，有这样一种方法，并给出了Java代码示例

1.中心扩展算法：

事实上，只需使用恒定的空间，我们就可以在 O(n^2)O(n2) 的时间内解决这个问题。

我们观察到回文中心的两侧互为镜像。因此，回文可以从它的中心展开，并且只有 2n - 12n−1 个这样的中心。

你可能会问，为什么会是 2n - 12n−1 个，而不是 nn 个中心？原因在于所含字母数为偶数的回文的中心可以处于两字母之间（例如 \textrm{“abba”}“abba” 的中心在两个 \textrm{‘b’}‘b’ 之间）。

c++也可同样思想:

错误代码

这段代码对大部分测试用例都适用，但是例如这样“ccccc”奇数个字符串的时候会出错

输入: "ccccc"
输出: "cccc"

class Solution {
public:
    string longestPalindrome(string s) {
         int len=s.length();
        string result="";
             int left=-1;           //声明左右游标
             int right=-1;
        if(len==0)
            return result;
        for(int i=0;i<len;i++){
   
            //这里存在字符串判断条件太苛刻了，并不只有这两种情况
            //形如“sssss”子串应该是“sssss"应该走else
            //但是满足if条件

            if(s[i]==s[i+1]){      //对称点是偶数点
                 left=i;
                 right=i+1;
            }else{                 //对称点是奇数点
                 left=i;
                 right=i;
            }
            while(left>0&&right<len-1&&s[left-1]==s[right+1]){
                left--;
                right++;
                }
            if(right-left+1>result.length()){
                result=s.substr(left,right-left+1);//返回子串
            }    
            
        }
    
        return result;

    }
};

接下来是正确的代码

这样的方式分别以回文子串是偶数个数和奇数个数为出发点去考虑

首先认为回文子串必定是奇数个，也就是只有一个中心点，得出result；

然后认为回文子串必定是偶数个，有两个中心点，得出result；

两者比较，然后确定最终的result

class Solution {
public:
   string longestPalindrome(string s) {
        int len=s.length();
        string result="";
        if(len==0)
            return result;
        for(int i=0;i<len;i++){   //对称点是奇数点
            int left=i;           //假定只有一个对称点
            int right=i;
            while(left>0&&right<len-1&&s[left-1]==s[right+1]){
                left--;
                right++;
            }
            if(right-left+1>result.length()){
                result=s.substr(left,right-left+1);
            }
        }
        for(int i=0;i<len;i++){   //对称点是偶数点
            if(s[i]==s[i+1]){      //俩个对称点
                int left=i;
                int right=i+1;
                while(left>0&&right<len-1&&s[left-1]==s[right+1]){
                    left--;
                    right++;
                }
                if(right-left+1>result.length()){
                    result=s.substr(left,right-left+1);
                }
            }
        }
        return result;
    }


};

2.动态规划算法：

根据官方题解提示，动态规划的思想如下

因此可以构造如下代码

class Solution {
public:
 string longestPalindrome(string s) {
        int len=s.length();
        string result="";
        if(len==0)
            return result;
        int maxLen=0;
        int start=0;
        int end=0;
        //构造键值对存储        
        vector<vector<bool>> dp(len,vector<bool>(len,false));
        for(int j=0;j<len;j++){
            for(int i=0;i<j;i++){
                //条件等同，动态规划
                if(s[i]==s[j]&&(j-i<=2||dp[i+1][j-1])){
                    dp[i][j]=true;
                    if(j-i+1>maxLen){
                        maxLen=j-i+1;
                        start=i;
                        end=j;
                    }
                }
            }
        }
        return s.substr(start,end-start+1);
    }
};