[LeetCode] Longest Palindromic Substring

This problem has a long story. There are just too many solutions on the web and it can be studied for a long time before you fully grasp it. Morever, it can induce many other concepts or problems (longest palindromic subsequence, longest common substring, etc).

The simplest way to solve it is to use two-dimensional DP. We denote P[i][j] to be an indicator of whether the substring from i to j (inclusive) is a palindrome. It is obvious that the following relationships hold:

1. P[i][i] = 1 (each character itself is palindromic);
2. P[i][i + 1] = s[i] == s[j] (two neighboring characters are palindromic if they are the same);
3. P[i][j] = P[i + 1][j - 1] && s[i] == s[j] (If the substring is palindrome, then adding the same character at both of its two ends still gives a palindrome).

1 and 2 are base cases and 3 is the general case.

Then we will have the following unoptimiezd DP code.

    string longestPalindrome(string s) {
        int start = 0, len = 1, n = s.length();
        bool dp[1000][1000] = {false};
        for (int i = 0; i < n; i++)
            dp[i][i] = true;
        for (int i = 0; i < n - 1; i++) {
            dp[i][i + 1] = s[i] == s[i + 1];
            if (dp[i][i + 1]) {
                start = i;
                len = 2;
            }
        }
        for (int l = 3; l <= n; l++) {
            for (int i = 0; i < n - l + 1; i++) {
                int j = i + l - 1;
                dp[i][j] = dp[i + 1][j - 1] && s[i] == s[j];
                if (dp[i][j]) {
                    start = i;
                    len = l;
                }
            }
        }
        return s.substr(start, len);
    }

Note that each time when we update dp[i][j], we only need dp[i + 1][j - 1] from the left column, so we can maintain a single variable for it and reduce the space complexity from O(n^2) to O(n). The code now becomes as follows.

    string longestPalindrome(string s) {
        int start = 0, len = 1, n = s.length();
        bool cur[1000] = {false};
        bool pre;
        cur[0] = true;
        for (int j = 1; j < n; j++) {
            cur[j] = true;
            pre = cur[j - 1];
            cur[j - 1] = s[j - 1] == s[j];
            if (cur[j - 1] && len < 2) {
                start = j - 1;
                len = 2;
            }
            for (int i = j - 2; i >= 0; i--) {
                bool temp = cur[i];
                cur[i] = pre && s[i] == s[j];
                if (cur[i] && j - i + 1 > len) {
                    start = i;
                    len = j - i + 1;
                }
                pre = temp;
            }
        }
        return s.substr(start, len);
    }

We may also traverse the string and expand to left and right from any character to obtain the longest palindrome. The following code should be self-explanatory.

    string search(string s, int left, int right) {
        int l = left, r = right;
        while (l >= 0 && r < s.length() && s[l] == s[r]) {
            l--;
            r++;
        }
        return s.substr(l + 1, r - l - 1);
    }
    
    string longestPalindrome(string s) {
        string longest = s.substr(0, 1);
        for (int i = 0; i < s.length() - 1; i++) {
            string tmp1 = search(s, i, i);
            string tmp2 = search(s, i, i + 1);
            if (tmp1.length() > longest.length()) longest = tmp1;
            if (tmp2.length() > longest.length()) longest = tmp2;
        }
        return longest;
    }

Of course, this problem still has a non-trivial O(n) algorithm, named Manacher's algorithm. This page has a nice explanation for it. The final code is shown below.

    string process(string s) {
        int n = s.length();
        string t(2 * n + 3, '#');
        t[0] = '$';
        t[2 * n + 2] = '%';
        for (int i = 0; i < n; i++)
            t[2 * (i + 1)] = s[i];
        return t;
    }
    
    string longestPalindrome(string s) {
        string t = process(s);
        int n = t.length();
        int* plen = new int[n]();
        int center = 0, right = 0;
        for (int i = 1; i < n - 1; i++) {
            int i_mirror = 2 * center - i;
            plen[i] = right > i ? min(plen[i_mirror], right - i) : 0;
            while (t[i + plen[i] + 1] == t[i - plen[i] - 1])
                plen[i]++;
            if (i + plen[i] > right) {
                center = i;
                right = i + plen[i];
            }
        }
        int maxlen = 0;
        for (int i = 1; i < n - 1; i++) {
            if (plen[i] > maxlen) {
                center = i;
                maxlen = plen[i];
            }
        }
        delete[] plen;
        return s.substr((center - 1 - maxlen) / 2, maxlen);
    }