leetcode ：5 最长回文子串

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

示例 1：

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1.mannacher算法：https://www.jianshu.com/p/116aa58b7d81

2.我自己觉着是动态规划：回文子串可以分为两种，奇数个和偶数个，基础为单个字符，和两个相同字符，找到一个子串，向外

扩张，达到边界，保存当前最长子串，（一次循环进行两次扩张，一次为奇数个子串的，另一次要先判断偶数子串是否存在，若存在，进行扩张）

3.暴力，特别慢，将每个子串都进行判断，n^2个子串，难搞！

/*
https://www.jianshu.com/p/116aa58b7d81
    Mannacher算法，首先是找到下一个点的回文半径，
    如果下一个点在一个回文串里，则以回文中心轴，对应点的
    回文半径就可以作为一个参考值，
    如果对应点回文半径左侧的点落在回文中心轴与其半径长左侧点之间，即r[i]=r[2*c-i],2*c-i 左侧点坐标
    如果大于则r[i]=R-i+1;
    如果等于r[i]=r[2*c-i],但是这个值还需要进行左右扩张
*/

    string longestPalindrome(string s) {
        
        if(s.size()<1)
        return "";
        string s1="";
        for(int i=0;i<s.size();i++)
            s1=s1+"#"+s[i];
        s1=s1+"#";
        vector<int> r(s1.size(),0);
        int R=-1;
        int c=-1;
        //int max=MAX_INT;
        string ms="";
        for(int i=0;i<r.size();i++){
            r[i]=R>i?min(r[2*c-i],R-i+1):1;
            while(i+r[i]<s1.size()&&i-r[i]>-1){
                if(s1[i-r[i]]==s1[i+r[i]]){
                    r[i]++;
                }else{
                    break;
                }
            }
            if(i+r[i]>R){
                R=i+r[i]-1;
                c=i;
            }

            //max=max>r[i]?max:r[i];
            string s2(s1.substr(i-r[i]+1,2*r[i]-1));
            string s3="";
            for(int j=0;j<s2.size();j++)
            {
                if(s2[j]!='#')
                s3+=s2[j];
            }
            if(s3.size()>ms.size())
            ms=s3;
            //cout<<"s1"<<s1<<endl;
            //cout<<"s2"<<s2<<endl;
            //cout<<"s3"<<s3<<endl;
        }
        return ms;
        
    }

string longestPalindrome(string s) {
        string x="";
        for(int i=0;i<s.size();i++){//每一个单独的字符都是一个回文子串
            //以当前子串为中心寻找更长的子串
            int l=i;
            int r=i;
            while(l>=0&&r<s.size()){
                if(s[l]==s[r]){
                    l--;
                    r++;
                }else{
                    break;
                }
            }
        //当到达边界后，取出子串并于以前的子串比较长度
        string str(s.substr(l+1,r-l-2+1));
        if(str.size()>x.size())
            x=str;
            //如果是偶数个的子串，要先判断，在同上步骤
            if(i!=0&&s[i-1]==s[i]){
                l=i-1;
                r=i;
                while(l>=0&&r<s.size()){
                    if(s[l]==s[r]){
                        l--;
                        r++;
                    }else{
                        break;
                    }
                }
                string str(s.substr(l+1,r-l-2+1));
                if(str.size()>x.size())
                    x=str;
            }
        }
     return x;  
    }

string longestPalindrome(string s) {
        int num=s.length();
      
        int flag=0;
        int len=0;
        string cc;
        if(num<2)
            return s;
        for(int i=0;i<num;i++){
            for(int j=i+1;j<num+1;j++){
                string aa(s.substr(i,j-i));
               
                for(int k=0;k<(j-i)/2+1;k++){
                    if(aa[k]!=aa[j-i-k-1])
                    {
                        flag=1;
                        break;
                    }
                }
                if(flag==0)
                {                
                    if(len<=(j-i)){                       
                        cc=aa;
                        len=j-i;                        
                    }                  
                }
                else flag=0;
            }
        }
        return cc;
    
    }