LeetCode Shortest Palindrome

Given a string S, you are allowed to convert it to a palindrome by adding characters in front of it. Find and return the shortest palindrome you can find by performing this transformation.

For example:

Given "aacecaaa", return "aaacecaaa".

Given "abcd", return "dcbabcd".

Credits:
Special thanks to @ifanchu for adding this problem and creating all test cases. Thanks to @Freezen for additional test cases.

先来个直接的，就是求出从字符串起始处开始的最长回文串，如果有这样的回文串存在（必然存在，单个字符就是一个回文串，但找到的回文串长度越长，补全后的回文串整体长度就越小），我们只需要以这个找到的回文串为中心，再在字符串前补全即可。但是TLE

class Solution {
public:
    string shortestPalindrome(string s) {
        int len = s.size();
        int idx;
        for (idx=len; idx>0; idx--) {
            if (isPar(s, 0, idx)) {
                break;
            }
        }
        string mirror;
        for (int i=len - 1; i>=idx; i--) {
            mirror.push_back(s[i]);
        }
        return mirror + s;
    }
    
    bool isPar(string& s, int start, int end) {
        int p = start;
        int q = end - 1;
        while (p < q) {
            if (s[p] != s[q]) {
                return false;
            }
            p++, q--;
        }
        return true;
    }
};

一样的思路，别人的就简洁很多 ，92ms

class Solution {
public:
    string shortestPalindrome(string s) {
        string s2=s;
        reverse(s2.begin(),s2.end());
        int n=s.size(),l;
        for(l=n;l>=0;l--)
        {
            if(s.substr(0,l)==s2.substr(n-l))
                break;
        }
        return s2.substr(0,n-l)+s;
    }
};

 还是一样的思路，但是加入高效求回文串的过程(manacher's algorithm，见另一篇自己博客图解，网上资料也很多)，时间8ms，速度提高太多了

class Solution {
public:
    string shortestPalindrome(string s) {
        string ss("$");
        for (int i=0; i<s.size(); i++) {
            ss.push_back(s[i]);
            ss.push_back('$');
        }
        
        int len = ss.size();
        vector<int> pl(len, 1);
        
        int far = 0;
        int mid = 0;
        int longest = 0;
        int mirror = 0;
        
        for (int i=0; i<len; i++) {
            int cfar = i;
            
            // if this index is covered by exist palindrome
            if (far > i) {
                mirror = 2 * mid - i;
                cfar = min(pl[mirror], far - i) + cfar;
            }
            // spread out
            while (cfar < len && (2 * i - cfar >= 0) && ss[cfar] == ss[2 * i - cfar]) {
                cfar++;
            }
            // current palindrome single part length(incuded middle character)
            pl[i] = cfar - i;
            
            // update right farest index covered by palindrome
            if (cfar > far) {
                mid = i;
                far = cfar;
            }
            // is this palindrome start from s[0]?
            if (2 * i - cfar == -1) {
                // index i in ss is just the palindrome length in s(original string)
                longest = i;
            }
        }
        
        string str = s.substr(longest);
        reverse(str.begin(), str.end());
        
        return str + s;
    }
};

 discuss里还有用KMP做的，不过KMP不熟，以后再写。

改写一下：

class Solution {
public:
    string shortestPalindrome(string s) {
        if (s.size() < 2) {
            return s;
        }
        int plen = palindrome(s);
        string left = s.substr(plen);
        reverse(left.begin(), left.end());
        return left + s;
    }
    
    int palindrome(string& s) {
        string ms(s.size() * 2 + 1, '$');
        int i = 0;
        for (char ch : s) {
            ms[i++ * 2 + 1] = ch;
        }
        int mlen = ms.size();
        vector<int> lens(mlen, 0);
        
        int far = 0;
        int lcenter = 0;
        
        int maxlen = 2;
        for (int i=0; i<mlen; i++) {
            int p = i, q = i;
            if (i < far) {
                int mirror = 2 * lcenter - i;
                int step = min(lens[mirror], far - i);
                p -= step;
                q += step;
            }
            while (p >= 0 && q < mlen && ms[p] == ms[q]) {
                p--, q++;
            }
            if (q > far) {
                far = q;
                lcenter = i;
            }
            lens[i] = q - i;
            if (p < 0) {
                maxlen = max(maxlen, lens[i]);
            }
        }
        return (maxlen * 2 - 1) / 2;
    }
};