[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;                }  }