Resolve #213

Author: aylei

Cargo.toml

@@ -9,3 +9,7 @@ reqwest = "0.9.8"
 serde = "1.0"
 serde_json = "1.0"
 serde_derive = "1.0"
+
+[lib]
+doctest = false
+test = false

src/lib.rs

@@ -178,3 +178,6 @@ mod n0207_course_schedule;
 mod n0208_implement_trie_prefix_tree;
 mod n0209_minimum_size_subarray_sum;
 mod n0210_course_schedule_ii;
+mod n0211_add_and_search_word_data_structure_design;
+mod n0212_word_search_ii;
+mod n0213_house_robber_ii;

src/n0211_add_and_search_word_data_structure_design.rs

@@ -0,0 +1,128 @@
+/**
+ * [211] Add and Search Word - Data structure design
+ *
+ * Design a data structure that supports the following two operations:
+ *
+ *
+ * void addWord(word)
+ * bool search(word)
+ *
+ *
+ * search(word) can search a literal word or a regular expression string containing only letters a-z or .. A . means it can represent any one letter.
+ *
+ * Example:
+ *
+ *
+ * addWord("bad")
+ * addWord("dad")
+ * addWord("mad")
+ * search("pad") -> false
+ * search("bad") -> true
+ * search(".ad") -> true
+ * search("b..") -> true
+ *
+ *
+ * Note:<br />
+ * You may assume that all words are consist of lowercase letters a-z.
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+
+struct WordDictionary {
+    root: Option<Box<Trie>>,
+}
+
+#[derive(Default)]
+struct Trie {
+    is_end: bool,
+    marked: Vec<usize>,
+    nodes: [Option<Box<Trie>>; 26],
+}
+
+impl Trie {
+    fn new() -> Self {
+        Default::default()
+    }
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl WordDictionary {
+    // /** Initialize your data structure here. */
+    // fn new() -> Self {
+    //     WordDictionary{
+    //         root: Some(Box::new(Trie::new())),
+    //     }
+    // }
+
+    // /** Adds a word into the data structure. */
+    // fn add_word(&mut self, word: String) {
+    //     let mut curr = self.root;
+
+    //     for i in word.chars().map(|ch| (ch as u8 - 'a' as u8) as usize) {
+    //         curr = curr.as_ref().unwrap().nodes[i];
+    //     }
+    //     curr.as_mut().unwrap().is_end = true;
+    // }
+
+    // /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
+    // fn search(&self, word: String) -> bool {
+    //     let mut chs: Vec<char> = word.chars().collect();
+    //     WordDictionary::search_from(self.root.as_ref(), &mut chs)
+    // }
+
+    // fn search_from(node: Option<&Box<Trie>>, chs: &mut [char]) -> bool {
+    //     if node.is_none() {
+    //         return false
+    //     }
+    //     let node = node.unwrap();
+    //     if chs.len() < 1 {
+    //         return node.is_end
+    //     }
+    //     if chs[0] == '.' {
+    //         // backtracking
+    //         let mut sliced = &mut chs[1..];
+    //         for &idx in node.marked.iter() {
+    //             if WordDictionary::search_from(node.nodes[idx].as_ref(), sliced) {
+    //                 return true
+    //             }
+    //         }
+    //         false
+    //     } else {
+    //         let next = node.nodes[(chs[0] as u8 - 'a' as u8) as usize].as_ref();
+    //         WordDictionary::search_from(next, &mut chs[1..])
+    //     }
+    // }
+}
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * let obj = WordDictionary::new();
+ * obj.add_word(word);
+ * let ret_2: bool = obj.search(word);
+ */
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_211() {
+        // let mut dict = WordDictionary::new();
+        // dict.add_word("bad".to_owned());
+        // dict.add_word("dad".to_owned());
+        // dict.add_word("mad".to_owned());
+        // assert_eq!(dict.search("pad".to_owned()), false);
+        // assert_eq!(dict.search("bad".to_owned()), true);
+        // assert_eq!(dict.search(".ad".to_owned()), true);
+        // assert_eq!(dict.search("da.".to_owned()), true);
+    }
+
+}

src/n0212_word_search_ii.rs

@@ -0,0 +1,54 @@
+/**
+ * [212] Word Search II
+ *
+ * Given a 2D board and a list of words from the dictionary, find all words in the board.
+ *
+ * Each word must be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.
+ *
+ *
+ *
+ * Example:
+ *
+ *
+ * Input:
+ * board = [
+ *   ['<span style="color:#d70">o</span>','<span style="color:#d70">a</span>','a','n'],
+ *   ['e','<span style="color:#d30">t</span>','<span style="color:#d00">a</span>','<span style="color:#d00">e</span>'],
+ *   ['i','<span style="color:#d70">h</span>','k','r'],
+ *   ['i','f','l','v']
+ * ]
+ * words = ["oath","pea","eat","rain"]
+ *
+ * Output: ["eat","oath"]
+ *
+ *
+ *
+ *
+ * Note:
+ *
+ * <ol>
+ * 	All inputs are consist of lowercase letters a-z.
+ * 	The values of words are distinct.
+ * </ol>
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+// TODO
+
+impl Solution {
+    pub fn find_words(board: Vec<Vec<char>>, words: Vec<String>) -> Vec<String> {
+        vec![]
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_212() {}
+}

src/n0213_house_robber_ii.rs

@@ -0,0 +1,66 @@
+/**
+ * [213] House Robber II
+ *
+ * You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. All houses at this place are arranged in a circle. That means the first house is the neighbor of the last one. Meanwhile, adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.
+ *
+ * Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.
+ *
+ * Example 1:
+ *
+ *
+ * Input: [2,3,2]
+ * Output: 3
+ * Explanation: You cannot rob house 1 (money = 2) and then rob house 3 (money = 2),
+ *              because they are adjacent houses.
+ *
+ *
+ * Example 2:
+ *
+ *
+ * Input: [1,2,3,1]
+ * Output: 4
+ * Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).
+ *              Total amount you can rob = 1 + 3 = 4.
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+// DP twice: rob first one || not rob first one
+// F[i] = max(F[i-2] + num[i], F[i-1])
+impl Solution {
+    pub fn rob(nums: Vec<i32>) -> i32 {
+        let mut max = i32::min_value();
+        for &rob_first in vec![true, false].iter() {
+            let (mut prev, mut curr) = (0, 0);
+            for (k, &num) in nums.iter().enumerate() {
+                if k == 0 && !rob_first {
+                    continue
+                }
+                // k is last element but not the first element
+                if k != 0 && k == (nums.len() - 1) && rob_first {
+                    continue
+                }
+                let next = i32::max(prev + num, curr);
+                prev = curr;
+                curr = next;
+            }
+            max = i32::max(max, curr)
+        }
+        max
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_213() {
+        assert_eq!(Solution::rob(vec![2,3,2], 3));
+        assert_eq!(Solution::rob(vec![1,2,3,1], 4));
+    }
+}