solves design and add search words data structure

Author: anishLearnsToCode

README.md

@@ -171,7 +171,7 @@
 | 208  | [Implement Trie (Prefix Tree)](https://leetcode.com/problems/implement-trie-prefix-tree)                                                                  |                                                                      [![Java](assets/java.png)](src/Trie.java)                                                                       |                                                                                                                                   |
 | 209  | [Minimum Size Subarray Sum](https://leetcode.com/problems/minimum-size-subarray-sum)                                                                      |                                                             [![Java](assets/java.png)](src/MinimumSizeSubarraySum.java)                                                              |                                                                                                                                   |
 | 210  | [Course Schedule II](https://leetcode.com/problems/course-schedule-ii)                                                                                    |                                                                [![Java](assets/java.png)](src/CourseScheduleII.java)                                                                 |                                                                                                                                   |
-| 211  | [Design Add and Search Words Data Structure](https://leetcode.com/problems/design-add-and-search-words-data-structure)                                    |                                                                                                                                                                                      |                                                                                                                                   |
+| 211  | [Design Add and Search Words Data Structure](https://leetcode.com/problems/design-add-and-search-words-data-structure)                                    |                                                      [![Java](assets/java.png)](src/DesignAddAndSearchWordsDataStructure.java)                                                       |                                                                                                                                   |
 | 213  | [House Robber II](https://leetcode.com/problems/house-robber-ii)                                                                                          |                                                                                                                                                                                      |                                                                                                                                   |
 | 215  | [Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array)                                                          |                                                           [![Java](assets/java.png)](src/KthLargestElementInAnArray.java)                                                            |                                                                                                                                   |
 | 216  | [Combination Sum III](https://leetcode.com/problems/combination-sum-iii)                                                                                  |                                                                                                                                                                                      |                                                                                                                                   |

src/DesignAddAndSearchWordsDataStructure.java

@@ -0,0 +1,81 @@
+// https://leetcode.com/problems/design-add-and-search-words-data-structure
+// S: O(sum |word|_i)
+/*
+    trie.add(String word)
+    T: O(word)
+
+    trie.contains(String word)
+    T: O(26^3 * word) = O(k * word) = O(word)
+ */
+/*
+    word_dict.addWord(String word)
+    T: O(word)
+
+    word_dict.search(String word)
+    T: O(word)
+ */
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class DesignAddAndSearchWordsDataStructure {
+    private static final class WordDictionary {
+
+        private final Trie trie = new Trie();
+        private final Set<String> words = new HashSet<>();
+
+        public void addWord(String word) {
+            words.add(word);
+            trie.add(word);
+        }
+
+        public boolean search(String word) {
+            if (!containsDots(word)) return words.contains(word);
+            return trie.contains(word);
+        }
+
+        private boolean containsDots(String word) {
+            for (int i = 0 ; i < word.length() ; i++) {
+                if (word.charAt(i) == '.') return true;
+            }
+            return false;
+        }
+    }
+
+    private static final class Trie {
+        final Trie[] children = new Trie[26];
+        boolean isWord = false;
+
+        public void add(String s) {
+            add(s, 0);
+        }
+
+        private void add(String s, int index) {
+            if (index == s.length()) {
+                isWord = true;
+                return;
+            }
+            char c = s.charAt(index);
+            if (children[c - 'a'] == null) children[c - 'a'] = new Trie();
+            children[c - 'a'].add(s, index + 1);
+        }
+
+        public boolean contains(String s) {
+            return contains(s, 0);
+        }
+
+        private boolean contains(String s, int index) {
+            if (index == s.length()) return isWord;
+            char character = s.charAt(index);
+            if (character != '.') {
+                return children[character - 'a'] != null && children[character - 'a'].contains(s, index + 1);
+            }
+            for (Trie child : children) {
+                if (child != null && child.contains(s, index + 1)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+}