solve problem Path Sum III

Author: P-ppc

README.md

@@ -126,6 +126,7 @@ All solutions will be accepted!
 |844|[Backspace String Compare](https://leetcode-cn.com/problems/backspace-string-compare/description/)|[java/py/js](./algorithms/BackspaceStringCompare)|Easy|
 |26|[Remove Duplicates From Sorted Array](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/description/)|[java/py/js](./algorithms/RemoveDuplicatesFromSortedArray)|Easy|
 |112|[Path Sum](https://leetcode-cn.com/problems/path-sum/description/)|[java/py/js](./algorithms/PathSum)|Easy|
+|437|[Path Sum III](https://leetcode-cn.com/problems/path-sum-iii/description/)|[java/py/js](./algorithms/PathSumIII)|Easy|
 |263|[Ugly Number](https://leetcode-cn.com/problems/ugly-number/description/)|[java/py/js](./algorithms/UglyNumber)|Easy|
 |783|[Minimum Distance Between Bst Nodes](https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/description/)|[java/py/js](./algorithms/MinimumDistanceBetweenBstNodes)|Easy|
 |747|[Largest Number At Least Twice Of Others](https://leetcode-cn.com/problems/largest-number-at-least-twice-of-others/description/)|[java/py/js](./algorithms/LargestNumberAtLeastTwiceOfOthers)|Easy|

algorithms/PathSumIII/README.md

@@ -0,0 +1,2 @@
+# Path Sum III
+This problem is easy to solve by recursive

algorithms/PathSumIII/Solution.java

@@ -0,0 +1,34 @@
+/**
+ * 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) {
+        return helper(root, sum, 0, new ArrayList<Integer>());       
+    }
+    
+    public int helper(TreeNode node, int sum, int curSum, List<Integer> paths) {
+        if (node == null) return 0;
+        
+        int res = 0;
+        curSum += node.val;
+        paths.add(node.val);
+        
+        if (curSum == sum) res++;
+        int tempSum = curSum;
+        
+        for (int i = 0; i < paths.size() - 1; i++) {
+            tempSum -= paths.get(i);
+            if (tempSum == sum) res++;
+        }
+        
+        if (node.left != null) res += helper(node.left, sum, curSum, new ArrayList<Integer>(paths));
+        if (node.right != null) res += helper(node.right, sum, curSum, new ArrayList<Integer>(paths));
+        return res;
+    }
+}

algorithms/PathSumIII/solution.js

@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} sum
+ * @return {number}
+ */
+var pathSum = function(root, sum) {
+    return helper(root, sum, 0, [])
+};
+
+var helper = function(node, sum, curSum, paths) {
+    if (!node) {
+        return 0
+    }
+    
+    let res = 0
+    curSum += node.val
+    paths.push(node.val)
+    
+    if (curSum === sum) {
+        res++
+    }
+    let tempSum = curSum
+    
+    for (let i = 0; i < paths.length - 1; i++) {
+        tempSum -= paths[i]
+        if (tempSum === sum) {
+            res++
+        }
+    }
+    
+    if (node.left) {
+        res += helper(node.left, sum, curSum, paths.slice(0))
+    }
+    if (node.right) {
+        res += helper(node.right, sum, curSum, paths.slice(0))
+    }
+    return res
+}

algorithms/PathSumIII/solution.py

@@ -0,0 +1,39 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def pathSum(self, root, sum):
+        """
+        :type root: TreeNode
+        :type sum: int
+        :rtype: int
+        """
+        return self.helper(root, sum, 0, [])
+    
+    def helper(self, node, sm, cur_sum, paths):
+        if not node:
+            return 0
+        
+        res = 0
+        cur_sum += node.val
+        paths.append(node.val)
+        
+        if cur_sum == sm:
+            res += 1
+        temp_sum = cur_sum
+        for i in range(len(paths) - 1):
+            temp_sum -= paths[i]
+            if temp_sum == sm:
+                res += 1
+        
+        
+        if node.left:
+            res += self.helper(node.left, sm, cur_sum, paths[:])
+        if node.right:
+            res += self.helper(node.right, sm, cur_sum, paths[:])
+            
+        return res