5. Longest Palindromic Substring (DP / Two Pointer)

Dp solution

This question can use a very simple DP to solve. Let's set the DP[i][j] to represent an interval i to j form a palindromic string.

There are only two situations we need to initialize, the first one is when i == j, it would be a single letter, and a single letter belongs to a palindromic string. Another situation is when i + 1 == j, you may ask why, before telling you the answer, we first check about the transfer function.

As dp[i][j] represents an interval, a bigger interval relies on a smaller interval, thus dp[i][j] equals dp[i + 1][j - 1] and we need to check s[i] equals s[j] or not.

The transfer already provided the hints to us, when the interval length is two we need to initialize by ourselves because the transfer function only supports length of 3 or above.

class Solution {
public:
    string longestPalindrome(string s) {
        bool dp[1001][1001] = {0};
        int diff = -1, x = 0, y;
        for(int end = 0; end < s.length(); end++){
            for(int j = 0; j <= end; j++){
                if(end == j)dp[j][end] = 1;
                else if(j + 1 == end && s[end] == s[j])dp[j][end] = 1;
                else dp[j][end] = dp[j + 1][end - 1] && s[end] == s[j];
                
                if(dp[j][end] && diff < end - j + 1){
                    diff = end - j + 1;
                    x = j;
                    y = end - j + 1;
                }
            }
            
        }
        return s.substr(x, y);
    }
};

Two pointer solution

Two pointer solution is really simple and intuitive. We just need to loop the s for once and make s[i] as the center to expand and check how long can this center form a palindromic string. 

class Solution:
    def longestPalindrome(self, s: str) -> str:
        p = ''
        for i in range(len(s)):
            //even length
            p1 = self.get_palindrome(s, i, i+1)
            //odd length
            p2 = self.get_palindrome(s, i, i)
            p = max([p, p1, p2], key=lambda x: len(x))
        return p
    
    def get_palindrome(self, s: str, l: int, r: int) -> str:
        while l >= 0 and r < len(s) and s[l] == s[r]:
            l -= 1
            r += 1
        return s[l+1:r]