[Function add]

1. Add leetcode solutions using c++.

Author: Seanforfun

leetcode/17. Letter Combinations of a Phone Number.md

@@ -115,4 +115,29 @@ class Solution {
 			}
 		}
 	}
+	```
+
+### C++ version
+* Method 1: recursion
+	```objectivec
+	class Solution {
+	private:
+		vector<string> res_;
+		string key[10] = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+	public:
+		vector<string> letterCombinations(string digits) {
+			if(digits.empty()) return res_;
+			recursion(digits, "", 0);
+			return res_;
+		}
+		void recursion(string s, string cur, int index){
+			if(index == s.length()) res_.emplace_back(cur);
+			else{
+				string letters = key[s[index] - '0'];
+				for(const char c: letters){
+					recursion(s, cur + c, index + 1);
+				}
+			}
+		}
+	};
 	```

leetcode/39. Combination Sum.md

@@ -135,4 +135,35 @@ class Solution {
 			}
 		}
 	}
+	```
+
+### C++ version
+* Method 1: Recursion
+	```objectivec
+	class Solution {
+	private:
+		vector<vector<int>> res_;
+		vector<int> candidates_;
+		int target_;
+	public:
+		vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+			if(candidates.empty()) return res_;
+			candidates_ = candidates;
+			target_ = target;
+			vector<int> cur;
+			recursion(0, 0, cur);
+			return res_;
+		}
+		void recursion(int index, int sum, vector<int>& cur){
+			if(sum == target_) res_.push_back(cur);
+			else if(sum < target_){
+				int size = candidates_.size();
+				for(int i = index; i < size; ++i){
+					cur.push_back(candidates_[i]);
+					recursion(i, sum + candidates_[i], cur);
+					cur.pop_back();
+				}
+			}
+		}
+	};
 	```

leetcode/745. Prefix and Suffix Search.md

@@ -160,9 +160,107 @@ Note:
  * Method 3: Trie Tree
     * we construct a new word before inserting to tire tree.
     * Example: app, we save -app, p-app, pp-app, app-app, which contains all possible suffix conditions, since the question memtioned that word range is from 0 to 10.
+	
+	```objectivec
+	class Trie{
+	private:
+		struct Node{
+			vector<Node*> childs;
+			int index;
+			Node(): index(-1), childs(27, nullptr){};
+			~Node(){
+				for(auto node: childs){
+					delete node;
+				}
+			}
+		};
+		Node* find(const string & s){
+			Node* temp = root_.get();
+			for(const char & c: s){
+				if(!temp->childs[c - 'a']) return nullptr;
+				temp = temp->childs[c - 'a'];
+			}
+			return temp;
+		}
+		unique_ptr<Node> root_;
+	public:
+		Trie(): root_(new Node()){};
+		void insert(const string & word, int index){
+			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->index = index;
+			}
+		}
+		
+		int startWith(const string & s){
+			auto node = find(s);
+			if(!node) return -1;
+			return node->index;
+		}
+	};
+	class WordFilter {
+	private:
+		Trie trie_;
+	public:
+		WordFilter(vector<string>& words) {
+			int size = words.size();
+			for(int i = 0; i < size; ++i){
+				const string word = words[i];
+				int len = word.length();
+				for(int j = len; j >= 0; j--)
+					trie_.insert(word.substr(j, len) + "{" + word, i);
+			}
+		}
+		
+		int f(string prefix, string suffix) {
+			return trie_.startWith(suffix + "{" + prefix);
+		}
+	};
+	/**
+	 * Your WordFilter object will be instantiated and called as such:
+	 * WordFilter* obj = new WordFilter(words);
+	 * int param_1 = obj->f(prefix,suffix);
+	 */
+	```
 
 * Method 4: Hashmap
     * we create two hashmaps(key is String of prefix or suffix, value is a list to save the word) to save all possible prefix and suffix.
     * Example: app
         * prefix map : a, ap, app
         * suffix map: p, pp, app
+	
+	```objectc
+	class WordFilter {
+	public:
+		WordFilter(vector<string>& words) {
+			int size = words.size();
+			for(int k = 0; k < size; ++k){
+				string word = words[k];
+				int len = word.length();
+				for(int i = 0; i <= len; ++i){
+					string prefix = word.substr(0, i);
+					for(int j = len; j >= 0; --j){
+						string key = prefix + "_" + word.substr(j, len);
+						map_[key] = k;
+					}
+				}
+			}
+		}
+		int f(string prefix, string suffix) {
+			auto ptr = map_.find(prefix + "_" + suffix);
+			if(ptr == map_.end()) return -1;
+			return ptr->second;
+		}
+	private:
+		unordered_map<string, int> map_;
+	};
+	/**
+	 * Your WordFilter object will be instantiated and called as such:
+	 * WordFilter* obj = new WordFilter(words);
+	 * int param_1 = obj->f(prefix,suffix);
+	 */
+	```

leetcode/901. Online Stock Span.md

@@ -64,3 +64,23 @@ Note:
    * int param_1 = obj.next(price);
    */
   ```
+
+### C++ Version
+* Method 1: monostack
+	```objectivec
+	class StockSpanner {
+	public:
+		StockSpanner() {}		
+		int next(int price) {
+			int span = 1;
+			while(!stack_.empty() && price >= stack_.top().first){
+				span += stack_.top().second;
+				stack_.pop();
+			}
+			stack_.emplace(price, span);
+			return span;
+		}
+	private:
+		stack<pair<int, int>> stack_; // first: price, second: span
+	};
+	```