[Function add]

1. Add leetcode results in C++.

Author: Seanforfun

leetcode/212. Word Search II.md

@@ -249,3 +249,135 @@ class Solution {
 		}
 	}
 	```
+
+### C++ version
+* Method 1: dfs
+```objectivec
+class Solution {
+private:
+    vector<string> res_;
+    static int dir[4][2];
+    vector<vector<char>> board_;
+    int height_, width_;
+    bool dfs(int index, const string& word, int row, int col){
+        if(index == word.length()) return true;
+        int tx = 0, ty = 0;
+        for(int d = 0; d < 4; ++d){
+            tx = row + Solution::dir[d][0];
+            ty = col + Solution::dir[d][1];
+            if(tx >= 0 && tx < height_ && ty >= 0 && ty < width_ && board_[tx][ty] != '#' && board_[tx][ty] == word[index]){
+                char c = board_[tx][ty];
+                board_[tx][ty] = '#';
+                if(dfs(index + 1, word, tx, ty)){
+                    board_[tx][ty] = c;
+                    return true;
+                }
+                board_[tx][ty] = c;
+            }
+        }
+        return false;
+    }
+public:
+    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
+        height_=  board.size();
+        width_ = board[0].size();
+        board_ = move(board);
+        unordered_set<string> set(words.begin(), words.end());
+        for(const string& word: set){
+            bool found = false;
+            for(int i = 0; i < height_ && !found; ++i){
+                for(int j = 0; j < width_  && !found; ++j){
+                    if(word[0] == board_[i][j]){
+                        char c = board_[i][j];
+                        board_[i][j] = '#';
+                        if(dfs(1, word, i, j)){
+                            res_.emplace_back(word);
+                            found = true;
+                        }
+                        board_[i][j] = c;
+                    }
+                }
+            }
+        }
+        return res_;
+    }    
+};
+int Solution::dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+static auto speedup=[](){
+ios::sync_with_stdio(false);
+cin.tie(nullptr);
+cout.tie(nullptr);
+return nullptr;
+}();
+```
+
+* Method 2: Tire Tree
+```objectivec
+struct Node{
+    vector<Node*> childs;
+    const string* word;
+    
+    Node(): childs(26), word(nullptr){}
+    ~Node(){
+        for(auto node: childs){
+            delete node;
+        }
+    }
+};
+class Solution {
+private:
+    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->word = &word;
+    }
+    static int dir[4][2];
+public:
+    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
+        root_.reset(new Node());
+        for(const string& word: words){
+            insert(word);
+        }
+        int height = board.size(), width = board[0].size();
+        vector<string> res;
+        function<void(int, int, Node*)> walk = [&](int i, int j, Node* node){
+            if(i < 0 || i >= height || j < 0 || j >= width || board[i][j] == '#') return;
+            const char c = board[i][j];
+            Node* next = node->childs[c - 'a'];
+            if(!next) return;
+            if(next->word){
+                res.emplace_back(*next->word);
+                next->word = nullptr;
+            }
+            int tx = 0, ty = 0;
+            board[i][j] = '#';
+            for(int d = 0; d < 4; ++d){
+                tx = i + dir[d][0];
+                ty = j + dir[d][1];
+                walk(tx, ty, next);
+            }
+            board[i][j] = c;
+        };
+        for(int i = 0; i < height; ++i){
+            for(int j = 0; j < width; ++j){
+                walk(i, j, root_.get());
+            }
+        }
+        return res;
+    }
+};
+int Solution::dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+static auto speedup=[](){
+ios::sync_with_stdio(false);
+cin.tie(nullptr);
+cout.tie(nullptr);
+return nullptr;
+}();
+```

leetcode/79. Word Search.md

@@ -256,4 +256,53 @@ class Solution {
 			return false;
 		}
 	}
-	```
+	```
+
+### C++ version
+* Method 1: dfs
+```objectivec
+class Solution {
+private:
+    static int dir[4][2];
+    vector<vector<char>> board_;
+    int height, width;
+    bool dfs(const string& word, int index, int i, int j, vector<vector<int>>& visited){
+        if(index == word.length()) return true;
+        int tx = 0, ty = 0;
+        for(int d = 0; d < 4; ++d){
+            tx = i + Solution::dir[d][0];
+            ty = j + Solution::dir[d][1];
+            if(tx >= 0 && tx < height && ty >= 0 && ty < width && !visited[tx][ty] && word[index] == board_[tx][ty]){
+                visited[tx][ty] = true;
+                if(dfs(word, index + 1, tx, ty, visited)) return true;
+                visited[tx][ty] = false;
+            }
+        }
+        return false;
+    }
+public:
+    bool exist(vector<vector<char>>& board, string word) {
+        this->height = board.size();
+        this->width = board[0].size();
+        board_ = move(board);
+        vector<vector<int>> visited(height, vector<int>(width, false)); 
+        for(int i = 0; i < height; ++i){
+            for(int j = 0; j < width; ++j){
+                if(word[0] == board_[i][j]){
+                    visited[i][j] = true;
+                    if(dfs(word, 1, i, j, visited)) return true;
+                    visited[i][j] = false;
+                }
+            }
+        }
+        return false;
+    }
+};
+int Solution::dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+static auto speedup=[](){
+ios::sync_with_stdio(false);
+cin.tie(nullptr);
+cout.tie(nullptr);
+return nullptr;
+}();
+```