[Function add]

1. Add two leetcode solutions using C++.

Author: Seanforfun

leetcode/307. Range Sum Query - Mutable.md

@@ -300,4 +300,41 @@ class NumArray {
  * obj.update(i,val);
  * int param_2 = obj.sumRange(i,j);
  */
+```
+
+### C++ Version
+```objectc
+class NumArray {
+private:
+    vector<int> sum_;
+    vector<int> nums_;
+public:
+    NumArray(vector<int>& nums): nums_(std::move(nums)) {
+        int size = nums_.size();
+        if(size == 0) return;
+        sum_.resize(size, 0);
+        sum_[0] = nums_[0];
+        for(int i = 1; i < size; i++){
+            sum_[i] = sum_[i - 1] + nums_[i];
+        }
+    }
+    void update(int i, int val) {
+        int pre = nums_[i];
+        nums_[i] = val;
+        int diff = val - pre;
+        for(int j = i; j < sum_.size(); j++){
+            sum_[j] += diff;
+        }
+    }
+    int sumRange(int i, int j) {
+        return sum_[j] - sum_[i] + nums_[i];
+    }
+};
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray* obj = new NumArray(nums);
+ * obj->update(i,val);
+ * int param_2 = obj->sumRange(i,j);
+ */
 ```

leetcode/720. Longest Word in Dictionary.md

@@ -84,3 +84,55 @@ The length of words[i] will be in the range [1, 30].
 		}
 	}
 	```
+
+### C++ version
+```objectc
+class Solution {
+public:
+    string longestWord(vector<string>& words) {
+        root_.reset(new Node());
+        sort(words.begin(), words.end());
+        for(const string & word: words){
+            int len = word.length();
+            if(len == 1 && !root_->childs[word[0] - 'a']){
+                root_->childs[word[0] - 'a'] = new Node();
+                root_->childs[word[0] - 'a']->isLeaf = true;
+            }else{
+                Node* pre = find(word.substr(0, len - 1));
+                if(!pre) continue;
+                else if(!pre->childs[word[len - 1] - 'a']){
+                    pre->childs[word[len - 1] - 'a'] = new Node();
+                }
+                pre->childs[word[len - 1] - 'a']->isLeaf = true;
+            }
+            if(len > max_){
+                max_ = len;
+                res_ = word;
+            }
+        }  
+        return res_;
+    }
+private:
+    struct Node{
+        vector<Node*> childs;
+        bool isLeaf;
+        Node(): isLeaf(false), childs(26, nullptr){}
+        ~Node(){
+            for(auto node: childs){
+                delete node;
+            }
+        }
+    };
+    unique_ptr<Node> root_;
+    Node* find(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->isLeaf ? temp: nullptr;
+    }
+    int max_ = 0;
+    string res_ = "";
+};
+```