[Function add]

Seanforfun · Seanforfun · commit 961a31585634 · 2019-03-08T12:04:56.000-05:00
1. Add leetcode trie tree questions.
diff --git a/README.md b/README.md
@@ -496,6 +496,20 @@
 [315. Count of Smaller Numbers After Self](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/315.%20Count%20of%20Smaller%20Numbers%20After%20Self.md)
 
 
+## LeetCode by Tag:
+1. [Tag table from huahua](https://docs.google.com/spreadsheets/d/1SbpY-04Cz8EWw3A_LBUmDEXKUMO31DBjfeMoA0dlfIA/edit#gid=126913158)
+
+### Advance
+#### [Trie Tree]()
+* [208. Implement Trie (Prefix Tree)](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/208.%20Implement%20Trie%20(Prefix%20Tree).md)
+* [648. Replace Words](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/648.%20Replace%20Words.md)
+* [676. Implement Magic Dictionary](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/676.%20Implement%20Magic%20Dictionary.md)
+* [677. Map Sum Pairs](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/677.%20Map%20Sum%20Pairs.md)
+* [720. Longest Word in Dictionary](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/720.%20Longest%20Word%20in%20Dictionary.md)
+* [745. Prefix and Suffix Search](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/745.%20Prefix%20and%20Suffix%20Search.md)
+* Conclusion: [Data structure | Trie Tree 字典树](https://seanforfun.github.io/datastructure/2018/11/07/TrieTree.html)
+
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.
diff --git a/leetcode/208. Implement Trie (Prefix Tree).md b/leetcode/208. Implement Trie (Prefix Tree).md
@@ -150,5 +150,73 @@ class Trie {
  */
 ```
 
+### Third time
+```Java
+class Trie {
+    private static class Node{
+        boolean isLeaf;
+        Node[] childs;
+        public Node(){
+            this.childs = new Node[26];
+        }
+    }
+    private Node root;
+    /** Initialize your data structure here. */
+    public Trie() {
+        this.root = new Node();
+    }
+
+    /** Inserts a word into the trie. */
+    public void insert(String word) {
+        char[] arr = word.toCharArray();
+        Node node = root;
+        for(int i = 0; i < arr.length; i++){
+            int c = arr[i] - 'a';
+            if(node.childs[c] == null){
+                node.childs[c] = new Node();
+            }
+            node = node.childs[c];
+        }
+        node.isLeaf = true;
+    }
+
+    /** Returns if the word is in the trie. */
+    public boolean search(String word) {
+        char[] arr = word.toCharArray();
+        Node node = root;
+        for(int i = 0; i < arr.length; i++){
+            int c = arr[i] - 'a';
+            if(node.childs[c] == null){
+                return false;
+            }
+            node = node.childs[c];
+        }
+        return node.isLeaf;
+    }
+
+    /** Returns if there is any word in the trie that starts with the given prefix. */
+    public boolean startsWith(String prefix) {
+        char[] arr = prefix.toCharArray();
+        Node node = root;
+        for(int i = 0; i < arr.length; i++){
+            int c = arr[i] - 'a';
+            if(node.childs[c] == null){
+                return false;   
+            }
+            node = node.childs[c];
+        }
+        return true;
+    }
+}
+
+/**
+ * Your Trie object will be instantiated and called as such:
+ * Trie obj = new Trie();
+ * obj.insert(word);
+ * boolean param_2 = obj.search(word);
+ * boolean param_3 = obj.startsWith(prefix);
+ */
+```
+
 ### Reference
 1. [Trie Tree 字典树](https://seanforfun.github.io/datastructure/2018/11/07/TrieTree.html)
diff --git a/leetcode/648. Replace Words.md b/leetcode/648. Replace Words.md
@@ -0,0 +1,88 @@
+## 648. Replace Words
+
+### Question
+In English, we have a concept called root, which can be followed by some other words to form another longer word - let's call this word successor. For example, the root an, followed by other, which can form another word another.
+
+Now, given a dictionary consisting of many roots and a sentence. You need to replace all the successor in the sentence with the root forming it. If a successor has many roots can form it, replace it with the root with the shortest length.
+
+You need to output the sentence after the replacement.
+
+```
+Example 1:
+
+Input: dict = ["cat", "bat", "rat"]
+sentence = "the cattle was rattled by the battery"
+Output: "the cat was rat by the bat"
+```
+ 
+Note:
+* The input will only have lower-case letters.
+* 1 <= dict words number <= 1000
+* 1 <= sentence words number <= 1000
+* 1 <= root length <= 100
+* 1 <= sentence words length <= 1000
+
+
+### Thinking:
+* Method 1:Trie Tree
+
+```Java
+class Solution {
+    private static class TrieTree{
+        public static class Node{
+            boolean isLeaf;
+            Node[] childs;
+            public Node(){
+                this.childs = new Node[26];
+            }
+        }
+        private Node root;
+        public TrieTree(){
+            this.root = new Node();
+        }
+        public void insert(String s){
+            char[] arr = s.toCharArray();
+            Node node = root;
+            for(int i = 0; i < arr.length; i++){
+                if(node.isLeaf) return;
+                int c = arr[i] - 'a';
+                if(node.childs[c] == null){
+                    node.childs[c] = new Node();
+                }
+                node = node.childs[c];
+            }
+            node.isLeaf = true;            
+        }
+        public String findClosest(String s){
+            char[] arr = s.toCharArray();
+            Node node = root;
+            for(int i = 0; i < arr.length; i++){
+                int c = arr[i] - 'a';
+                if(node.childs[c] == null){
+                    return s;   
+                }else{
+                    node = node.childs[c];
+                    if(node.isLeaf){
+                        return s.substring(0, i + 1);   
+                    }
+                }
+            }
+            return s;
+        }
+    }
+    public String replaceWords(List<String> dict, String sentence) {
+        if(sentence == null || sentence.length() == 0) return "";
+        if(dict == null || dict.size() == 0) return sentence;
+        TrieTree tree = new TrieTree();
+        for(String s : dict){
+            tree.insert(s);
+        }
+        StringBuilder sb = new StringBuilder();
+        String[] tokens = sentence.split(" ");
+        for(String token : tokens){
+            sb.append(" " + tree.findClosest(token));
+        }
+        return sb.toString().substring(1);
+    }
+}
+```
diff --git a/leetcode/676. Implement Magic Dictionary.md b/leetcode/676. Implement Magic Dictionary.md
@@ -0,0 +1,89 @@
+## 676. Implement Magic Dictionary
+
+### Question
+Implement a magic directory with buildDict, and search methods.
+
+For the method buildDict, you'll be given a list of non-repetitive words to build a dictionary.
+
+For the method search, you'll be given a word, and judge whether if you modify exactly one character into another character in this word, the modified word is in the dictionary you just built.
+
+```
+Example 1:
+
+Input: buildDict(["hello", "leetcode"]), Output: Null
+Input: search("hello"), Output: False
+Input: search("hhllo"), Output: True
+Input: search("hell"), Output: False
+Input: search("leetcoded"), Output: False
+```
+
+Note:
+1. You may assume that all the inputs are consist of lowercase letters a-z.
+2. For contest purpose, the test data is rather small by now. You could think about highly efficient algorithm after the contest.
+3. Please remember to RESET your class variables declared in class MagicDictionary, as static/class variables are persisted across multiple test cases. Please see here for more details.
+
+### Solution
+* Method 1: Trie Tree
+
+```Java
+class MagicDictionary {
+    private static class Node{
+        boolean isLeaf;
+        Node[] childs;
+        public Node(){
+            this.childs = new Node[26];
+        }
+    }
+    private Node root;
+    /** Initialize your data structure here. */
+    public MagicDictionary() {
+        this.root = new Node();
+    }
+
+    /** Build a dictionary through a list of words */
+    public void buildDict(String[] dict) {
+        for(String s : dict){
+            char[] arr = s.toCharArray();
+            Node node = root;
+            for(int i = 0; i < arr.length; i++){
+                int c = arr[i] - 'a';
+                if(node.childs[c] == null){
+                    node.childs[c] = new Node();
+                }
+                node = node.childs[c];
+            }
+            node.isLeaf = true;
+        }
+    }
+    /** Returns if there is any word in the trie that equals to the given word after modifying exactly one character */
+    public boolean search(String word) {
+        if(word == null || word.length() == 0) return false;
+        return dfs(word, 0, root, 0);
+    }
+    private boolean dfs(String word, int index, Node node, int diff){
+        if(diff > 1) return false;
+        if(index == word.length()){
+            if(diff == 1 && node.isLeaf){
+                return true;
+            }else{
+                return false;
+            }
+        }
+        int c = word.charAt(index) - 'a';
+        boolean res = false;
+        for(int i = 0; i < 26; i++){
+            if(node.childs[i] != null){
+                res |= dfs(word, index + 1, node.childs[i], diff + (c == i ? 0: 1));
+            }
+        }
+        return res;
+    }
+}
+
+/**
+ * Your MagicDictionary object will be instantiated and called as such:
+ * MagicDictionary obj = new MagicDictionary();
+ * obj.buildDict(dict);
+ * boolean param_2 = obj.search(word);
+ */
+```
diff --git a/leetcode/677. Map Sum Pairs.md b/leetcode/677. Map Sum Pairs.md
@@ -0,0 +1,83 @@
+## 677. Map Sum Pairs
+
+### Question:
+Implement a MapSum class with insert, and sum methods.
+
+For the method insert, you'll be given a pair of (string, integer). The string represents the key and the integer represents the value. If the key already existed, then the original key-value pair will be overridden to the new one.
+
+For the method sum, you'll be given a string representing the prefix, and you need to return the sum of all the pairs' value whose key starts with the prefix.
+
+```
+Example 1:
+
+Input: insert("apple", 3), Output: Null
+Input: sum("ap"), Output: 3
+Input: insert("app", 2), Output: Null
+Input: sum("ap"), Output: 5
+```
+
+### Solution
+* Method 1: Trie Tree
+
+```Java
+class MapSum {
+
+    private static class Node{
+        int count;
+        Node[] childs;
+        boolean isLeaf;
+        public Node(){
+            this.childs = new Node[26];
+        }
+    }
+    private Node root;
+    /** Initialize your data structure here. */
+    public MapSum() {
+        this.root = new Node();
+    }
+
+    public void insert(String key, int val) {
+        char[] arr = key.toCharArray();
+        Node node = root;
+        for(int i = 0; i < arr.length; i++){
+            int c = arr[i] - 'a';
+            if(node.childs[c] == null){
+                node.childs[c] = new Node();
+            }
+            node = node.childs[c];
+        }
+        node.isLeaf = true;
+        node.count = val;
+    }
+
+    public int sum(String prefix) {
+        char[] arr = prefix.toCharArray();
+        Node node = root;
+        for(int i = 0; i < arr.length; i++){
+            int c = arr[i] - 'a';
+            if(node.childs[c] == null){
+                return 0;
+            }else{
+                node = node.childs[c];
+            }
+        }
+        return childsCount(node);
+    }
+    private int childsCount(Node node){
+        int count = node.count;
+        for(int i = 0; i < 26; i++){
+            if(node.childs[i] != null){
+                count += childsCount(node.childs[i]);
+            }
+        }
+        return count;
+    }
+}
+
+/**
+ * Your MapSum object will be instantiated and called as such:
+ * MapSum obj = new MapSum();
+ * obj.insert(key,val);
+ * int param_2 = obj.sum(prefix);
+ */
+```
diff --git a/leetcode/720. Longest Word in Dictionary.md b/leetcode/720. Longest Word in Dictionary.md
diff --git a/leetcode/745. Prefix and Suffix Search.md b/leetcode/745. Prefix and Suffix Search.md
