查找字符串中的最长回串

1.中心查找。把每个字符（字符间隙）当成一个未知回串的中心，两边同时扫描，直到两边的值不同，或者超出字符串长度为止，取出最长字串即可

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        lenth = len(s)
        maxlen = 0
        res = ""
        if lenth == 0:
            return ""
        
        for i in range(2*lenth-1): #把字符串的空隙算入总长度
            left = i/2
            right = i/2
            if i%2 == 1: #i为空隙
                right = right + 1
            sub_s = self.func(s, left, right)
            if maxlen < len(sub_s):
                maxlen = len(sub_s)
                res = sub_s
        return res
    
    def func(self, s, left, right):
        try:
            while(left >= 0 and right <= len(s) and s[left] == s[right]):
                left = left - 1
                right =  right + 1
        except IndexError: #right超出长度，获取字符串索引报错
            pass
        return s[left+1:right]

if __name__ == "__main__":
    st = Solution()
    print st.longestPalindrome("babad")
    
    

2.Manacher算法

算法基本要点：首先用一个非常巧妙的方式，将所有可能的奇数/偶数长度的回文子串都转换成了奇数长度：在每个字符的两边都插入一个特殊的符号。比如 abba 变成 #a#b#b#a#， aba变成 #a#b#a#。 为了进一步减少编码的复杂度，可以在字符串的开始加入另一个特殊字符，这样就不用特殊处理越界问题，比如$#a#b#a#。

下面以字符串12212321为例，经过上一步，变成了 S[] = "$#1#2#2#1#2#3#2#1#";

然后用一个数组 P[i] 来记录以字符S[i]为中心的最长回文子串向左/右扩张的长度（包括S[i]），比如S和P的对应关系：

S     #  1  #  2  #  2  #  1  #  2  #  3  #  2  #  1  #
P     1   2  1  2  5   2  1  4   1  2  1  6   1  2   1  2  1
(p.s. 可以看出，P[i]-1正好是原字符串中回文串的总长度）

下面计算P[i]，该算法增加两个辅助变量id和mx，其中id表示最大回文子串中心的位置，mx则为id+P[id]，也就是最大回文子串的边界。

这个算法的关键点就在这里了：如果mx > i，那么P[i] >= MIN(P[2 * id - i], mx - i)。

具体代码如下：

if(mx > i)
{
      p[i] = (p[2*id - i] < (mx - i) ? p[2*id - i] : (mx - i));
}
else
{
       p[i] = 1;
}

当 mx - i > P[j] 的时候，以S[j]为中心的回文子串包含在以S[id]为中心的回文子串中，由于 i 和 j 对称，以S[i]为中心的回文子串必然包含在以S[id]为中心的回文子串中，所以必有 P[i] = P[j]，见下图。

当 P[j] > mx - i 的时候，以S[j]为中心的回文子串不完全包含于以S[id]为中心的回文子串中，但是基于对称性可知，下图中两个绿框所包围的部分是相同的，也就是说以S[i]为中心的回文子串，其向右至少会扩张到mx的位置，也就是说 P[i] >= mx - i。至于mx之后的部分是否对称，就只能一个一个匹配了。

对于 mx <= i 的情况，无法对 P[i]做更多的假设，只能P[i] = 1，然后再去匹配了

下面给出原文，进一步解释算法为线性的原因

def longestPalindrome3(s):
    mx=0                   #mx即为当前计算回文串最右边字符的最大值
    ans=0
    po=0
    Len=[0]*10000

##转换字符串
    def INIT(s):
        init_s='@#'
        for x in s:
            init_s=init_s+x+'#'

        return init_s+'$',2*len(s)+1     # 字符串结尾加一个字符，防止越界 

    init_s,len_s=INIT(s)       #转换字符串
    get_po=0
    for i in range(1,len_s):
        if mx>i:
            Len[i]=min(mx-i,Len[2*po-i]) #在Len[j]和mx-i 中取小
        else:
            Len[i]=1  #如果i>mx，要从头开始匹配

        while init_s[i-Len[i]]==init_s[i+Len[i]]:
            Len[i]=Len[i]+1

        if Len[i]+i>mx:      #若新计算的回文串右端点位置大于mx，要更新po和mx的值
            mx=Len[i]+i
            po=i


        if ans<Len[i]:
            ans=Len[i]
            get_po=i


    return 'ans=  '+str(ans-1)+'  get_po= '+init_s[get_po-ans+2:get_po+ans:2]   #返回Len[i]中的最大值-1即为原串的最长回文子串额长度