Rust: Trie Solutions

Author: tomijaga

rust/08_tries/208_implement_trie.rs

@@ -0,0 +1,56 @@
+#[derive(Default)]
+struct Trie {
+    is_word_end: bool,
+    children: [Option<Box<Trie>>; 26],
+}
+
+impl Trie {
+
+    fn new() -> Self {
+        Self{ ..Default::default() }
+    }
+    
+    fn insert(&mut self, word: String) {
+        let mut trie = self;
+        
+        for c in word.chars(){
+            trie = trie.children[char_index(c)]
+                .get_or_insert(Box::new(Trie::new()))
+                .as_mut();
+        }
+        
+        trie.is_word_end = true;
+    }
+    
+    fn search(& self, word: String) -> bool {
+        let mut trie = self;
+        
+        for c in word.chars(){
+            if let Some(ref next_trie) = trie.children[char_index(c)]{
+                trie = next_trie.as_ref();
+            }else{
+                return false;
+            }
+        }
+        
+        trie.is_word_end
+    }
+    
+    fn starts_with(&self, prefix: String) -> bool {
+        let mut trie = self;
+        
+        for c in prefix.chars(){
+            if let Some(ref next_trie) = trie.children[char_index(c)]{
+                trie = next_trie.as_ref();
+            }else{
+                return false;
+            }
+        }
+        
+        true
+    }
+}
+
+pub fn char_index(c: char) -> usize{
+    c as usize - 'a' as usize
+}

rust/08_tries/211_design_add_and_search_words_data_structure.rs

@@ -0,0 +1,60 @@
+#[derive(Default)]
+struct WordDictionary {
+    is_word_end: bool,
+    children: [Option<Box<WordDictionary>>; 26],
+}
+
+impl WordDictionary {
+
+    fn new() -> Self {
+        Default::default()
+    }
+    
+    fn add_word(&mut self, word: String) {
+        let mut dict = self;
+        
+        for c in word.chars(){
+            dict = dict.children[char_index(c)]
+                .get_or_insert(Box::new(WordDictionary::new()))
+                .as_mut();
+        }
+        
+        dict.is_word_end = true;
+    }
+    
+    fn search_ref(&self, word: &str) -> bool{
+        let mut dict = self;
+        
+        for (i, c) in word.chars().enumerate(){
+            if c == '.'{
+                let res = dict.children
+                    .iter()
+                    .any(|opt|{
+                        if let Some(ref next_dict) = opt{
+                            next_dict.search_ref(&word[i + 1..])
+                        }else{
+                            false
+                        }
+                    });
+                
+                return res;
+            }else{
+                if let Some(ref next_dict) = dict.children[char_index(c)]{
+                    dict = next_dict.as_ref();
+                }else{
+                    return false;
+                }
+            }
+        }
+        
+        dict.is_word_end
+    }
+    
+    fn search(&self, word: String) -> bool {
+        self.search_ref(&word)
+    }
+}
+
+pub fn char_index(c: char) -> usize{
+    c as usize - 'a' as usize
+}

rust/08_tries/212_word_search_II.rs

@@ -0,0 +1,93 @@
+#[derive(Default, Debug, Clone)]
+struct Trie {
+    is_word_end: bool,
+    children: [Option<Box<Trie>>; 26],
+}
+
+impl Solution {
+    pub fn find_words(mut board: Vec<Vec<char>>, words: Vec<String>) -> Vec<String> {
+        let mut trie = Trie::new();
+        let (m, n) = (board.len(), board[0].len());
+        
+        for word in words{
+            trie.insert(word);
+        }
+        
+        let mut word = String::new();
+        let mut res = vec![];
+        
+        for i in 0..m{
+            for j in 0..n{
+                Self::dfs(&mut board, &mut trie, &mut res, &mut word,  i, j);
+            }
+        }
+        res
+    }
+    
+    pub fn dfs(
+        board: &mut Vec<Vec<char>>, 
+        mut trie: &mut Trie, 
+        res: &mut Vec<String>, 
+        word: &mut String, 
+        i: usize, 
+        j: usize
+    ){
+        let (m, n) = (board.len(), board[0].len());
+        
+        if  i!= usize::MAX && 
+            j!= usize::MAX && 
+            i < m && 
+            j < n && 
+            board[i][j] != '#'
+        {
+            let c = board[i][j];
+            
+            // mark as visited
+            board[i][j] = '#';
+
+            if let Some(ref mut curr_trie) = trie.children[char_index(c)]{
+                trie = curr_trie.as_mut();
+            
+                word.push(c);
+                
+                if trie.is_word_end{
+                    res.push(word.clone());
+                    trie.is_word_end = false;
+                }
+                
+                for (x, y) in [(i + 1, j), (i - 1, j), (i, j + 1), (i, j - 1)]{
+                    Self::dfs(board, trie, res, word, x, y);
+                }
+                
+                word.pop();
+                
+            }
+            
+            board[i][j] = c;
+            
+        }
+    }
+}
+
+impl Trie {
+
+    fn new() -> Self {
+        Default::default()
+    }
+    
+    fn insert(&mut self, word: String) {
+        let mut trie = self;
+        
+        for c in word.chars(){
+            trie = trie.children[char_index(c)]
+                .get_or_insert(Box::new(Trie::new()))
+                .as_mut();
+        }
+        
+        trie.is_word_end = true;
+    }
+}
+
+pub fn char_index(c: char) -> usize{
+    c as usize - 'a' as usize
+}