【LeetCode】5. 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.

Example:

Input: "babad"

Output: "bab"

Note: "aba" is also a valid answer.

 

Example:

Input: "cbbd"

Output: "bb"

 

解法一：

回文字符串是正向读和反着读都是一样的字符串，比如abcba, a. 题目要求找长度最长的回文子字符串。 我们可以以某一个字符为中心点，向两边延伸，若字符左右相等则继续延伸，这样找到的回文子字符串长度为奇数。也可以以某两个相邻相等的字符为中心点，向两边延伸，这样找到的回文子字符串长度为偶数。如果一个字符有一个相邻相等的字符，例如C'C''C'''中的C'',则以C''延伸得到最长回文子串是CCC，以C''C'''延伸得到的最长回文子串是C''C'''，所以对于每一个字符，都要以两种情况来延伸得到最长的回文子串，而且start, maxlen得到的值是最长的那个情况下的。我们需要一个start, maxlen变量来记录和更新每一次延伸的结果。时间复杂度 O(n^2)

代码如下：

int start = 0, maxLen = 0;
    
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 2){
            return s;
        }
        char[] ss = s.toCharArray();
        for (int i = 0; i < ss.length - 1; i++){
            extend(ss, i, i + 1);
            extend(ss, i, i);
        }
        return s.substring(start, start + maxLen);
    }
    private void extend(char[] ss, int left, int right){
        while (left >= 0 && right < ss.length && ss[left] == ss[right]){
            left--;
            right++;
        }
        if (maxLen < right - left - 1){
            maxLen = right - left - 1;
            start = left + 1;
        }
    }

解法二：

我们可以用动态规划来解题。dp[i][j] 表示给定字符串s中 从 i 到 j (包括i, j所指的字符) 所形成的字符串是否是回文字符串，则dp[i][j] == true if dp[i + 1][j - 1] == true and ss[i] == ss[j]，注意index的边界情况。我们依旧需要start, maxLen来记录和更新每一次的值。 时间复杂度 O(n^2)

代码如下：

public String longestPalindrome(String s) {
        if (s == null || s.length() < 2){
            return s;
        }
        char[] ss = s.toCharArray();
        boolean[][] dp = new boolean[ss.length][ss.length];
        int start = 0, maxLen = 1;
        
        for (int i = ss.length - 1; i >= 0; i--){
            for (int j = ss.length - 1; j >= i; j--){
                dp[i][j] = ss[i] == ss[j] && (j - i < 2 || dp[i + 1][j - 1]);
                if (dp[i][j] && j - i + 1 > maxLen){
                    start = i;
                    maxLen = j - i + 1;
                }
            }
        }
        return s.substring(start, start + maxLen);
    }

解法三：

可以在解法二的基础上继续优化，从O(n^2)优化至O(n).  dp[i][j] 是从dp[i + 1][j - 1] 得来的，外部循环i是在逐步递减的，也就是说在当前(i) 开始的时候，dp[0...j...n-1]还是上一次(i + 1)的值。并且j也是逐步递减，我们先更新dp[j]，再更新dp[j - 1]，因此在更新dp[j]的时候，dp[j - 1]还是上一层的值。如果用一位数组来记录的话，可以减少memory。

代码如下：

public String longestPalindrome(String s) {
        if (s == null || s.length() < 2){
            return s;
        }
        char[] ss = s.toCharArray();
        boolean[] dp = new boolean[ss.length];
        int start = 0, maxLen = 1;
        
        for (int i = ss.length - 1; i >= 0; i--){
            for (int j = ss.length - 1; j >= i; j--){
                dp[j] = ss[i] == ss[j] && (j - i < 2 || dp[j - 1]);
                if (dp[j] && j - i + 1 > maxLen){
                    start = i;
                    maxLen = j - i + 1;
                }
            }
        }
        return s.substring(start, start + maxLen);

以上三种解法思路均来源于LeetCode discussion。