LeetCode 5. Longest Palindromic Substring

原题链接在这里：https://leetcode.com/problems/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"

题解：

以字符串的每一个char 为中心开始向左右延展，直到不是回文为止，若新的substring 比原来的res长，就更新res.

Note: 子字符串的中心可以是一个字符，整个字符串有奇数个字符；也可以是两个字符中间的空隙，整个字符串有偶数个字符。

Note: longest辅助函数在左右延展时，跳出while loop时，i 和 j 指向的要么是out of index bound, 要么指向的字符已经不想等了。所以最后返回的最常字符串应该是substring(i+1,j)这一段, j 指向的 字符并没有包括在最后结果中。

Time Complexity: O(n^2). n = s.length(). Space: O(n), res的长度。

AC Java: 

public class Solution {
    public String longestPalindrome(String s) {
        if(s == null || s.length() == 0){
            return s;
        }
        String res = "";
        for(int i = 0; i<s.length(); i++){
            //string with odd # of characters
            String longestOddSubstring = findLongest(s, i, i);
            if(longestOddSubstring.length() > res.length()){
                res = longestOddSubstring;
            }
            //string with even # of characters
            String longestEvenSubstring = findLongest(s, i, i+1);
            if(longestEvenSubstring.length() > res.length()){
                res = longestEvenSubstring;
            }
        }
        return res;
    }
    
    //find the longest palindromic substring
    private String findLongest(String s, int i, int j){
        while(i>=0 && j<s.length() && s.charAt(i) == s.charAt(j)){
            i--;
            j++;
        }
        return s.substring(i+1,j);
    }
}

AC Python:

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if not s:
            return s
        
        res = ""
        for i in range(len(s)):
            oddCan = self.findLongest(s, i, i)
            if len(oddCan) > len(res):
                res = oddCan
            evenCan = self.findLongest(s, i, i + 1)
            if len(evenCan) > len(res):
                res = evenCan
        return res
        
    def findLongest(self, s, l, r):
        while l >= 0 and r < len(s) and s[l] == s[r]:
            l -= 1
            r += 1
        return s[l + 1:r]

可以用index取得结果来节省空间. 当前index 为i向两边延展后取得的最长palindrome substring的长度len.

最长palindrome substring的左侧index就是i-(len-1)/2, 右侧index就是i+len/2. 

Time Complexity: O(n^2). n = s.length().

Space: O(1).

AC Java:

class Solution {
    public String longestPalindrome(String s) {
        if(s == null || s.length() == 0){
            return s;
        }
        
        int l = 0;
        int r = 0;
        for(int i = 0; i<s.length(); i++){
            int longestOddSubstringLen = findLongest(s, i, i);
            int longestEvenSubstringLen = findLongest(s, i, i+1);
            int longestSubstringLen = Math.max(longestOddSubstringLen, longestEvenSubstringLen);
            if(longestSubstringLen > r-l+1){
                l = i-(longestSubstringLen-1)/2;
                r = i+longestSubstringLen/2;
            }
        }
        return s.substring(l, r+1);
    }
    
    private int findLongest(String s, int i, int j){
        while(i>=0 && j<s.length() && s.charAt(i)==s.charAt(j)){
            i--;
            j++;
        }
        return j-i-1;
    }
}

AC Python:

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if not s:
            return s
        l, r = 0, 0
        for i in range(len(s)):
            oddCan = self.findLongest(s, i, i)
            evenCan = self.findLongest(s, i, i + 1)
            maxCan = max(oddCan, evenCan)
            if maxCan > r - l + 1:
                l = i - (maxCan - 1) // 2
                r = i + maxCan // 2
        return s[l : r + 1]
    
    def findLongest(self, s, l, r):
        while l >= 0 and r < len(s) and s[l] == s[r]:
            l-=1
            r+=1
        return r - l -1

DP 方法. dp[i][j]记录s.substring(i, j+1)是否为Palindromic.

dp[i][j] = (s.charAt(i) == s.charAt(j) && (j-i<2 || dp[i+1][j-1]).

Time Complexity: O(n^2). Space: O(n^2).

public class Solution {
    public String longestPalindrome(String s) {
        if(s == null || s.length() == 0){
            return s;
        }
        
        String res = "";
        int len = s.length();
        boolean [][] dp = new boolean[len][len];
        for(int i = len-1; i>=0; i--){
            for(int j = i; j<len; j++){
                //Need to check j-i < 2 first 
                //or IndexOutOfBondException
                if(s.charAt(i) == s.charAt(j) && (j-i<2 || dp[i+1][j-1])){ 
                    dp[i][j] = true;
                    if(j-i+1 > res.length()){
                        res = s.substring(i, j+1);
                    }
                }
            }
        }
        return res;
    }
}

AC Python:

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if not s:
            return s
        n = len(s)
        dp = [[False for _ in range(n)] for _ in range(n)]
        res = ""
        for i in range(n - 1, -1, -1):
            for j in range(i, n):
                if s[i] == s[j] and (j - i < 2 or dp[i + 1][j - 1]):
                    dp[i][j] = True
                    if len(res) < j - i + 1:
                        res = s[i:j + 1]
        return res     

类似Palindromic Substrings, Longest Palindromic Subsequence.