LeetCode: Palindrome Pairs

这个问题需要我们判断给定的一系列字符串中，能够构成回文字符串的字符串对有哪些？那么一个经典思路就是采用暴力求解，两个循环撸出来。

暴力求解

vector<vector<int>> palindromePairs(vector<string>& words) {
    vector<vector<int>> result;
    for (int i = 0; i<words.size(); i++){
        for (int j = 0; j < words.size(); j++){
            if (j != i){
                string tail = words[j];
                string head = words[i];
                head += tail;
                //  Determine whether string is palindrome
                int found = 1;
                if (head.empty())
                    found = -1;
                else{
                    int len = head.length();
                    for (int k = 0; k < len / 2; k++){
                        if (head[k] != head[len - k - 1]){
                            found = 0;
                            break;
                        }
                    }
                }
                //  Store the palindrome pair
                if (found == 1){
                    result.push_back({ i, j });
                }
            }
        }
    }

    return result;
}

不过这题难就难在会超时，所以一定要修改。一个新的思路是，对每个字符串与比它短的字符串进行首尾匹配，比它长的字符串可以进行一个交换，之后的思路还是一样的。一个例子，字符串“bbbbbbbbcasfsdfsd”，与比它短的字符串“dsf”匹配，匹配成功后对剩下的字符串“bbbbbbbbcasfsd”进行回文判断；当满足上面两个条件时，则返回回文对。

修改后的算法

vector<vector<int>> palindromePairs(vector<string>& words) {
    vector<vector<int>> result;
    vector<int> wordLength;
    unordered_map<string, int> map;
    for (int i = 0; i < words.size(); i++){
        map[words[i]] = i;
        wordLength.push_back(words[i].length());
    }
    for (int i = 0; i < words.size(); i++){
        string str = words[i];
        int length = str.length();
        reverse(str.begin(), str.end());
        //  Find words of same length
        if (map.count(str) && map[str] != i)
            result.push_back({ i, map[str] });
        //  Deal with words of different length
        sort(wordLength.begin(), wordLength.end());
        vector<int>::iterator iter = find(wordLength.begin(), wordLength.end(), length);
        for (vector<int>::iterator it = wordLength.begin(); it != iter; it++){
            int shorterLength = *it;
            //  Forward matching
            if (map.count(str.substr(0, shorterLength)))
                if (isValid(str, shorterLength, length - 1))
                    result.push_back({ map[str.substr(0, shorterLength)], i });
            //  Backward matching
            if (map.count(str.substr(length - shorterLength)))
                if (isValid(str, 0, length - shorterLength - 1))
                    result.push_back({ i, map[str.substr(length - shorterLength)] });
        }
    }

    return result;
}

这里可能用到了一个unordered_map，主要是解决题目假设：自身与自身不能形成回文对。但是很不幸，这个还是超时了…….0.0。后来网上看到了一个别人的解法，思路类似，但是由于它在存储短的字符串的长度时用了set（自动排序且自动去重），这就大大加快了算法计算速度。（我还是太年轻了= =）

最终提交版本

vector<vector<int>> palindromePairs(vector<string>& words) {
    vector<vector<int>> res;
    unordered_map<string, int> m;
    set<int> s;
    for (int i = 0; i < words.size(); ++i) {
        m[words[i]] = i;
        s.insert(words[i].size());
    }
    for (int i = 0; i < words.size(); ++i) {
        string t = words[i];
        int len = t.size();
        reverse(t.begin(), t.end());
        if (m.count(t) && m[t] != i) {
            res.push_back({ i, m[t] });
        }
        auto a = s.find(len);
        for (auto it = s.begin(); it != a; ++it) { 
            int d = *it;
            if (isValid(t, 0, len - d - 1) && m.count(t.substr(len - d))) {
                res.push_back({ i, m[t.substr(len - d)] });
            }
            if (isValid(t, d, len - 1) && m.count(t.substr(0, d))) {
                res.push_back({ m[t.substr(0, d)], i });
            }
        }
    }
    return res;
}