Longest Palindromic Substring

1. Question

求最长回文子串

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.

2. Solution

2.1 O(n3)

对每个字符，考察该字符（作为首字符）与其余字符（作为尾字符）组成的子串是否是回文串，找到最长的。判断是否是回文串耗时O(n)，因此时间复杂度O(n3)

2.2 O(n2)

2.2.1 中心向外扩充法

对每个字符，将其作为回文串中心字符（可通过插入辅助字符使得仅考虑奇数回文串情况，eg. abcd--->#a#b#c#d#），考虑其最长回文串长度。此时，为每个中心字符找回文串用时O(n)，因此时间复杂度O(n2)

public class Solution {
    private int maxStart;
    private int maxEnd;
    
    private void expand( String s, int from, int end ){
        for( ; from>=0 && end<s.length() && (s.charAt(from) == s.charAt(end) ); from--,end++ );
        end--;
        from++;
        if( end-from > maxEnd-maxStart ){
            maxStart = from;
            maxEnd = end;
        }
    }
    
    //expand from a middle point, O(n2) time
    public String longestPalindrome( String s ){
        maxStart = 0;
        maxEnd = 0;
        for( int i=0; i<s.length()-1; i++ ){
            expand( s,i,i ); //the result length is odd
            expand( s,i,i+1 ); //the result length is even
        }
        return s.substring(maxStart, maxEnd+1);
    }
}

 

2.2.2 按长度依次扩充

人在找回文串时，一般都是先看到较短的回文串，然后再慢慢往外扩（类似上述中心向外扩充），即先找长度为2的回文串，再找长度为3的，为4的...长度长的可以复用长度短的信息。

由此，定义二维数组a[][]存储回文串信息，a[i][j]表示字符i到j是否是回文串，则有：

　　a[i][i] = true;

　　a[i][i+1] = ( chars[i] == chars[i+1] );

　　a[i][j] = ( chars[i] == chars[j] ) && a[i+1][j-1];

public class Solution {
    //DP, O(n2) time
    public String longestPalindrome( String s ){
        if( s.length()==1 )    return s;
        if( s.length() == 2 ){
            if( s.charAt(0) == s.charAt(1) )
                return s;
            return s.substring(0, 1);
        }
        //s.length() >2
        boolean[][] p = new boolean[s.length()][s.length()];
        int i;
        for( i=0; i<s.length()-1; i++ ){
            p[i][i] = true;
            p[i][i+1] = ( s.charAt(i) == s.charAt(i+1) );
        }
        p[i][i] = true;        
        for( i=2; i<s.length(); i++ )
            for( int j=0, k=i; k<s.length(); j++, k++ )
                p[j][k] = ( s.charAt(j) == s.charAt(k) ) && p[j+1][k-1];
        
        int maxStart = 0;
        int maxEnd = 0;
        for( i=0; i<s.length(); i++ )
            for( int j=s.length()-1; j>=i; j-- ){
                if( p[i][j] ){
                    if( j-i > maxEnd-maxStart ){
                        maxStart = i;
                        maxEnd = j;
                    }
                    break;
                }
            }
        return s.substring(maxStart, maxEnd+1);
    }
}

2.3 O(n)

 考虑中心向外扩充，它遍历每个字符为其找回文串。而事实上，由于回文串的对称性，中心点左侧的回文性和右侧字符的部分回文性是一致的，这部分数据可以重用，而不用重复计算。

改进上述算法，重新定义下列变量：

• r[]：存放以每个点为中心点的最长回文串的半径（以便复用该信息）
• max：存放目前回文串走到最远的中心字符索引，即以max为中心的回文串，其回文串最后一个字符是目前走的最远的。下面简称max为最远覆盖点，回文串范围为覆盖范围
• i：定义当前访问的字符索引，要为字符i计算其回文串长度
  • 如果i在max的覆盖范围，考察i的对称点的覆盖范围
    • 如果对称点覆盖边界在max覆盖边界之内，则无需对i再扩展，r[i] = r[i的对称点]
    • 如果对称点覆盖边界与max某覆盖边界重合，则对于i，最远覆盖边界之外的点是下一个可能在i的回文串范围的字符，应当从最远覆盖边界开始继续向外扩充，计算r[i]
  • 如果不在，以i为中心点向外扩充（此时没有可利用的信息）

利用渐进计算分析可知，该算法时间复杂度O(n)

public class Solution {
    
    //adding extra character to make all substring as an odd number string. such as: abcd--->#a#b#c#d#
    private String preProcess( String s ){
        StringBuilder res = new StringBuilder();
        for( int i=0; i<s.length(); i++ ){
            res.append('#');
            res.append( s.charAt(i) );
        }
        res.append( '#' );
        return res.toString();
    }
    
    //expand a palindrome, return the expanding length
    private int expand( String s, int start, int end ){
        int newS = start;
        int newE = end;
        for( ; newS >= 0 && newE < s.length() && s.charAt(newS) == s.charAt(newE); newS--, newE++ );
        return start - newS;
    }
    
    //O(n) time, using symmetry feature, calculate the longest palindromic centered by each point
    public String longestPalindrome( String s ){
        String newS = preProcess(s);
        
        int[] r = new int[newS.length()];
        r[0] = 0;
        int max = 0;
        
        for( int i=1; i<newS.length(); i++ ){
            int j = r[max] + max;   //present farthest palindrome range, inclusive
            if( j >= newS.length() )
                break;
            //if i is in the range, it's possible to fast calculate the palindromic length for point i
            if( i<=j ){
                int symI = r[2*max-i];
                int remainRange = j - i;
                if( symI < remainRange )
                    r[i] = symI;
                else
                    r[i] = expand( newS, i-remainRange-1, j+1 ) + remainRange;
            }
            //if i is not int the range, r[i] = expand(i)
            else
                r[i] = expand( newS, i-1, i+1 );
            
            if( r[i] + i > j )  max = i;
        }
        max = 0;
        for( int i=0; i<r.length; i++ )
            if( r[i] > r[max] ) max = i;
        return s.substring( (max-r[max]+1)/2, (max+r[max])/2 );
    }
}