LeetCode "Palindrome Pairs"

My first reaction was to use Manacher - which is O(n*k*k) - n is the no. of words, and k is the average length of words.

Code of Manacher based solution is kinda long:

class Solution {
    vector<vector<int>> ret;

    //    To find lenghth of the leading Palin only
    vector<string> manacher(const string &s)
    {
        size_t slen = s.length();
        if (slen < 2) return { s };
        
        //    inserting tokens to original string
        string ns = "#";
        for (auto c : s)
        {
            ns += c;
            ns += "#";
        }

        //
        size_t len = ns.length();
        vector<size_t> rec(len, 0);

        int maxi = 1, maxr = 0; vector<int> rs_leading;
        int ci = 1, r = 0;
        for (size_t i = 1; i < len; i++)
        {
            int myr = 0;        //    brand new index
            if (i <= (ci + r))    //    can be reused due to symmetry
            {
                myr = std::min(rec[2 * ci - i], (ci + r) - i);
            }
            //    expand to new inx towards end of string
            bool bMis = false;
            int max_ex = std::min(len - 1 - i, i);
            while (myr < max_ex)
            {
                myr++;
                if (ns[i + myr] != ns[i - myr])
                {
                    bMis = true;
                    break;
                }
            }
            if (bMis) myr--;

            //    book-keeping
            rec[i] = myr;
            if ((i + myr) > (maxi + maxr))
                ci = i, r = myr;

            if (myr > maxr)    //     record max
            {
                maxi = i, maxr = myr;
                if (i == myr)
                {
                    rs_leading.push_back(maxr);
                }
            }
        }

        //    Retrieve the Palin
        vector<string> ret;
        for (auto l : rs_leading)
        {
            string raw = ns.substr(0, l * 2 + 1);
            string tmp;
            for (auto c : raw)
            {
                if (c != '#') tmp += c;
            }
            ret.push_back(tmp);
        }
        return ret;
    }

    void handleLeadingPalin(string w, int inxw, unordered_map<string, int> &dict, bool bReversed)
    {
        vector<string> hPalins = manacher(w);
        for (auto hPalin : hPalins)
        {
            int plen = hPalin.size();
            if (plen)
            {
                string tgt = w.substr(plen);
                if (!bReversed)
                    reverse(tgt.begin(), tgt.end());
        
                if (dict.find(tgt) != dict.end())
                {
                    int inxt = dict[tgt];
                    if (inxw != inxt)
                    {
                        if (!bReversed)
                            ret.push_back({ inxt, inxw });
                        else
                            ret.push_back({ inxw, inxt});
                    }
                }
            }
        }
    }
public:
    vector<vector<int>> palindromePairs(vector<string>& words) {
        
        //    Fill out String <-> Index dictionary
        unordered_map<string, int> dict;
        for (int i = 0; i < words.size(); i ++)
            dict[words[i]] = i;
                
        //    Go
        for (auto &k : dict)
        {
            int inx = k.second;

            // case 1: reverse the whole string
            string tgt1 = k.first;

            reverse(tgt1.begin(), tgt1.end());
            if (dict.find(tgt1) != dict.end())
            {
                int inx1 = dict[tgt1];
                if (inx1 != inx)
                    ret.push_back({inx, inx1});
            }

            // case 2a: leading manacher of key
            handleLeadingPalin(k.first, inx, dict, false);
            
            // case 2b: leading manacher of reverse(key)
            string tmp = k.first;
            reverse(tmp.begin(), tmp.end());
            handleLeadingPalin(tmp, inx, dict, true);
        }

        return ret;
    }
};

And please check this concise Python solution - so neat!

https://leetcode.com/discuss/91284/python-solution