LeetCode#5 Longest Palindromic Substring

Problem Definition:

Given a string S, find the longest palindromic substring in S.

You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic substring.

Solution:

1) 暴力。把所有的子串全找出来，然后验真是否回文。找子串耗时O(n^2)来确定起点和终点；验真回文耗时O(n)。于是得到一个O(n^3)的算法（或许不叫算法）。

def longestPalindrome(s):
        #brute-force TLE
        mag,subLen,maxLen,subStr=len(s),2,1,[0,1]#[begin,length]
        while subLen<=mag:
            for i in range(mag-subLen+1):
                if self.isPal(s[i:i+subLen]):
                    maxLen=max(maxLen,subLen)
                    subStr=[i,maxLen]
            subLen+=1
        return s[subStr[0]:subStr[0]+subStr[1]]

def isPal(s):
        head,rear=0,len(s)-1
        while head<=rear:
            if s[head]!=s[rear]:
                return False
            head+=1
            rear-=1
        return True

2）动态规划。任何长度大于1的回文，必然可以由更小的回文扩展而来。用s[i....j]表示从i到j的这个子串，则有：

　　1._如果s[i+1...j-1]是回文，且s[ i ]==s[ j ]，则s[i...j]是回文。

　　2._如果s[i+1...j-1]不是回文，或者s[ i ]!=s[ j ]，则s[i...j]不是回文。

　　　　可以用一个表来记录子串是否是回文。tb=[ n ][ n ]， tb[ 2 ][ 2 ]==True表示从下标2开始到下标2结束的

　　子串(就是一个字符)是回文，tb[4][7]==True表示从下标4到下标7的串是回文。

　　　　这个解法耗时O(n^2)，空间复杂度也是O(n^2)。

def longestPalindrome(s):
        #dp
        begin,maxLen=0,1
        tb=[[False]*len(s)]*len(s)
        for i in range(len(s)): #subLen=1
            tb[i][i]=True
        for i in range(len(s)-1):
            if tb[i][i]==tb[i][i+1]:  #subLen=2
                begin=i
                maxLen=2
        for subLen in range(3,len(s)+1): #subLen=[3-->len(s)]
            for i in range(len(s)-subLen+1):  #begin index
                j=i+subLen-1                  #end index
                if s[i]==s[j] and tb[i+1][j-1]==True:
                    tb[i][j]=True
                    begin=i
                    maxLen=subLen
        return s[begin:begin+maxLen]

3）从回文串对称轴扩展。我们知道回文字符串是对称的，因此任何一个回文字符串都可以从它的对称轴处开始扩展而来。

　  这里要注意的是，回文串的长度可能是奇数或偶数。奇数长度字符串的对称轴上是一个字符，比如aba；偶数长度字

　  符串对称轴上则是空隙，比如abba。因此有2n-1个位置可以作为对称轴（n个字符，n-1个空隙）。

　  此方法耗时O(n^2)，空间复杂度为常数。

def longestPalindrome(s):
        lgst=s[0]
        for i in range(len(s)-1):
            s1=self.expCenter(s, i, i)
            if len(s1)>len(lgst):
                lgst=s1
            s2=self.expCenter(s, i, i+1)
            if len(s2)>len(lgst):
                lgst=s2
        return lgst

def expCenter(self, s, lft, rgt):
        while lft>=0 and rgt<len(s) and s[lft]==s[rgt]:
            lft-=1
            rgt+=1
        return s[lft+1:rgt]

4）还有更优的解法吗？ Manacher算法可以达到线性的时间复杂度。