5. 最长回文子串

题目描述：

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

示例 1：

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

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

算法1：动态规划

class Solution {
public:
    string longestPalindrome(string s) {
        int len = s.length();
        if(len==0 || len==1)
            return s;
        vector<vector<int> >dp(len, vector<int>(len) ); //定义二维动态数组
        int MAX = 1;   //回文串最大长度
        int start = 0; //回文串起始位置
        for(int i=0; i<len; i++)   //初始化状态
        {
            dp[i][i] = 1;
            if(i+1<len && s[i]==s[i+1])
            {
                dp[i][i+1] = 1;
                MAX = 2;
                start = i;
            }
        }
        for(int leng = 3; leng <= len; leng++) //leng 表示检索的子串长度，等于3表示先检索长度为3的子串
        {
            for(int i=0; i+leng-1 < len; i++)
            {
                int j = i+leng-1;  //终止字符位置
                if(s[i]==s[j] && dp[i+1][j-1] == 1)  //状态转移
                {
                    dp[i][j] = 1;
                    start = i;
                    MAX = leng;
                }
            }
        }
        return s.substr(start, MAX); //获取最长回文子串
        
    }
};

算法2：中心扩展法

回文中心的两侧互为镜像。因此，回文可以从他的中心展开，并且只有2n-1个这样的中心(一个元素为中心的情况有n个，两个元素为中心的情况有n-1个)

class Solution {
public:
    string longestPalindrome(string s) {
        int len=s.size();
        if(len==0||len==1)
            return s;
        int start=0;//记录回文子串起始位置
        int end=0;//记录回文子串终止位置
        int mlen=0;//记录最大回文子串的长度
        for(int i=0;i<len;i++)
        {
            int len1=expendaroundcenter(s,i,i);//一个元素为中心
            int len2=expendaroundcenter(s,i,i+1);//两个元素为中心
            mlen=max(max(len1,len2),mlen);
            if(mlen>end-start+1)
            {
                start=i-(mlen-1)/2;
                end=i+mlen/2;
            }
        }
        return s.substr(start,mlen);
        //该函数的意思是获取从start开始长度为mlen长度的字符串
    }
private:
    int expendaroundcenter(string s,int left,int right)
    //计算以left和right为中心的回文串长度
    {
        int L=left;
        int R=right;
        while(L>=0 && R<s.length() && s[R]==s[L])
        {
            L--;
            R++;
        }
        return R-L-1;
    }
};

 算法3：

Manacher 算法