336. Palindrome Pairs（C++实现）
本文给出五种C++程序实现的代码！前三种解答程序，已Accepted ！是从网上整理来的，加上本人一些分析和代码备注，让看的朋友更容易理解。
解答思路一：（最快解答）
用哈希表来建立每个单词和其位置的映射，一个set来保存出现过的单词的长度。
算法的思想是，遍历单词集，对于遍历到的单词，我们对其翻转一下，然后在哈希表查找翻转后的字符串是否存在，注意不能和原字符串的坐标位置相同，因为有可能一个单词翻转后和原单词相等，现在我们只是处理了bat和tab的情况，还存在abcd和cba，dcb和abcd这些情况需要考虑，这就是我们为啥需要用set，由于set是自动排序的，我们可以找到当前单词长度在set中的iterator，然后从开头开始遍历set，遍历比当前单词小的长度，比如abcdd翻转后为ddcba，我们发现set中有长度为3的单词，然后我们dd是否为回文串，若是，再看cba是否存在于哈希表，若存在，则说明abcdd和cba是回文对，存入结果中，对于dcb和aabcd这类的情况也是同样处理，我们要在set里找的字符串要在遍历到的字符串的左边和右边分别尝试，看是否是回文对，这样遍历完单词集，就能得到所有的回文对
<span style="font-size:18px;">class Solution {
public:
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) {//反转单词在map中，并且不是同一个单词，加入结果，如单词表中有两单词aba 和 aba
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))) {//反转单词aaba，若set中存在单词ba，且前半部分aa为回文。
res.push_back({i, m[t.substr(len - d)]});
}
if (isValid(t, d, len - 1) && m.count(t.substr(0, d))) {//反转单词baaa，若set中存在单词ba，且后半部分aa为回文。
res.push_back({m[t.substr(0, d)], i});
}
}
}
return res;
}
bool isValid(string t, int left, int right) {//判断单词t[left]到t[right]是否构成回文。
while (left < right) {
if (t[left++] != t[right--]) return false;
}
return true;
}
};</span>
解答思路二：（很容易想到的算法）
考虑所有构成回文的情况
1 存在空单词；遍历所有单词，找回文单词，如{“aa”，“”}
2 将单词反转，若反转后的单词在单词表中，这两个单词构成回文！如{“abc”，“cba”}
3 将每个单词都分成左右两部分，（将aabc分两部分： a abc；aa bc；aab c；）
若左半部分是回文，则反转右半部分，查看单词表中是否存在右半部分的反转单词；如cb与aabc构成回文。
若右半部分是回文，则反转左半部分，查看单词表中是否存在左半部分的反转单词；如aabc与baa构成回文。
class Solution {
public:
vector<vector<int>> palindromePairs(vector<string>& words) {
vector<vector<int>> res;
vector<int> temp(2);
multimap<string,int> map;
for (int i = 0; i < words.size(); ++i) {
map.insert(pair<string,int>(words[i],i));
}
//若有单词为空，则找到所有本身是回文的单词
if(map.find("")!=map.end()){
int k=(map.find(""))->second;
for(int i = 0; i < words.size(); ++i){
if(isPalindrome(words[i])&&i!=k){
temp[0]=k;
temp[1]=i;
res.push_back(temp);
temp[0]=i;
temp[1]=k;
res.push_back(temp);
}
}
}
for (int i = 0; i < words.size(); ++i) {//遍历一遍所有的单词
string word = words[i];
int n = word.size();
for(int j=1;j<n;++j){
//把单词分成左右两部分left，right
string left=word.substr(0,j);
string right=word.substr(j);
if(isPalindrome(right)){//若单词右半部分是回文
reverse(left.begin(), left.end());//左半部分反转
if(map.find(left)!=map.end()&&(map.find(left)->second)!=i){
temp[0]=i;
temp[1]=map.find(left)->second;
res.push_back(temp);
}
}
if(isPalindrome(left)){//若单词左半部分是回文
reverse(right.begin(),right.end());//右半部分反转
if(map.find(right)!=map.end()&&(map.find(right)->second)!=i){
temp[0]=map.find(right)->second;
temp[1]=i;
res.push_back(temp);
}
}
}
//反转整个单词，看反转单词是否在单词表中
reverse(word.begin(), word.end());
if(map.find(word)!=map.end()&&(map.find(word)->second)!=i){
temp[0]=i;
temp[1]=map.find(word)->second;
res.push_back(temp);
}
}
return res;
}
bool isPalindrome(string s) {//判断单词s是否构成回文。
int i=0;
int j=s.size()-1;
while (i<j) {
if (s[i++] != s[j--]) return false;
}
return true;
}
};
解题思路三：（还不错的解答，思路较复杂）
用长度为两个单词数的向量expand，保存所有单词及其对应下标（用true标记），也保存所有单词的反转单词及其原单词对应的下标（用false标记）。
对expand初始化，然后进行排序。排序是为了提高检索速度，使相同单词或者相近单词在位置上保存相近，若发现完全不匹配的单词，就可以直接跳出二层循环，结束当前单词的匹配。
能构成回文的情况有三种： abc和cba，abaa与ab，aaba与ab。第一种反转后的单词与原单词完全相同，第二种情况和第三种情况，除去相同部分，剩余部分构成回文。
程序中的函数isPalin()，返回一个整形数，返回3包含了能构成回文的三种情况，即为所求！返回2代表当前单词不匹配，继续验证expand中的下一个单词；返回1代表当前反转单词与当前expand中的其他单词没有匹配的，不需要再向后匹配，即跳出二层循环！
<span style="font-size:18px;">class Solution {
public:
vector<vector<int> > palindromePairs(vector<string>& words) {
int size = words.size();
vector<vector<int> > result;//保存得到的结果
vector<pair<string, pair<int, bool> > > expand(size*2);//保存单词和对应的下标，反转每个单词后，保存反转单词及原来的下标
for(int i = 0; i < size; ++i)
expand[i] = pair<string, pair<int, bool> >(words[i], pair<int, bool>(i, true));//保存单词和对应的下标。原单词都标记为true
for(int i = 0; i < size; ++i)
{
reverse(words[i].begin(), words[i].end());//反转每个单词
expand[i+size] = pair<string, pair<int,bool> >(words[i], pair<int, bool>(i, false));//保存反转后的单词及原单词对应的下标，反转单词标记false
}
sort(expand.begin(), expand.end());//对向量进行排序，向量中存储的是pair<string,pair<int,bool>>,所以比较顺序是单词、下标、bool
for(int i = 0; i < size*2; ++i)
{
bool flag = true;
for(int j = i+1; j < size*2 && flag; ++j)
{
if(expand[i].second.first == expand[j].second.first) //下标相同，即为同一个单词，跳过
continue;
if(! (expand[i].second.second ^ expand[j].second.second) )//同为false，即两个都是反转单词，跳过
continue;
int type = isPalin(expand[i].first, expand[j].first);//判断两个单词的情况：1有字母不同；2长度不同，且长单词剩余部分不是回文；3两个单词构成回文。
switch(type)
{
case 1: flag = false; break;//情况1，其后的单词不用再比较，直接跳过（因expand中已经排好序，相同单词必定挨着。）
case 2: break;//情况2，进行下一轮比较
case 3: //情况3，两个单词可以构成回文，将单词下标加入result
int u = expand[i].second.second?expand[i].second.first:expand[j].second.first;
int v = expand[i].second.second?expand[j].second.first:expand[i].second.first;
vector<int> tmp(2); tmp[0] = u; tmp[1] = v;
result.push_back(tmp);
break;
}
}
}
return result;
}
private:
//return 1 means a and b don't have proper prefix
//return 2 means a and b do have proper prefix,
//but the trailing part is not palindrome
//return 3 means a and b do have proper prefix,
//and the trailing part is palindrome
int isPalin(string &a, string &b)
{
int size1 = a.size(), size2 = b.size();
int i = 0;
while(i < size1 && i < size2)
{
if(a[i] != b[i]) return 1;//单词中相同位置的字母不匹配 如单词 abc 和 bde
++i;
}
if(i < size1)
{
int j = size1-1;
while(i < j)
{
if(a[i] != a[j])
return 2;//多余部分不是回文 如abce 和 ab
++i;
--j;
}
}
else if(i < size2)
{
int j = size2-1;
while(i < j)
{
if(b[i] != b[j])//多余部分不是回文，如ab 和 abed
return 2;
++i;
--j;
}
}
return 3;//两个单词完全相同，或者多余部分是回文，如abc 和 abc；又如abcc 和 ab
}
};</span>
解题思路三：暴力解法：运行超时！
<span style="font-size:18px;">class Solution {
private:
bool palindrome(string s){
int n=s.size();
int i=0;
while(i<n/2){
if(s[i]!=s[n-i-1])return false;
++i;
}
return true;
}
public:
vector<vector<int>> palindromePairs(vector<string>& words) {
vector<int> v1(2);
vector<vector<int>> res;
int n=words.size();
int j=0;
while(j<n){
string s=words[0];
v1[0]=j;
for(int i=1;i<n;++i){
s=words[0];
s+=words[i];
if(palindrome(s)){
if(i<=j)
v1[1]=i-1;
else
v1[1]=i;
res.push_back(v1);
}
}
++j;
if(j<=n-1){
string temp=words[0];
words[0]=words[j];
words[j]=temp;
}
}
return res;
}
};</span>
解题思路四：暴力解法：运行超时！
<span style="font-size:18px;">class Solution {
private:
bool palindrome(string s1,string s2){
int i=0;
int j=s2.size()-1;
while(i<s1.size()&&j>=0){
if(s1[i]!=s2[j])
return false;
++i;
--j;
}
if(s1.size()>s2.size()){
j=s1.size()-1;
while(i<j){
if(s1[i]!=s1[j])
return false;
++i;
--j;
}
}else if(s1.size()<s2.size()){
i=0;
while(i<j){
if(s2[i]!=s2[j])
return false;
++i;
--j;
}
}
return true;
}
public:
vector<vector<int>> palindromePairs(vector<string>& words) {
vector<int> v1(2);
vector<vector<int>> res;
int n=words.size();
for(int i=0;i<n;++i){
for(int j=0;j<n;++j){
if(i!=j&&palindrome(words[i],words[j])){
v1[0]=i;
v1[1]=j;
res.push_back(v1);
}
}
}
return res;
}
};</span>