feat: update solutions to lc problem: No.0437

No.0437.Path Sum III

Author: yanglbme

solution/0400-0499/0437.Path Sum III/README.md

@@ -43,7 +43,23 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-在遍历的过程中，记录当前路径上的前缀和
+**方法一：哈希表 + 前缀和 + 递归**
+
+我们可以运用前缀和的思想，对二叉树进行递归遍历，同时用哈希表 $cnt$ 统计从根节点到当前节点的路径上各个前缀和出现的次数。
+
+我们设计一个递归函数 $dfs(node, s)$，表示当前遍历到的节点为 $node$，从根节点到当前节点的路径上的前缀和为 $s$。函数的返回值是统计以 $node$ 节点及其子树节点作为路径终点且路径和为 $targetSum$ 的路径数目。那么答案就是 $dfs(root, 0)$。
+
+函数 $dfs(node, s)$ 的递归过程如下：
+
+-   如果当前节点 $node$ 为空，则返回 $0$。
+-   计算从根节点到当前节点的路径上的前缀和 $s$。
+-   用 $cnt[s - targetSum]$ 表示以当前节点为路径终点且路径和为 $targetSum$ 的路径数目，其中 $cnt[s - targetSum]$ 即为 $cnt$ 中前缀和为 $s - targetSum$ 的个数。
+-   将前缀和 $s$ 的计数值加 $1$，即 $cnt[s] = cnt[s] + 1$。
+-   递归地遍历当前节点的左右子节点，即调用函数 $dfs(node.left, s)$ 和 $dfs(node.right, s)$，并将它们的返回值相加。
+-   在返回值计算完成以后，需要将当前节点的前缀和 $s$ 的计数值减 $1$，即执行 $cnt[s] = cnt[s] - 1$。
+-   最后返回答案。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉树的节点个数。
 
 <!-- tabs:start -->
 
@@ -59,24 +75,19 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def pathSum(self, root: TreeNode, targetSum: int) -> int:
-        preSum = defaultdict(int)
-        preSum[0] = 1
-
-        def dfs(node: TreeNode, cur: int) -> int:
-            if not node:
+    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> int:
+        def dfs(node, s):
+            if node is None:
                 return 0
-
-            cur += node.val
-            ret = preSum[cur - targetSum]
-
-            preSum[cur] += 1
-            ret += dfs(node.left, cur)
-            ret += dfs(node.right, cur)
-            preSum[cur] -= 1
-
-            return ret
-
+            s += node.val
+            ans = cnt[s - targetSum]
+            cnt[s] += 1
+            ans += dfs(node.left, s)
+            ans += dfs(node.right, s)
+            cnt[s] -= 1
+            return ans
+
+        cnt = Counter({0: 1})
         return dfs(root, 0)
 ```
 
@@ -101,68 +112,30 @@ class Solution:
  * }
  */
 class Solution {
-
-    private final Map<Integer, Integer> preSum = new HashMap<>();
+    private Map<Long, Integer> cnt = new HashMap<>();
+    private int targetSum;
 
     public int pathSum(TreeNode root, int targetSum) {
-        preSum.put(0, 1);
-        return dfs(root, 0, targetSum);
+        cnt.put(0L, 1);
+        this.targetSum = targetSum;
+        return dfs(root, 0);
     }
 
-    private int dfs(TreeNode node, int cur, int targetSum) {
+    private int dfs(TreeNode node, long s) {
         if (node == null) {
             return 0;
         }
-
-        cur += node.val;
-        int ret = preSum.getOrDefault(cur - targetSum, 0);
-
-        preSum.merge(cur, 1, Integer::sum);
-        ret += dfs(node.left, cur, targetSum);
-        ret += dfs(node.right, cur, targetSum);
-        preSum.merge(cur, -1, Integer::sum);
-
-        return ret;
+        s += node.val;
+        int ans = cnt.getOrDefault(s - targetSum, 0);
+        cnt.merge(s, 1, Integer::sum);
+        ans += dfs(node.left, s);
+        ans += dfs(node.right, s);
+        cnt.merge(s, -1, Integer::sum);
+        return ans;
     }
 }
 ```
 
-### **Go**
-
-```go
-/**
- * Definition for a binary tree node.
- * type TreeNode struct {
- *     Val int
- *     Left *TreeNode
- *     Right *TreeNode
- * }
- */
-func pathSum(root *TreeNode, targetSum int) int {
-	preSum := make(map[int]int)
-	preSum[0] = 1
-
-	var dfs func(*TreeNode, int) int
-	dfs = func(node *TreeNode, cur int) int {
-		if node == nil {
-			return 0
-		}
-
-		cur += node.Val
-		ret := preSum[cur-targetSum]
-
-		preSum[cur]++
-		ret += dfs(node.Left, cur)
-		ret += dfs(node.Right, cur)
-		preSum[cur]--
-
-		return ret
-	}
-
-	return dfs(root, 0)
-}
-```
-
 ### **C++**
 
 ```cpp
@@ -180,30 +153,51 @@ func pathSum(root *TreeNode, targetSum int) int {
 class Solution {
 public:
     int pathSum(TreeNode* root, int targetSum) {
-        unordered_map<int, int> preSum;
-        preSum[0] = 1;
-
-        function<int(TreeNode*, int)> dfs = [&](TreeNode* node, int cur) {
-            if (node == nullptr) {
-                return 0;
-            }
-
-            cur += node->val;
-            int ret = preSum[cur - targetSum];
-
-            ++preSum[cur];
-            ret += dfs(node->left, cur);
-            ret += dfs(node->right, cur);
-            --preSum[cur];
-
-            return ret;
+        unordered_map<long, int> cnt;
+        cnt[0] = 1;
+        function<int(TreeNode*, long)> dfs = [&](TreeNode* node, long s) -> int {
+            if (!node) return 0;
+            s += node->val;
+            int ans = cnt[s - targetSum];
+            ++cnt[s];
+            ans += dfs(node->left, s) + dfs(node->right, s);
+            --cnt[s];
+            return ans;
         };
-
         return dfs(root, 0);
     }
 };
 ```
 
+### **Go**
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func pathSum(root *TreeNode, targetSum int) int {
+	cnt := map[int]int{0: 1}
+	var dfs func(*TreeNode, int) int
+	dfs = func(node *TreeNode, s int) int {
+		if node == nil {
+			return 0
+		}
+		s += node.Val
+		ans := cnt[s-targetSum]
+		cnt[s]++
+		ans += dfs(node.Left, s) + dfs(node.Right, s)
+		cnt[s]--
+		return ans
+	}
+	return dfs(root, 0)
+}
+```
+
 ### **...**
 
 ```