Trie for string LeetCode

Trie build and search

 class TrieNode
 {
 public:
     TrieNode * next[];
     bool is_word;
     TrieNode(bool b = false)
     {
         memset(next,,sizeof(next));
         is_word = b;
     }
 };
 class Trie {
     TrieNode* root;
 public:
     /** Initialize your data structure here. */
     Trie() {
         root = new TrieNode();
     }

     /** Inserts a word into the trie. */
     void insert(string word) {
         TrieNode* p = root;
         for(int i=;i<word.size();i++)
         {
             if(p->next[word[i]-'a']==NULL)
                 p->next[word[i]-'a']=new TrieNode();
             p = p->next[word[i]-'a'];
         }
         p->is_word=true;
     }

     /** Returns if the word is in the trie. */
     bool search(string word) {
         TrieNode* p = find(word);
         return p&&p->is_word;
     }

     /** Returns if there is any word in the trie that starts with the given prefix. */
     bool startsWith(string prefix) {
         return find(prefix);
     }

     TrieNode* find(string word)
     {
         TrieNode* p = root;
         for(int i=;i<word.size();i++)
             if(p->next[word[i]-'a']==NULL)return NULL;
             else p=p->next[word[i]-'a'];
         return p;
     }
 };

 /**
  * Your Trie object will be instantiated and called as such:
  * Trie obj = new Trie();
  * obj.insert(word);
  * bool param_2 = obj.search(word);
  * bool param_3 = obj.startsWith(prefix);
  */

加 . 正则匹配一个任意字母 ，递归处理，注意p应指向当前遍历字母对应的结点

 class TrieNode
 {
 public:
     TrieNode *next[];
     bool is_word;

     TrieNode(bool b = false)
     {
         memset(next, , sizeof(next));
         is_word = b;
     }
 };

 class WordDictionary {
 public:
     /** Initialize your data structure here. */
     WordDictionary() {
         root = new TrieNode();
     }

     /** Adds a word into the data structure. */
     void addWord(string word) {
         TrieNode *p = root;
         for (int i = ; i < word.size(); i++)
         {
             if (p->next[word[i] - 'a'] == NULL)
                 p->next[word[i] - 'a'] = new TrieNode();
             p = p->next[word[i] - 'a'];
         }
         p->is_word = true;
     }

     /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
     bool search(string word) {
         return query(word.c_str(), root);
     }

 private:
     TrieNode* root;
     bool query(const char* word, TrieNode* node)
     {
         TrieNode* p = node;
         for (int i = ; word[i]; i++)
         {
             if (p && word[i] != '.')
                 p = p ->next[word[i] - 'a'];
             else if (p && word[i] == '.')
             {
                 TrieNode* tmp=p;
                 for (int j = ; j < ; j++)
                 {
                     p = tmp -> next[j];
                     if (query(word + i + , p))
                         return true;
                 }
             }
             else break;
         }
         return p && p -> is_word;
     }
 };
 /**
  * Your WordDictionary object will be instantiated and called as such:
  * WordDictionary obj = new WordDictionary();
  * obj.addWord(word);
  * bool param_2 = obj.search(word);
  */

word search II

1. word list insert to Trie

2. dfs search

 class TrieNode
 {
 public:
     TrieNode *next[];
     string word;

     TrieNode()
     {
         memset(next, , sizeof(next));
         word = "";
     }
 };

 class Trie
 {

 public:
     TrieNode* root;
     Trie()
     {
         root = new TrieNode();
     }

     void insert(string s)
     {
         TrieNode *p = root;
         for (int i = ; i < s.size(); i++)
         {
             if (p->next[s[i] - 'a'] == NULL)
                 p->next[s[i] - 'a'] = new TrieNode();
             p = p->next[s[i] - 'a'];
         }
         p->word = s;
     }

 };

 void dfs(int i, int j, TrieNode* p, vector<vector<char>>& board, vector<string> &res)
 {
     char c = board[i][j];
     if (c == '#' || p->next[c - 'a'] == NULL)return;
     p = p->next[c - 'a'];
     if (p->word != "")
     {
         res.push_back(p->word);//找到
         p->word = "";//去重
     }
     board[i][j] = '#';
     if (i > )dfs(i - , j, p, board, res);
     if (j > )dfs(i, j - , p, board, res);
     if (i < board.size() - )dfs(i + , j, p, board, res);
     if (j < board[].size() - )dfs(i, j + , p, board, res);
     board[i][j] = c;
 }

 class Solution {
 public:
     vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
         Trie t;
         vector<string> res;
         for (int i = ; i < words.size(); i++)
             t.insert(words[i]);
         for (int i = ; i < board.size(); i++)
         for (int j = ; j < board[].size(); j++)
             dfs(i, j, t.root, board, res);
         return res;
     }
 };

421 数组中任意两个数的最大异或值

思路：建树插入所有数，对每个数按位查找异或值

 class Trie{
 public:
     Trie* children[];
     Trie(){
         children[]=NULL;
         children[]=NULL;
     }
 };

 class Solution {
 public:
 int findMaximumXOR(vector<int>& nums) {
     if(nums.size()==)return ;
     //Init Trie
     Trie* root = new Trie();
     for(int num:nums)
     {
         Trie* curNode = root;
         for(int i=;i>=;i--)
         {
             int curBit = (num>>i)&;
             if(curNode->children[curBit]==NULL)
             {
                 curNode->children[curBit] = new Trie();
             }
             curNode = curNode->children[curBit];
         }
     }
     int _max = 0xffffffff;
     for(int num:nums)
     {
         Trie* curNode = root;
         int curSum = ;
         for(int i=;i>=;i--)
         {
             int curBit = (num>>i)&;
             if(curNode->children[curBit^]!=NULL)
             {
                 curSum += <<i;
                 curNode = curNode->children[curBit^];
             }
             else
             {
                 curNode = curNode->children[curBit];
             }
         }
         _max = max(curSum,_max);
     }
     return _max;
 }

 };