Leetcode Palindrome Pairs

Leetcode Palindrome Pairs，本算法的重点是通过hash表来保存映射。对于word，从正向推开始，我们记录其每一个substring，从反向我们也记录其每一个substring，并且保证除去substring后的剩于串是palindrome，这样对于查找时，可以知道，对于其它的word，如果其反转与substring相等，则知道他们加起来可以构成回文串，对于谁在前，谁在后，则根据从哪个hash map中查找结果。设给出的数据中字母个数为num，则时间复杂度为O(num)。相关代码如下：

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>

using namespace std;
class Solution {
public:
    vector<vector<int>> palindromePairs(vector<string>& words) {
        map<string, vector<int> > record_forward;
        map<string, vector<int> > record_backward;
        vector<vector<int> > re;
        vector<int> re_pair(2, 0);
        string tmp;
        for (int i = 0; i < words.size(); i++) {
            if (words[i] == "") {
                for (int k = 0; k < words.size(); k++) {
                    if (k != i && checkpalindrome(words[k])) {
                        re_pair[0] = i;
                        re_pair[1] = k;
                        re.push_back(re_pair);
                        re_pair[0] = k;
                        re_pair[1] = i;
                        re.push_back(re_pair);
                    }
                }
                continue;
            }
            for (int len = 1; len <= words[i].length(); len++) {
                if (checkpalindrome(words[i].substr(len, string::npos))) {
                    tmp = words[i].substr(0, len);
                    if (record_forward.find(tmp) == record_forward.end()) {
                        record_forward[tmp] = vector<int>(1, i);
                    } else {
                        record_forward[tmp].push_back(i);
                    }
                }
            }
            for (int len = 1; len <= words[i].length(); len++) {
                if (checkpalindrome(words[i].substr(0, len))) {
                    tmp = words[i].substr(len, string::npos);
                    if (record_backward.find(tmp) == record_backward.end()) {
                        record_backward[tmp] = vector<int>(1, i);
                    } else {
                        record_backward[tmp].push_back(i);
                    }
                }
            }
        }
        for (int i = 0; i < words.size(); i++) {
            if (words[i] == "") {
                continue;
            }
            tmp = words[i];
            reverse(tmp.begin(), tmp.end());
            if (record_forward.find(tmp) != record_forward.end()) {
                re_pair[1] = i;
                for (auto idx: record_forward[tmp]) {
                    if (idx != i) {
                        re_pair[0] = idx;
                        re.push_back(re_pair);
                    }
                }
            }
            if (record_backward.find(tmp) != record_backward.end()) {
                re_pair[0] = i;
                for (auto idx: record_backward[tmp]) {
                    if (idx != i) {
                        re_pair[1] = idx;
                        re.push_back(re_pair);
                    }
                }
            }
        }
        return re;
    }

    bool checkpalindrome(string str) {
        for (int i = 0; i < str.length() / 2; i++) {
            if (str[i] != str[str.length() - 1 - i]) {
                return false;
            }
        }
        return true;
    }
};

int main(int argc, char * argv[]) {
    Solution so;
    vector<string> test;
    for (int i = 1; i < argc; i ++) {
        test.push_back(string(argv[i]));
    }
    vector<vector<int> > re = so.palindromePairs(test);
    cout<<"re: ";
    for (auto ele: re) {
        cout<<"["<<ele[0]<<", "<<ele[1]<<"], ";
    }
    cout<<endl;
    return 0;
}

测试：./a.out aab baa cdd eff e f
结果：re: [1, 0], [0, 1], [3, 4],