update tree

Author: StephenLeeUSTC

src/solution/mod.rs

@@ -14,3 +14,6 @@ mod s1011_capacity_to_ship_packages_within_d_days;
 mod s0137_single_number_ii;
 mod s0403_frog_jump;
 mod s0633_sum_of_square_numbers;
+mod s0112_path_sum;
+mod s0129_sum_root_to_leaf_numbers;
+mod s0814_binary_tree_pruning;

src/solution/s0112_path_sum.rs

@@ -0,0 +1,92 @@
+/**
+ * [112] Path Sum
+ *
+ * Given the root of a binary tree and an integer targetSum, return true if the tree has a root-to-leaf path such that adding up all the values along the path equals targetSum.
+ * A leaf is a node with no children.
+ *  
+ * Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/pathsum1.jpg" style="width: 500px; height: 356px;" />
+ * Input: root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
+ * Output: true
+ * 
+ * Example 2:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/pathsum2.jpg" />
+ * Input: root = [1,2,3], targetSum = 5
+ * Output: false
+ * 
+ * Example 3:
+ * 
+ * Input: root = [1,2], targetSum = 0
+ * Output: false
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	The number of nodes in the tree is in the range [0, 5000].
+ * 	-1000 <= Node.val <= 1000
+ * 	-1000 <= targetSum <= 1000
+ * 
+ */
+pub struct Solution {}
+use crate::util::tree::{TreeNode, to_tree};
+
+// problem: https://leetcode.com/problems/path-sum/
+// discuss: https://leetcode.com/problems/path-sum/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+// 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
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn has_path_sum(root: Option<Rc<RefCell<TreeNode>>>, target_sum: i32) -> bool {
+        if let Some(p) = root {
+            let left = p.borrow_mut().left.take();
+            let right = p.borrow_mut().right.take();
+            
+            let val = p.borrow_mut().val;
+
+            if left.is_none() && right.is_none() && val == target_sum {
+                return true;
+            }
+            if Self::has_path_sum(left, target_sum - val) {
+                return true;
+            }
+            if Self::has_path_sum(right, target_sum - val) {
+                return true;
+            }
+        }
+        false
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_112() {
+        assert_eq!(Solution::has_path_sum(tree![5,4,8,11,null,13,4,7,2,null,null,null,1], 22), true);
+        assert_eq!(Solution::has_path_sum(tree![1, 2, 3], 5), false);
+        assert_eq!(Solution::has_path_sum(tree![1, 2], 0), false);
+    }
+}

src/solution/s0129_sum_root_to_leaf_numbers.rs

@@ -0,0 +1,103 @@
+/**
+ * [129] Sum Root to Leaf Numbers
+ *
+ * You are given the root of a binary tree containing digits from 0 to 9 only.
+ * Each root-to-leaf path in the tree represents a number.
+ * 
+ * 	For example, the root-to-leaf path 1 -> 2 -> 3 represents the number 123.
+ * 
+ * Return the total sum of all root-to-leaf numbers. Test cases are generated so that the answer will fit in a 32-bit integer.
+ * A leaf node is a node with no children.
+ *  
+ * Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/num1tree.jpg" style="width: 212px; height: 182px;" />
+ * Input: root = [1,2,3]
+ * Output: 25
+ * Explanation:
+ * The root-to-leaf path 1->2 represents the number 12.
+ * The root-to-leaf path 1->3 represents the number 13.
+ * Therefore, sum = 12 + 13 = 25.
+ * 
+ * Example 2:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/num2tree.jpg" style="width: 292px; height: 302px;" />
+ * Input: root = [4,9,0,5,1]
+ * Output: 1026
+ * Explanation:
+ * The root-to-leaf path 4->9->5 represents the number 495.
+ * The root-to-leaf path 4->9->1 represents the number 491.
+ * The root-to-leaf path 4->0 represents the number 40.
+ * Therefore, sum = 495 + 491 + 40 = 1026.
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	The number of nodes in the tree is in the range [1, 1000].
+ * 	0 <= Node.val <= 9
+ * 	The depth of the tree will not exceed 10.
+ * 
+ */
+pub struct Solution {}
+use crate::util::tree::{TreeNode, to_tree};
+
+// problem: https://leetcode.com/problems/sum-root-to-leaf-numbers/
+// discuss: https://leetcode.com/problems/sum-root-to-leaf-numbers/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+// 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
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn sum_numbers(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        let mut res = 0;
+        Self::helper(root, &mut res, 0);
+        return res;
+    }
+
+    pub fn helper(root: Option<Rc<RefCell<TreeNode>>>, res: &mut i32, path: i32) {
+        if let Some(p) = root {
+           let left = p.borrow_mut().left.take(); 
+           let right = p.borrow_mut().right.take(); 
+           let val = p.borrow_mut().val;
+           if left.is_none() && right.is_none() {
+               *res += path * 10 + val;
+           }
+           if left.is_some() {
+               Self::helper(left, res, path * 10 + val);
+           }
+           if right.is_some() {
+               Self::helper(right, res, path * 10 + val);
+           }
+        }
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_129() {
+        assert_eq!(Solution::sum_numbers(tree![1, 2, 3]), 25);
+        assert_eq!(Solution::sum_numbers(tree![4,9,0,5,1]), 1026);
+    }
+}

src/solution/s0814_binary_tree_pruning.rs

@@ -0,0 +1,98 @@
+/**
+ * [814] Binary Tree Pruning
+ *
+ * We are given the head node root of a binary tree, where additionally every node's value is either a 0 or a 1.
+ * Return the same tree where every subtree (of the given tree) not containing a 1 has been removed.
+ * (Recall that the subtree of a node X is X, plus every node that is a descendant of X.)
+ * 
+ * Example 1:
+ * Input: [1,null,0,0,1]
+ * Output: [1,null,0,null,1]
+ *  
+ * Explanation: 
+ * Only the red nodes satisfy the property "every subtree not containing a 1".
+ * The diagram on the right represents the answer.
+ * <img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/06/1028_2.png" style="width:450px" />
+ * 
+ * Example 2:
+ * Input: [1,0,1,0,0,0,1]
+ * Output: [1,null,1,null,1]
+ * 
+ * <img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/06/1028_1.png" style="width:450px" />
+ * 
+ * Example 3:
+ * Input: [1,1,0,1,1,0,1,0]
+ * Output: [1,1,0,1,1,null,1]
+ * 
+ * <img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/05/1028.png" style="width:450px" />
+ * 
+ * Note: 
+ * 
+ * 	The binary tree will have at most 200 nodes.
+ * 	The value of each node will only be 0 or 1.
+ * 
+ */
+pub struct Solution {}
+use crate::util::tree::{TreeNode, to_tree};
+
+// problem: https://leetcode.com/problems/binary-tree-pruning/
+// discuss: https://leetcode.com/problems/binary-tree-pruning/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+// 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
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn prune_tree(root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
+        if let Some(p) = root {
+            let left = p.borrow_mut().left.take();
+            let left_a = Self::prune_tree(left);
+
+            let right = p.borrow_mut().right.take();
+            let right_a = Self::prune_tree(right);
+
+            if left_a.is_none() && right_a.is_none() && p.borrow_mut().val == 0 {
+                return None;
+            } else {
+                p.borrow_mut().left = left_a;
+                p.borrow_mut().right = right_a;
+            }
+            return Some(p);
+        }
+        None
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_814() {
+        assert_eq!(Solution::prune_tree(tree![1,0,1,0,0,0,1]), tree![1,null,1,null,1]);
+        assert_eq!(Solution::prune_tree(tree![1,null,0,0,1]), tree![1,null,0,null,1]);
+        assert_eq!(Solution::prune_tree(tree![1,1,0,1,1,0,1,0]), tree![1,1,0,1,1,null,1]);
+        assert_eq!(Solution::prune_tree(tree![0, 0, 0]), tree![]);
+        assert_eq!(Solution::prune_tree(tree![0]), tree![]);
+    }
+}