[LeetCode] Longest Palindromic Substring 最长回文子串

最长回文子串的问题有很多变种，先看最基本的：

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.

思路： 用一个指针从0遍历到s.length()-1，从里向外来检测子串是否是回文，分两种情况：1）bab, 2)bb。也就是当前指针可能指向的是奇数回文，也可能是偶数回文。做两次检测。

Java

   public static  String longestPalindrome(String s) {  
        if (s == null || s.length() <= 1) return s;  
        String longestPalindrome = "";  
        for (int i = 0; i < s.length() - 1; i++) {  
            String palindrome = getLongestPalindrome(s, i, i);  //case: bab
            if (palindrome.length() > longestPalindrome.length()) {  
                longestPalindrome = palindrome;  
            }  
              
            palindrome = getLongestPalindrome(s, i, i + 1);   //case: bb
            if (palindrome.length() > longestPalindrome.length()) {  
                longestPalindrome = palindrome;  
            }   
        }  
        return longestPalindrome;  
    }  
      
    public static String getLongestPalindrome(String s, int left, int right) {  
        int length = s.length();  
        while(left >= 0 && right < length && s.charAt(left) == s.charAt(right)) {  
            left--;  
            right++;  
        }  
        return s.substring(left + 1, right);  
    }  
	
	public static void main(String[] args){
		
		System.out.println(longestPalindrome("wfacabcdcbagggafd"));
		
	}
}

其他思路：

思路1. 动态规划
这里动态规划的思路是 dp[i][j] 表示的是 从i 到 j 的字串，是否是回文串。
则根据回文的规则我们可以知道：
如果s[i] == s[j] 那么是否是回文决定于 dp[i+1][ j - 1]
当 s[i] != s[j] 的时候， dp[i][j] 直接就是 false。
动态规划的进行是按照字符串的长度从1 到 n推进的。
代码很明晰：给出java代码，复杂度 O(n^2)
[java] view plaincopy

public class DPSolution {  
  
    boolean[][] dp;  
      
    public String longestPalindrome(String s)  
    {  
        if(s.length() == 0)  
        {  
            return "";  
        }  
        if(s.length() == 1)  
        {  
            return s;  
        }  
  
        dp = new boolean[s.length()][s.length()];  
          
        int i,j;  
          
        for( i = 0; i < s.length(); i++)  
        {  
            for( j = 0; j < s.length(); j++)  
            {  
                if(i >= j)  
                {  
                    dp[i][j] = true; //当i == j 的时候，只有一个字符的字符串; 当 i > j 认为是空串，也是回文  
  
                }  
                else  
                {  
                    dp[i][j] = false; //其他情况都初始化成不是回文  
                }  
            }  
        }  
          
        int k;  
        int maxLen = 1;  
        int rf = 0, rt = 0;  
        for( k = 1; k < s.length(); k++)  
        {  
            for( i = 0;  k + i < s.length(); i++)  
            {  
                j = i + k;  
                if(s.charAt(i) != s.charAt(j)) //对字符串 s[i....j] 如果 s[i] != s[j] 那么不是回文  
                {  
                    dp[i][j] = false;  
                }  
                else  //如果s[i] == s[j] 回文性质由 s[i+1][j-1] 决定  
                {  
                    dp[i][j] = dp[i+1][j-1];  
                    if(dp[i][j])  
                    {  
                        if(k + 1 > maxLen)  
                        {  
                            maxLen = k + 1;  
                            rf = i;  
                            rt = j;  
                        }  
                    }  
                }  
            }  
        }  
        return s.substring(rf, rt+1);  
    }  
}  

思路2. KMP匹配
第二个思路来源于字符串匹配，最长回文串有如下性质：　
对于串S, 假设它的 Reverse是 S', 那么S的最长回文串是 S 和 S' 的最长公共字串。
例如 S = abcddca,  S' = acddcba， S和S'的最长公共字串是 cddc 也是S的最长回文字串。
如果S‘是 模式串，我们可以对S’的所有后缀枚举(S0, S1, S2, Sn) 然后用每个后缀和S匹配，寻找最长的匹配前缀。
例如当前枚举是 S0 = acddcba 最长匹配前缀是 a
S1  = cddcba 最长匹配前缀是 cddc
S2 = ddcba 最长匹配前缀是 ddc
当然这个过程可以做适当剪枝，如果当前枚举的后缀长度，小于当前找到的最长匹配，则直接跳过。


Java 代码如下：
[java] view plaincopy

public class Solution {  
    private int[] next;  
    private void GetNext(String s)　//KMP求next数组  
    {  
        int i,j;  
          
        i = 0;   
        j = -1;  
          
        next[0] = -1;  
          
        while( i < s.length())  
        {  
            if( j == -1 || s.charAt(i) == s.charAt(j))  
            {  
                i++;  
                j++;  
                next[i] = j;  
            }  
            else  
            {  
                j = next[j];  
            }  
        }  
    }  
    private int compare(String pattern, String s) //用KMP算法做求出最长的前缀匹配  
    {  
        int i,j;  
          
        i = 0;  
        j = 0;  
       
        int maxLen = 0;  
        while( i < s.length())  
        {  
            if(j == -1 || pattern.charAt(j) == s.charAt(i))  
            {  
                i++;  
                j++;  
            }  
            else  
            {  
                j = next[j];  
            }  
            if( j > maxLen)  
            {  
                maxLen = j;  
            }  
            if(j == pattern.length())  
            {  
                return maxLen;  
            }  
        }  
        return maxLen;  
    }  
      
    public String longestPalindrome(String s)  //  
    {  
        // Start typing your Java solution below  
        // DO NOT write main() function  
        String reverString = new StringBuilder(s).reverse().toString();  //求得到 输入string 的reverse  
        next = new int[s.length() + 1];  
          
        String maxPal = "";  
        int maxLen = 0;  
        int len;  
        for(int i = 0; i < s.length(); i++) //枚举所有后缀  
        {  
            String suffix = reverString.substring(i);  
            if(suffix.length() < maxLen)  
            {  
                break;  
            }  
            GetNext(suffix);  
            len = compare(suffix, s);  
            if( len > maxLen)  
            {  
                maxPal = suffix.substring(0, len);  
                maxLen = len;  
            }  
              
        }  
        return maxPal;  
          
    }  
}