leetcode 336. Palindrome Pairs

Given a list of unique words, find all pairs of distinct indices (i, j) in the given list, so that the concatenation of the two words, i.e. words[i] + words[j] is a palindrome.

Example 1:

Input: ["abcd","dcba","lls","s","sssll"]
Output: [[0,1],[1,0],[3,2],[2,4]] 
Explanation: The palindromes are ["dcbaabcd","abcddcba","slls","llssssll"]

Example 2:

Input: ["bat","tab","cat"]
Output: [[0,1],[1,0]] 
Explanation: The palindromes are ["battab","tabbat"]

给定一组唯一的单词， 找出所有不同 的索引对(i, j)，使得列表中的两个单词， words[i] + words[j] ，可拼接成回文串。

示例 1:

输入: ["abcd","dcba","lls","s","sssll"]
输出: [[0,1],[1,0],[3,2],[2,4]] 
解释: 可拼接成的回文串为 ["dcbaabcd","abcddcba","slls","llssssll"]
示例 2:

输入: ["bat","tab","cat"]
输出: [[0,1],[1,0]] 
解释: 可拼接成的回文串为 ["battab","tabbat"]

解题思路：

(回文串，哈希表) O(nL2)O(nL2)
首先，我们先来分析一下两个单词组成的回文串有什么性质。如下图所示：

① a                    b           c               和                c                      d
ac和cd分别表示两个单词。我们在线段中找到b点，使得 ab 和 cd 互为逆序 ， 且bc为回文串。
则ad为回文串 。

②         a            b                    c              和              d                    e

ac和de分别表示两个单词。我们在线段中找到b点，使得cb等于de ， 且ab为回文串 。 则deac为回文串 。

所以我们可以将所有单词存入哈希表，然后先枚举每个单词，再枚举每个单词的b点的位置，然后在哈希表中查找是否存在一个单词和ab相等，且bc是回文串，如果是 true，则找到了一组解；以及在哈希表中查找是否有单词cb等于de，且ab是回文串，如果是true，则找到一组解 ；

时间复杂度分析：令 nn 表示单词个数，LL 表示单词的平均长度。枚举单词的计算量是 O(n)O(n)，对每个单词枚举b点的位置的计算量是 O(L)O(L)，判断回文串的计算量是 O(L)O(L)，所以总时间复杂度是 O(nL2)O(nL2)。

class Solution {
public:
    vector<vector<int>> palindromePairs(vector<string>& words) 
    {
        unordered_map<string , int > wordmap ;
        vector<vector<int>> ans ;
        for(int i = 0 ; i < words.size() ; ++i)
        {
            string s = words[i] ;
            wordmap[s] = i ;
        }
        
        for(int i = 0 ; i < words.size() ; ++i)
        {
            string word = words[i] ;
            string wordr = word ;
            reverse(wordr.begin() , wordr.end()) ;
            int len = word.size() ;
            for(int  j = 0 ; j <= len ; j++)
            {
                string s = word.substr(0 , j ) ;
                string t = wordr.substr(0 , j ) ;
                reverse(s.begin() , s.end() ) ;
                if(wordmap.count(s) && ispalinpair(word.substr(j)))
                {
                    if(i != wordmap[s])
                    {
                        ans.push_back({i , wordmap[s]}) ;
                    }
                }
                
                if(j < len  && wordmap.count(t)  && ispalinpair(wordr.substr(j ))) 
                {
                    if(i != wordmap[t])
                    {
                        ans.push_back({wordmap[t] , i}) ;
                    }
                }
            }

        }
        
        return ans ;
    }
    
    bool ispalinpair(string s)
    {
        
        string w = s ;
        reverse(w.begin() , w.end()) ;
        
        return s == w ;
    }
};