LeetCode-336.回文对、字典树、字符串翻转

给定一组唯一的单词， 找出所有不同 的索引对(i, j)，使得列表中的两个单词， words[i] + words[j] ，可拼接成回文串。
示例 1:
输入: [“abcd”,“dcba”,“lls”,“s”,“sssll”]
输出: [[0,1],[1,0],[3,2],[2,4]]
解释: 可拼接成的回文串为 [“dcbaabcd”,“abcddcba”,“slls”,“llssssll”]
来源：力扣（LeetCode）第336题

字典树

1. 概念
   字典树又称单词查找树、前缀树，是一种树形结构，利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，比哈希表更快。
2. 基本性质
   ①．根节点不包含字符，除根节点外每个节点都只包含一个字符；
   ②．从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串；
   ③．每个节点的所有子节点包含的字符都不相同。

题目分析

如果字符串 S1 + S2 能构成一个回文串，把 S1 分成 S1_1 和 S1_2 两部分，可以有以下以下两种拼接情况：
①．S2 拼接在前，并且 S1_1 是回文串、 S1_2 是 S2 的逆序；
②．S2 拼接在后，并且 S1_2 是回文串、 S1_1 是 S2 的逆序；

代码示例

//字典树节点
class TrieNode
{
private:
    bool isEnd;//单词结束标记
    int index;//单词序号
    vector<TrieNode*> children;//子节点
public:
    //构造
    TrieNode():index(-1),isEnd(false),children(26,nullptr){}
    //析构
    ~TrieNode()
    {
        for(int i = 0;i < 26;i++)
        {
            if( children[i]) 
            {
                delete children[i];
                children[i] = nullptr;
            }
        }
    }
    //对外接口
    int getIndex() { return index;}
    void setIndex( int i) { index = i;}
    bool isWordEnd() { return isEnd;}
    void SetEnd(){ isEnd = true ;}
    //插入一个字符到子节点
    TrieNode * insertNode(char c)
    {
        if( !( 'a' <= c <= 'z')) return nullptr;
        int id = c-'a';
        if( children[id] == nullptr)
        {
            children[id] = new TrieNode();
            
        }
        return children[id];
    }
    //在子节点中查找一个字符
    TrieNode * getNode(char c)
    {
         if( !( 'a' <= c <= 'z')) return nullptr;
         int id = c-'a';
         return children[id] ;
    }
};
//字典树
class Trie
{
private:
    TrieNode * root;//根节点
public:
    Trie():root(new TrieNode()){}
    ~Trie()  { delete root;}  
    //插入一个单词及序号
    void insert( string word,int index)
    {
        TrieNode * p = root;
        for( int i = 0;i<word.size();i++)
        {
            p = p->insertNode(word[i]);
        }
        p->SetEnd();
        p->setIndex(index);
    }
    //查找一个字符串
    TrieNode *getNode(string word)
    {
        TrieNode * p = root;
        for(int i = 0;i < word.size();i++ )
        {
            p = p->getNode(word[i]) ;
            if( p == NULL ) return NULL;
        }
        return p;
    }
    //查找一个单词，返回序号
    bool  search(string word,int  &index)
    {
      
        TrieNode * p = getNode(word);
        if( p )
        {
            index = p->getIndex();
            return  p->isWordEnd();
        }
        return false;
    }
    

};
class Solution {
public:
    vector<vector<int>> palindromePairs(vector<string>& words) {
        vector<vector<int>> res;
        //构建字典树
        Trie * trieTree = new Trie();
        for(int i = 0;i < words.size();i++)
        {
            trieTree->insert(words[i],i);
        }
        for(int i = 0;i < words.size();i++)
        {
            for(int j = 0;j < words[i].size();j++ )
            {
                bool flag = check(words[i],0,j);
                if(flag)//前半截是回文
                {
                    string temp = words[i].substr(j+1);
                    reverse(temp.begin(),temp.end());
                    int index = -1;
                    if( trieTree->search(temp,index) )
                    {
                        if( i != index  )
                        {
                             res.push_back({index,i});
                             if( temp == "")
                             {
                                 res.push_back({i,index});
                             }
                        }
                           
                    }
                }
                flag = check(words[i],j+1,words[i].size()-1);
                if(flag)//后半截是回文
                {
                        string temp = words[i].substr(0,j+1);
                        reverse(temp.begin(),temp.end());
                        int index = -1;
                        if( trieTree->search(temp,index) )
                        {
                            if( i != index  )
                                res.push_back({i,index});
                        }
                }    
            }
        }
        return res;
    }
    bool check(string &vec,int left,int right)
    {
        int i = left;
        int j = right;
        while(i <= j)
        {
            if( vec[i] != vec[j]) return false;
            i++;
            j--;
        }
        return true;
    }
};