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);
 }