LeetCode - Longest Palindromic Substring

Longest Palindromic Substring

2014.2.10 00:57

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.

Solution1:

　　My first solution to this problem is the brute-force version, with O(n^2) time complexity, where n is the length of the string.

　　The code needs no further explanation, please see for yourself.

　　Time complexity is O(n^2), space complexity is O(1).

Accepted code:

// 1AC, the brute-force solution, O(n^2) time complexity
class Solution {
public:
    string longestPalindrome(string s) {
        int i, j;
        int len;
        int ll, rr;
        string s1, s2;
        string str;
        
        len = (int)s.length();
        if (len <= 1) {
            return s;
        }
        s1 = "";
        for (i = 0; i < len; ++i) {
            j = 0;
            while (true) {
                if ((i - j < 0) || (i + j > len - 1) || (s[i - j] != s[i + j])) {
                    break;
                } else {
                    ++j;
                }
            }
            --j;
            if (2 * j + 1 > (int)s1.length()) {
                s1 = s.substr(i - j, 2 * j + 1);
            }
        }
        s2 = "";
        for (i = 0; i < len - 1; ++i) {
            j = 0;
            while (true) {
                if ((i - j < 0) || (i + 1 + j > len - 1) || (s[i - j] != s[i + 1 + j])) {
                    break;
                } else {
                    ++j;
                }
            }
            --j;
            if (2 * j + 2 > (int)s2.length()) {
                s2 = s.substr(i - j, 2 * j + 2);
            }
        }
        
        if (s1.length() > s2.length()) {
            return s1;
        } else {
            return s2;
        }
    }
};

Solution2:

　　I believe you've heard about the Manacher's Algorithm. It is an efficient solution to this problem, which is linear and one-pass. Perhaps you haven't tried it yourself. Here is the wiki for your information: Manacher's Algorithm.

　　The difference between Manacher's Algorithm and the Brute-Force one can be described with an example below:

　　　　1. Here is a string "....sabcbas....", the part I show you here is a palindrome.

　　　　2. 'c' is the center of that palindrome, and the two 's's are symmetric, with 'c' as the symmetric center.

　　　　3. If this palindromic string is currently the longest we can find, and we're currently standing at the position of the second 's'.

　　　　4. We see that "sabc" and "cbas" look symmetric, and we suppose that the longest palindrome you can get with the second 's' as the center might be similar to the first 's', since they're symmetric.

　　　　5. Since the algorithm runs in one pass, we've know everything before s[i] when we're at position i.

　　　　6. The right side of the first 's' is already known, so is the left side of the second 's'. No more matching is needed here. That's why this algorithm can save some duplicated matching.

　　　　7. Nevertheless, the right part of "..." is still unknown, thus the matching must still be done here.

　　　　8. If a longer palindrome is found, the center 'c' and the palindromic radius will be updated.

　　　　9. The algorithm won't recalculate the palindrome within that longest palindromic range, that is, the farthest position the currently longest palindrome can reach. That's why the code has double loops, but still runs in O(n) time.

　　You might find the descriptions above a total mess. I have to say it really wasn't easy for me to digest the code when learning this genius algorithm.

　　The great Einstein once said, "if you can't explain it simply you don't understand it well enough". Guess that's why I tried to put a lot of words only to get you confused here. You might look at the code below, it's much simpler than my broken English. (^_^)

　　Besides the algorithm description, there's one more thing to mention. To treat cases like "abba" and "aba", you don't have to write two copies of code, just insert some delimiter like '#' between every character will solve the problem.

　　One last thing, this version of code put an extra character at the front, purely for the convenience of coding. If you've got your own way to make the code look short and clean, please share it with me.

　　Time and space complexities are both O(n).

Accepted code:

// 1CE, 2WA, 1AC, this really wasn't easy to understand..
class Solution {
public:
    string longestPalindrome(string s) {
        int len = (int)s.length();
        int nlen;
        int i, j;
        char *ss;
        int *p;
        
        nlen = 2 * len + 2;
        ss = new char[nlen + 1];
        p = new int[nlen + 1];
        
        // insert '#' between every character.
        nlen = 0;
        ss[nlen++] = '$';
        for (i = 0; i < len; ++i) {
            ss[nlen++] = '#';
            ss[nlen++] = s[i];
        }
        ss[nlen++] = '#';
        ss[nlen] = 0;
        
        // the farthest position the current palindromic string can reach.
        int mx_pos;
        // the index i that reaches this farthest position.
        int id;
        
        // the Manacher algorithm
        p[0] = 0;
        mx_pos = 0;
        for (i = 1; i < nlen; ++i) {
            p[i] = 1;
            if (mx_pos > i) {
                p[i] = p[2 * id - i];
                if (mx_pos - i < p[i]) {
                    p[i] = mx_pos - i;
                }
            }
            
            while (ss[i - p[i]] == ss[i + p[i]]) {
                ++p[i];
            }
            
            if (i + p[i] > mx_pos) {
                mx_pos = i + p[i];
                id = i;
            }
        }
        
        // find the maximal value
        int result = 0;
        int ri;
        string res_str;
        char *res;
        res = new char[len + 1];
        for (i = 0; i < nlen; ++i) {
            if (p[i] > result) {
                ri = i;
                result = p[i];
            }
        }
        
        len = 0;
        for (i = ri - p[ri] + 1; i <= ri + p[ri] - 1; ++i) {
            if ((i > 0) && ((i & 0x1) == 0)) {
                // odd positions are inserted with '#'
                // 0th position is inserted with '$'
                res[len++] = ss[i];
            }
        }
        res[len] = 0;
        res_str = string(res);
        
        delete [] res;
        delete [] p;
        delete [] ss;
        
        return res_str;
    }
};