[Function add]

1. Add trie tree results in C++ version.

Author: Seanforfun

leetcode/208. Implement Trie (Prefix Tree).md

@@ -280,5 +280,64 @@ class Trie {
    */
   ```
 
+### C++ Version
+```objectc
+class Trie {
+public:
+    /** Initialize your data structure here. */
+    Trie(): root_(new Node()){}    
+    ~Trie(){
+        delete root_;
+    }    
+    /** Inserts a word into the trie. */
+    void insert(string word) {
+        Node* temp = root_;
+        for(const char c: word){
+            if(temp->childs[c - 'a'] == nullptr){
+                temp->childs[c - 'a'] = new Node();
+            }
+            temp = temp->childs[c - 'a'];
+        }
+        temp->isLeaf = true;
+    }    
+    /** Returns if the word is in the trie. */
+    bool search(string word) {
+        Node* temp = find(std::move(word));
+        return temp == nullptr ? false: temp->isLeaf;
+    }    
+    /** Returns if there is any word in the trie that starts with the given prefix. */
+    bool startsWith(string prefix) {
+        return find(std::move(prefix)) != nullptr;
+    }
+private:
+    struct Node{
+        bool isLeaf;
+        vector<Node*> childs;
+        Node(): isLeaf(false), childs(26, nullptr){};
+        ~Node(){
+            for(auto nodePtr: childs){
+                delete nodePtr;
+            }
+        }
+    };    
+    Node* find(const string& word){
+        Node* temp = root_;
+        for(const char c: word){
+            if(temp->childs[c - 'a'] == nullptr) return nullptr;
+            temp = temp->childs[c - 'a'];
+        }
+        return temp;
+    }  
+    Node* root_;
+};
+/**
+ * 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);
+ */
+```
+
 ### Reference
 1. [Trie Tree 字典树](https://seanforfun.github.io/datastructure/2018/11/07/TrieTree.html)

leetcode/648. Replace Words.md

@@ -85,4 +85,59 @@ class Solution {
         return sb.toString().substring(1);
     }
 }
+```
+
+### C++ version
+```objectc
+class Solution {
+public:
+    string replaceWords(vector<string>& dict, string sentence) {
+        root_.reset(new Node());
+        string res = "", temp = "";
+        for(const string & pattern: dict){
+            insert(pattern);
+        }
+        istringstream is(sentence);
+        while(is >> temp){
+            if(!res.empty()) res += " ";
+            res += findClosest(temp);
+        }
+        return res;
+    }
+private:
+    struct Node{
+        vector<Node*> childs;
+        bool isLeaf;
+        Node(): isLeaf(false), childs(26, nullptr){};
+        ~Node(){
+            for(auto node: childs){
+                delete node;
+            }
+        }
+    };
+    std::unique_ptr<Node> root_;
+    void insert(const string & word){
+        Node* temp = root_.get();
+        for(const char & c: word){
+            if(!temp->childs[c - 'a']){
+                temp->childs[c - 'a'] = new Node();
+            }
+            temp = temp->childs[c - 'a'];
+        }
+        temp->isLeaf = true;
+    }
+    string findClosest(const string & word){
+        Node* temp = root_.get(); 
+        string cur = "";
+        for(const char c: word){
+            cur += c;
+            if(temp->childs[c - 'a']){
+                if(temp->childs[c - 'a']->isLeaf)
+                    return cur;
+                else temp = temp->childs[c - 'a'];
+            }else return word;
+        }
+        return word;
+    }
+};
 ```

leetcode/676. Implement Magic Dictionary.md

@@ -87,3 +87,52 @@ class MagicDictionary {
  * boolean param_2 = obj.search(word);
  */
 ```
+
+### C++ version
+```objectc
+class MagicDictionary {
+public:
+    /** Initialize your data structure here. */
+    MagicDictionary() {
+        map_.clear();
+    }
+    
+    /** Build a dictionary through a list of words */
+    void buildDict(vector<string> dict) {
+        for(string& s: dict){
+            int len = s.length();
+            for(int i = 0; i < len; ++i){
+                char c = s[i];
+                s[i] = '*';
+                map_[s].insert(c);
+                s[i] = c;
+            }
+        }
+    }
+    
+    /** Returns if there is any word in the trie that equals to the given word after modifying exactly one character */
+    bool search(string word) {
+        int len = word.length();
+        for(int i = 0; i < len; ++i){
+            char c = word[i];
+            word[i] = '*';
+            auto entry = map_.find(word);
+            word[i] = c;
+            if(entry == map_.end()) word[i] = c;
+            else{
+                if(entry->second.size() > 1 || c != *(entry->second.begin())) return true;
+            }
+        }
+        return false;
+    }
+private:
+    unordered_map<string, unordered_set<char>> map_;
+};
+
+/**
+ * Your MagicDictionary object will be instantiated and called as such:
+ * MagicDictionary* obj = new MagicDictionary();
+ * obj->buildDict(dict);
+ * bool param_2 = obj->search(word);
+ */
+```

leetcode/677. Map Sum Pairs.md

@@ -81,3 +81,63 @@ class MapSum {
  * int param_2 = obj.sum(prefix);
  */
 ```
+
+### C++ Version
+```objectc
+class MapSum {
+public:
+    /** Initialize your data structure here. */
+    MapSum() {
+        root_.reset(new Node());
+    }
+    void insert(string key, int val) {
+        Node* temp = root_.get();
+        Node* test = contains(key);
+        int diff = (test && test->isLeaf) ? val - test->sum: val;
+        temp->sum += diff;
+        for(const char & c: key){
+            if(!temp->childs[c - 'a']){
+                temp->childs[c - 'a'] = new Node();
+            }
+            temp = temp->childs[c - 'a'];
+            temp->sum += diff;
+        }
+        temp->isLeaf = true;
+    }
+    int sum(string prefix) {
+        Node* temp = root_.get();
+        for(const char & c: prefix){
+            if(!temp->childs[c - 'a']) return 0;
+            temp = temp->childs[c - 'a'];
+        }
+        return temp->sum;
+    }
+private:
+    struct Node{
+        vector<Node*> childs;
+        int sum;
+        bool isLeaf;
+        Node(): childs(26, nullptr), sum(0), isLeaf(false){};
+        ~Node(){
+            for(auto node: childs){
+                delete node;
+            }
+        }
+    };
+    Node* contains(string word){
+        Node * temp = root_.get();
+        for(const char & c: word){
+            if(!temp->childs[c - 'a']) return nullptr;
+            temp = temp->childs[c - 'a'];
+        }
+        return temp;
+    }
+    unique_ptr<Node> root_;
+};
+/**
+ * Your MapSum object will be instantiated and called as such:
+ * MapSum* obj = new MapSum();
+ * obj->insert(key,val);
+ * int param_2 = obj->sum(prefix);
+ */
+```