437. 路径总和 III

src/main.rs

@@ -1,32 +1,44 @@
+mod tree;
+use std::rc::Rc;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use tree::{TreeNode, build_tree};
+
 struct Solution;
+
 impl Solution {
-    pub fn first_missing_positive(mut nums: Vec<i32>) -> i32 {
-        for i in 0..nums.len(){
-            if nums[i] <= 0 || nums[i] > nums.len() as i32 {
-                continue;
-            }
-            let mut temp = nums[i];
-            nums[i] = -1;
-            while temp > 0 && temp <= nums.len() as i32 {
-                let temp2 = nums[temp as usize - 1];
-                nums[temp as usize - 1] = temp;
-                if temp == temp2 {
-                    break;
-                }
-                temp = temp2;
-            }
+    fn dfs(root: Option<Rc<RefCell<TreeNode>>>, target: i64) -> (HashMap<i64,i32>,i32) {
+        if root.is_none() {
+            return (HashMap::new(),0);
         }
-        println!("{:?}", nums);
-        for i in 0..nums.len(){
-            if nums[i] != (i as i32 + 1) {
-                return i as i32 + 1;
-            }
+        let node = root.unwrap();
+        let val = node.borrow().val;
+        let val = val as i64;
+        let mut ans = if val == target { 1 } else { 0 };
+        let (left,left_ans) = Self::dfs(node.borrow().left.clone(), target);
+        let (right, right_ans) = Self::dfs(node.borrow().right.clone(), target);
+        ans += left_ans + right_ans;
+        ans += *left.get(&(target - val)).unwrap_or(&0);
+        ans += *right.get(&(target - val)).unwrap_or(&0);
+        let mut map = HashMap::new();
+        map.insert(val, 1);
+        for (k,v) in left.iter().chain(right.iter()) {
+            *map.entry(k + val).or_insert(0) += v;
         }
-        nums.len() as i32 + 1
+        (map,ans)
+    }
+    pub fn path_sum(root: Option<Rc<RefCell<TreeNode>>>, target_sum: i32) -> i32 {
+        let (_,ans) = Self::dfs(root, target_sum as i64);
+        ans
     }
 }
 
 fn main() {
-    let sl = Solution::first_missing_positive(vec![1]);
+    let vals = vec![
+        Some(10), Some(5), Some(-3), Some(3), Some(2), None, Some(11),
+        Some(3), Some(-2), None, Some(1)
+    ];
+    let root = build_tree(&vals);
+    let sl = Solution::path_sum(root, 8);
     println!("{:?}", sl);
 }

src/tree.rs

@@ -0,0 +1,48 @@
+use std::rc::Rc;
+use std::cell::RefCell;
+use std::collections::VecDeque;
+
+#[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 fn build_tree(vals: &[Option<i32>]) -> Option<Rc<RefCell<TreeNode>>> {
+    if vals.is_empty() || vals[0].is_none() {
+        return None;
+    }
+    let root = Rc::new(RefCell::new(TreeNode::new(vals[0].unwrap())));
+    let mut queue = VecDeque::new();
+    queue.push_back(root.clone());
+    let mut i = 1;
+    while i < vals.len() {
+        if let Some(node) = queue.pop_front() {
+            if i < vals.len() {
+                if let Some(val) = vals[i] {
+                    let left = Rc::new(RefCell::new(TreeNode::new(val)));
+                    node.borrow_mut().left = Some(left.clone());
+                    queue.push_back(left);
+                }
+                i += 1;
+            }
+            if i < vals.len() {
+                if let Some(val) = vals[i] {
+                    let right = Rc::new(RefCell::new(TreeNode::new(val)));
+                    node.borrow_mut().right = Some(right.clone());
+                    queue.push_back(right);
+                }
+                i += 1;
+            }
+        }
+    }
+    Some(root)
+}