Merge pull request #40 from jtr109/develop

Develop

Author: jtr109

Cargo.lock

@@ -43,4 +43,13 @@ members = [
     "maximum_performance_of_a_team",
     "longest_consecutive_sequence",
     "min_cost_climbing_stairs",
+    "construct_binary_tree_from_preorder_and_inorder_traversal",
+    "jump_game_vi",
+    "my_calendar_i",
+    "stone_game_vii",
+    "minumum_number_of_refueling_stops",
+    "palindrome_pairs",
+    "matchsticks_to_square",
+    "generate_parentheses",
+    "number_of_subarrays_with_bounded_maximum",
 ]

Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "construct_binary_tree_from_preorder_and_inorder_traversal"
+version = "0.1.0"
+authors = ["Ryan Li <conbas2019@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

construct_binary_tree_from_preorder_and_inorder_traversal/Cargo.toml

@@ -0,0 +1,91 @@
+use std::cell::RefCell;
+use std::ops::Index;
+use std::rc::Rc;
+
+// Definition for a binary tree node.
+#[derive(Debug, PartialEq, Eq)]
+pub struct TreeNode {
+    pub val: i32,
+    pub left: Option<Rc<RefCell<TreeNode>>>,
+    pub right: Option<Rc<RefCell<TreeNode>>>,
+}
+
+impl TreeNode {
+    #[inline]
+    pub fn new(val: i32) -> Self {
+        TreeNode {
+            val,
+            left: None,
+            right: None,
+        }
+    }
+}
+
+pub struct Solution {}
+
+impl Solution {
+    pub fn build_tree(preorder: Vec<i32>, inorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
+        match preorder.iter().nth(0) {
+            None => None,
+            Some(val) => {
+                let index = inorder.iter().position(|v| val == v).unwrap();
+                let left_inorder = inorder[..index].to_vec();
+                let left_preorder = preorder[1..1 + index].to_vec();
+                let right_inorder = inorder[index + 1..].to_vec();
+                let right_preorder = preorder[1 + index..].to_vec();
+                Some(Rc::new(RefCell::new(TreeNode {
+                    val: *val,
+                    left: Self::build_tree(left_preorder, left_inorder),
+                    right: Self::build_tree(right_preorder, right_inorder),
+                })))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn example_1() {
+        let preorder = [3, 9, 20, 15, 7];
+        let inorder = [9, 3, 15, 20, 7];
+        let expected = Some(Rc::new(RefCell::new(TreeNode {
+            val: 3,
+            left: Some(Rc::new(RefCell::new(TreeNode {
+                val: 9,
+                left: None,
+                right: None,
+            }))),
+            right: Some(Rc::new(RefCell::new(TreeNode {
+                val: 20,
+                left: Some(Rc::new(RefCell::new(TreeNode {
+                    val: 15,
+                    left: None,
+                    right: None,
+                }))),
+                right: Some(Rc::new(RefCell::new(TreeNode {
+                    val: 7,
+                    left: None,
+                    right: None,
+                }))),
+            }))),
+        })));
+        assert_eq!(
+            Solution::build_tree(preorder.to_vec(), inorder.to_vec()),
+            expected
+        );
+    }
+
+    #[test]
+    fn example_2() {
+        let preorder = [-1];
+        let inorder = [-1];
+        let expected = Some(Rc::new(RefCell::new(TreeNode::new(-1))));
+        assert_eq!(
+            Solution::build_tree(preorder.to_vec(), inorder.to_vec()),
+            expected
+        );
+    }
+}

construct_binary_tree_from_preorder_and_inorder_traversal/src/lib.rs

@@ -0,0 +1,9 @@
+[package]
+name = "generate_parentheses"
+version = "0.1.0"
+authors = ["Ryan Li <conbas2019@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

generate_parentheses/Cargo.toml

@@ -0,0 +1,67 @@
+/*!
+ * Follow solution: https://leetcode.com/problems/generate-parentheses/discuss/10100/Easy-to-understand-Java-backtracking-solution
+ */
+
+pub struct Solution {}
+
+impl Solution {
+    pub fn generate_parenthesis(n: i32) -> Vec<String> {
+        let mut list = Vec::new();
+        Self::backtrack(&mut list, "".to_string(), 0, 0, n as usize);
+        list
+    }
+
+    fn backtrack(list: &mut Vec<String>, s: String, open: usize, close: usize, max: usize) {
+        // 如果前缀为 s 的值，获取所有可能性，加入 list
+        if (s.chars().count()) == max * 2 {
+            list.push(s);
+            return;
+        }
+
+        if open < max {
+            // 如果前缀中的 `(` 数量达到最大值，不再往前缀中加入 `(`
+            Self::backtrack(list, s.clone() + "(", open + 1, close, max);
+        }
+        if close < open {
+            // 如果前缀中的 `)` 数量和 `(` 数量一样多了，不再往前缀中加入 `)`
+            Self::backtrack(list, s.clone() + ")", open, close + 1, max);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn it_works(n: i32, expected: Vec<&str>) {
+        let mut result = Solution::generate_parenthesis(n);
+        let mut exp = expected.to_vec();
+        result.sort();
+        exp.sort();
+        assert_eq!(result, exp);
+    }
+
+    #[test]
+    fn example_1() {
+        let n = 3;
+        let expected = ["((()))", "(()())", "(())()", "()(())", "()()()"];
+        it_works(n, expected.to_vec());
+    }
+
+    #[test]
+    fn example_2() {
+        let n = 1;
+        let expected = ["()"];
+        it_works(n, expected.to_vec());
+    }
+
+    #[test]
+    fn submission_1() {
+        let n = 4;
+        let expected = [
+            "(((())))", "((()()))", "((())())", "((()))()", "(()(()))", "(()()())", "(()())()",
+            "(())(())", "(())()()", "()((()))", "()(()())", "()(())()", "()()(())", "()()()()",
+        ];
+        it_works(n, expected.to_vec());
+    }
+}

generate_parentheses/src/lib.rs

@@ -0,0 +1,9 @@
+[package]
+name = "jump_game_vi"
+version = "0.1.0"
+authors = ["Ryan Li <conbas2019@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]