[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.

思路1

最直接的思路当然是找到每一个子串，检测是否是回文字符串。

代码1

public class Solution {
    public String longestPalindrome(String s) {
        int len = s.length();
        
        if (s == null)
            return "Wrong Input!";
        if (len == 0)
            return "";
        
        for (int i = len;i > 0;i--) {
            for (int j = 0;j <= len-i;j++) {
                if (isPalindrome(s, j, j+i-1)){
                    return s.substring(j, j+i);
                }
            }
        }
        return null;
    }
    
    public static boolean isPalindrome(String s, int low, int high) {
        if (low >= high)
            return true;
        
        if (s.charAt(low) == s.charAt(high))
            return isPalindrome(s, ++low, --high);
    
        else
            return false;
    }
}

显然这种做法会导致Time Limit Exceeded。 

思路2

这类问题一个常规的思路是动态规划，可以将时间复杂度降低到O(N²)，首先给出初始状态和状态转移方程。

初始状态是

P[ i, i ] ← true
P[ i, i+1 ] ← Si = Si+1

状态转移方程

P[ i, j ] ← P[ i+1, j-1 ] 且Si = Sj  

代码2

public class Solution {
    public String longestPalindrome(String s) {
        int len = s.length();
        int beginIndex = 0, maxLen = 1;
        
        boolean[][] state = new boolean[1000][1000];
        
        for (int i = 0; i < len; i++) {
            state[i][i] = true;
        }
        
        for (int i = 0; i < len-1; i++) {
            if (s.charAt(i) == s.charAt(i+1)) {
                state[i][i+1] = true;
                beginIndex = i;
                maxLen = 2;
            } 
        }
        
        for (int k = 3; k <= len; k++) {
            for (int i = 0; i <= len-k ;i++) {
                int j = i + k - 1;
                
                if ((s.charAt(i) == s.charAt(j)) && (state[i+1][j-1])) {
                    state[i][j] = true;
                    beginIndex = i;
                    maxLen = k;
                }
            }
        }
        return s.substring(beginIndex, beginIndex+maxLen);
    }
}