437_Path_Sum_III

Author: qiyuangong

README.md

@@ -130,6 +130,7 @@ Remember solutions are only solutions to given problems. If you want full study
 | 421 | [Maximum XOR of Two Numbers in an Array](https://leetcode.com/problems/maximum-xor-of-two-numbers-in-an-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/421_Maximum_XOR_of_Two_Numbers_in_an_Array.py) | Check 0~32 prefix, check if there is x y in prefixes, where x ^ y = answer ^ 1, O(32n) and O(n) |
 | 422 | [Valid Word Square](https://leetcode.com/problems/valid-word-square/) ♥ | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/422_Valid_Word_Square.py) | Compare row with column, O(n^2) |
 | 434 | [Number of Segments in a String](https://leetcode.com/problems/number-of-segments-in-a-string/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/434_Number_of_Segments_in_a_String.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/434_Number_of_Segments_in_a_String.java) | 1. trim &split<br>2. Find segment in place |
+| 437 | [Path Sum III](https://leetcode.com/problems/number-of-segments-in-a-string/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/437_Path_Sum_III.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/437_Path_Sum_III.java) | 1. Recursively travese the whole tree, O(n^2)<br>2. Cache sum in Hash based on 1.|
 | 438 | [Find All Anagrams in a String](https://leetcode.com/problems/number-of-segments-in-a-string/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/438_Find_All_Anagrams_in_a_String.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/438_Find_All_Anagrams_in_a_String.java) | Build a char count list with 26-256 length. Note that this list can be update when going through the string. O(n) and O(1) |
 | 443 | [String Compression](https://leetcode.com/problems/string-compression/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/443_String_Compression.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/443_String_Compression.java) | Maintain curr, read, write and anchor (start of this char). |
 | 453 | [Number of Segments in a String](https://leetcode.com/problems/minimum-moves-to-equal-array-elements/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/453_Minimum_Moves_to_Equal_Array_Elements.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/453_Minimum_Moves_to_Equal_Array_Elements.java) | Each move is equal to minus one element in array, so the answer is the sum of all elements after minus min. |

java/437_Path_Sum_III.java

@@ -0,0 +1,47 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    /*public int pathSum(TreeNode root, int sum) {
+        if (root != null) return findPaths(root, sum)
+            + pathSum(root.left, sum)
+            + pathSum(root.right, sum);
+        return 0;
+    }
+
+    private int findPaths(TreeNode root, int target) {
+        if (root != null) return (root.val == target? 1 : 0)
+            + findPaths(root.left, target - root.val)
+            + findPaths(root.right, target - root.val);
+        return 0;
+    }*/
+
+    private int result;
+    private HashMap<Integer, Integer> cache;
+
+    public int pathSum(TreeNode root, int sum) {
+        result = 0;
+        cache = new HashMap<Integer, Integer>();
+        cache.put(0, 1);
+        pathSumHelper(root, sum, 0);
+        return result;
+    }
+    // https://leetcode.com/problems/path-sum-iii/discuss/91892/Python-solution-with-detailed-explanation
+    private void pathSumHelper(TreeNode root, int target, int soFar) {
+        if (root != null) {
+            int complement = soFar + root.val - target;
+            if (cache.containsKey(complement))
+                result += cache.get(complement);
+            cache.put(soFar + root.val, cache.getOrDefault(soFar + root.val, 0) + 1);
+            pathSumHelper(root.left, target, soFar + root.val);
+            pathSumHelper(root.right, target, soFar + root.val);
+            cache.put(soFar + root.val, cache.get(soFar + root.val) - 1);
+        }
+    }
+}

python/437_Path_Sum_III.py

@@ -0,0 +1,49 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+
+# https://leetcode.com/problems/path-sum-iii/discuss/91892/Python-solution-with-detailed-explanation
+class Solution(object):
+    # def find_paths(self, root, target):
+    #     if root:
+    #         return int(root.val == target)
+    #         + self.find_paths(root.left, target - root.val)
+    #         + self.find_paths(root.right, target - root.val)
+    #     return 0
+
+    # def pathSum(self, root, sum):
+    #     """
+    #     :type root: TreeNode
+    #     :type sum: int
+    #     :rtype: int
+    #     """
+    #     if root:
+    #         return self.find_paths(root, sum)
+    #         + self.pathSum(root.left, sum)
+    #         + self.pathSum(root.right, sum)
+    #     return 0
+
+    def pathSumHelper(self, root, target, so_far, cache):
+        if root:
+            complement = so_far + root.val - target
+            if complement in cache:
+                self.result += cache[complement]
+            cache[so_far + root.val] = cache.get(so_far + root.val, 0) + 1
+            self.pathSumHelper(root.left, target, so_far + root.val, cache)
+            self.pathSumHelper(root.right, target, so_far + root.val, cache)
+            cache[so_far + root.val] -= 1
+        return
+
+    def pathSum(self, root, sum):
+        """
+        :type root: TreeNode
+        :type sum: int
+        :rtype: int
+        """
+        self.result = 0
+        self.pathSumHelper(root, sum, 0, {0: 1})
+        return self.result