5. Longest Palindromic Substring

class Solution 
{
public:
    string longestPalindrome(string s) 
    {
        int len=s.length();
        if(len<2)
            return s;
        int min_start=0,max_len=1;
        for(int i=0;i<len;)
        {
            if(len-i<=max_len/2)
                break;
            int j=i,k=i;
            while(k<len-1&&s[k]==s[k+1])
                k++;
            i=k+1;
            while(k<len-1&&j>0&&s[k+1]==s[j-1])
            {
                ++k;
                --j;
            }
            int newlen=k-j+1;
            if(newlen>max_len)
            {
                min_start=j;
                max_len=newlen;
            }
        }
        return s.substr(min_start,max_len);
    }
};

中心扩散法，以回文中间元素为扫描基准，扫描的时候判定回文并更新最大长度和开始值，值得注意的是一定要跳过中间相等的元素，从相等那一段的两端往两边走。

 

class Solution {
public:
    string longestPalindrome(string s){
        // 进行填充，首末均有特殊字符，就不需要越界判定了
        string ss="$#";
        for(char& c:s)
            ss = ss + c + "#";
        int sz_ss=ss.size();
        vector<int> p(sz_ss, 0);
        // center是当前最远回文串中心，right是当前最远距离
        int center=0,right=0;
        // 用来存放最大回文子串的位置和长度
        int maxLen=0,maxPos=0;
        
        for(int i=1;i<sz_ss;i++){
            // 如果当前扫描元素在最远回文距离以内，尝试使用历史信息初步判定回文长度
            if(right>i)
                p[i]=min(right-i, p[2*center-i]);
            
            // 尝试继续向两边扩展
            while(ss[i+p[i]+1]==ss[i-p[i]-1])
                ++p[i];
            
            // 更新最远距离和中心
            if(right<i+p[i]){
                right=i+p[i];
                center=i;
            }
            
            // 更新最大长度和对应子串中心位置
            if(p[i]>maxLen){
                maxLen=p[i];
                maxPos=i;
            }   
        }
        // 这个计算很巧妙，填充序列里，每个回文串必以填充字符开始和结束
        // 所以真正回文开始位置就是最前方填充字符的下一个字符
        // 下一个字符在原字符串中的下标，正好就是前面填充字符下标除以2
        // 填充字符的下标是maxPos-maxLen
        return s.substr((maxPos-maxLen)/2,maxLen);
    }
};

马拉车算法，把回文串的特性利用了起来，减少了很多不必要的判定，O(n)复杂度，很强势。