LeetCode 211. Design Add and Search Words Data Structure Rust

Author: raul-sauco

README.md

@@ -151,7 +151,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [207. Course Schedule][lc207]                                                                 | 🟠 Medium  | [![python](res/py.png)][lc207py]                                                             |
 | [208. Implement Trie (Prefix Tree)][lc208]                                                    | 🟠 Medium  | [![python](res/py.png)][lc208py] [![rust](res/rs.png)][lc208rs]                              |
 | [210. Course Schedule II][lc210]                                                              | 🟠 Medium  | [![python](res/py.png)][lc210py]                                                             |
-| [211. Design Add and Search Words Data Structure][lc211]                                      | 🟠 Medium  | [![python](res/py.png)][lc211py]                                                             |
+| [211. Design Add and Search Words Data Structure][lc211]                                      | 🟠 Medium  | [![python](res/py.png)][lc211py] [![rust](res/rs.png)][lc211rs]                              |
 | [212. Word Search II][lc212]                                                                  | 🔴 Hard    | [![python](res/py.png)][lc212py]                                                             |
 | [213. House Robber II][lc213]                                                                 | 🟠 Medium  | [![python](res/py.png)][lc213py]                                                             |
 | [215. Kth Largest Element in an Array][lc215]                                                 | 🟠 Medium  | [![python](res/py.png)][lc215py]                                                             |
@@ -741,6 +741,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc210py]: leetcode/course-schedule-ii.py
 [lc211]: https://leetcode.com/problems/design-add-and-search-words-data-structure/
 [lc211py]: leetcode/design-add-and-search-words-data-structure.py
+[lc211rs]: leetcode/design-add-and-search-words-data-structure.rs
 [lc212]: https://leetcode.com/problems/word-search-ii/
 [lc212py]: leetcode/word-search-ii.py
 [lc213]: https://leetcode.com/problems/house-robber-ii/

leetcode/design-add-and-search-words-data-structure.py

@@ -24,8 +24,8 @@
 # inserted could make its own node, in average it will be less than that
 # because words with common roots will share nodes.
 #
-# Runtime: 16919 ms, faster than 27.72%
-# Memory Usage: 55.9 MB, less than 87.04%
+# Runtime: 9102 ms, faster than 74.25%
+# Memory Usage: 55.9 MB, less than 88.21%
 class WordDictionary:
     def __init__(self):
         self.root = {}
@@ -76,7 +76,7 @@ def __init__(self):
 # inserted could make its own node, in average it will be less than that
 # because words with common roots will share nodes.
 #
-# Runtime: 16930 ms, faster than 27.61%
+# Runtime: 10162 ms, faster than 60.45%
 # Memory Usage: 80 MB, less than 12.93%
 class WDEasyRead:
     def __init__(self):

leetcode/design-add-and-search-words-data-structure.rs

@@ -0,0 +1,127 @@
+// 211. Design Add and Search Words Data Structure
+// 🟠 Medium
+//
+// https://leetcode.com/problems/design-add-and-search-words-data-structure/
+//
+// Tags: String - Depth-First Search - Design - Trie
+
+use std::collections::HashMap;
+
+#[derive(Default)]
+struct WordDictionary {
+    children: HashMap<char, WordDictionary>,
+    is_word_end: bool,
+}
+
+/**
+ * Implement the word dictionary using plain hash maps to store the
+ * children of each node. Inserting is exactly the same as with the
+ * regular trie class and can be done in O(n), searching will need to
+ * branch out to all the nodes' children when the current character is a
+ * '.' wildcard and it could potentially take O(m*n) which is visiting
+ * each node in the trie, even though usually would be faster.
+ *
+ * Time complexity: O(m*n) - For searching strings with wildcards, it
+ * could potentially search the entire trie. O(n) for inserts, it will
+ * perform one O(1) operation per character.
+ * Space complexity: O(m*n) - Potentially, each character of each node
+ * inserted could make its own node, in average it will be less than that
+ * because words with common roots will share nodes.
+ *
+ * Runtime 732  ms Beats 60.71%
+ * Memory 45.9 Beats 32.14%
+ */
+impl WordDictionary {
+    /**
+     *  Time complexity: O(1) - We create one empty HashMap instance.
+     * Space complexity: O(1) - Constant space.
+     */
+    fn new() -> Self {
+        Self {
+            is_word_end: false,
+            children: HashMap::new(),
+        }
+    }
+
+    /**
+     * Time complexity: O(1) - Word is limited to 25 chars, we may loop 25 times
+     * and do O(1) work for each iteration.
+     * Space complexity: O(1) - Constant space.
+     */
+    fn add_word(&mut self, word: String) {
+        let mut node = self;
+        for ch in word.chars() {
+            node = node.children.entry(ch).or_default();
+        }
+        node.is_word_end = true;
+    }
+
+    /**
+     * Time O(m*n) - Each wildcard will branch to all children, we may visit all
+     * nodes in the word dictionary.
+     * Space O(h) - The call stack can grow to the height of the tree, limited to
+     * 20 so this is equivalent to O(1) in this case.
+     */
+    fn search(&self, word: String) -> bool {
+        let chars: Vec<char> = word.chars().collect();
+        self.search_from(&self, 0, &chars)
+    }
+
+    /**
+     * Time O(m*n) - Each wildcard will branch to all children, we may visit all
+     * nodes in the word dictionary.
+     * Space O(h) - The call stack can grow to the height of the tree, limited to
+     * 20 so this is equivalent to O(1) in this case.
+     */
+    fn search_from(&self, current: &WordDictionary, idx: usize, chars: &Vec<char>) -> bool {
+        let mut node = current;
+        let mut ch;
+        for i in idx..chars.len() {
+            ch = chars[i];
+            match ch {
+                // When we find a wildcard, we need to try all children.
+                '.' => {
+                    for (_, child) in node.children.iter() {
+                        // If any children is a match return true.
+                        if self.search_from(child, i + 1, chars) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+                // If it is a regular character, match it.
+                c => match node.children.get(&c) {
+                    Some(child) => node = child,
+                    None => return false,
+                },
+            }
+        }
+        // If we get to the end of the word.
+        node.is_word_end
+    }
+}
+
+// Tests.
+fn main() {
+    // Example test case.
+    let mut wd = WordDictionary::new();
+    wd.add_word(String::from("bad"));
+    wd.add_word(String::from("dad"));
+    wd.add_word(String::from("mad"));
+    assert_eq!(wd.search(String::from("pad")), false);
+    assert_eq!(wd.search(String::from("bad")), true);
+    assert_eq!(wd.search(String::from(".ad")), true);
+    assert_eq!(wd.search(String::from("b..")), true);
+
+    wd = WordDictionary::new();
+    wd.add_word(String::from("a"));
+    wd.add_word(String::from("a"));
+    assert_eq!(wd.search(String::from(".")), true);
+    assert_eq!(wd.search(String::from("a")), true);
+    assert_eq!(wd.search(String::from("aa")), false);
+    assert_eq!(wd.search(String::from("a")), true);
+    assert_eq!(wd.search(String::from(".a")), false);
+    assert_eq!(wd.search(String::from("a.")), false);
+
+    println!("All tests passed!")
+}