Added task 437.

Author: javadev

src/main/java/com_github_leetcode/TreeNode.java

@@ -1,5 +1,9 @@
 package com_github_leetcode;
 
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
 @SuppressWarnings("java:S1104")
 public class TreeNode {
     public int val;
@@ -16,26 +20,24 @@ public TreeNode(int val, TreeNode left, TreeNode right) {
         this.right = right;
     }
 
-    private static int index = 0;
-
-    public static TreeNode create(int[] arr) {
-        index = 0;
-        return create1(arr);
-    }
-
-    private static TreeNode create1(int[] arr) {
-        if (arr.length == index) {
-            return null;
-        }
-        if (arr[index] == '#') {
-            index++;
-            return null;
-        } else {
-            TreeNode res = new TreeNode(arr[index++]);
-            res.left = create1(arr);
-            res.right = create1(arr);
-            return res;
+    public static TreeNode create(List<Integer> treeValues) {
+        TreeNode root = new TreeNode(treeValues.get(0));
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+        int i = 1;
+        while (i < treeValues.size()) {
+            TreeNode curr = queue.poll();
+            if (treeValues.get(i) != null) {
+                curr.left = new TreeNode(treeValues.get(i));
+                queue.offer(curr.left);
+            }
+            if (++i < treeValues.size() && treeValues.get(i) != null) {
+                curr.right = new TreeNode(treeValues.get(i));
+                queue.offer(curr.right);
+            }
+            i++;
         }
+        return root;
     }
 
     public String toString() {

src/main/java/g0401_0500/s0437_path_sum_iii/Solution.java

@@ -0,0 +1,45 @@
+package g0401_0500.s0437_path_sum_iii;
+
+// #Medium #Top_100_Liked_Questions #Depth_First_Search #Tree #Binary_Tree
+
+import com_github_leetcode.TreeNode;
+import java.util.HashMap;
+import java.util.Map;
+
+/*
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    private int count(TreeNode root, int targetSum, Map<Integer, Integer> hashMap, int currentSum) {
+        if (root == null) {
+            return 0;
+        }
+        int count = 0;
+        if (hashMap.containsKey(currentSum + root.val - targetSum)) {
+            count = count + hashMap.get(currentSum + root.val - targetSum);
+        }
+        hashMap.put(currentSum + root.val, hashMap.getOrDefault(currentSum + root.val, 0) + 1);
+        int l1 = count(root.left, targetSum, hashMap, currentSum + root.val);
+        int l2 = count(root.right, targetSum, hashMap, currentSum + root.val);
+        hashMap.put(currentSum + root.val, hashMap.getOrDefault(currentSum + root.val, 0) - 1);
+        return l1 + l2 + count;
+    }
+
+    public int pathSum(TreeNode root, int targetSum) {
+        Map<Integer, Integer> map = new HashMap<>();
+        map.put(0, 1);
+        return count(root, targetSum, map, 0);
+    }
+}

src/main/java/g0401_0500/s0437_path_sum_iii/readme.md

@@ -0,0 +1,29 @@
+437\. Path Sum III
+
+Medium
+
+Given the `root` of a binary tree and an integer `targetSum`, return _the number of paths where the sum of the values along the path equals_ `targetSum`.
+
+The path does not need to start or end at the root or a leaf, but it must go downwards (i.e., traveling only from parent nodes to child nodes).
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/09/pathsum3-1-tree.jpg)
+
+**Input:** root = \[10,5,-3,3,2,null,11,3,-2,null,1\], targetSum = 8
+
+**Output:** 3
+
+**Explanation:** The paths that sum to 8 are shown. 
+
+**Example 2:**
+
+**Input:** root = \[5,4,8,11,null,13,4,7,2,null,null,5,1\], targetSum = 22
+
+**Output:** 3 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 1000]`.
+*   <code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code>
+*   `-1000 <= targetSum <= 1000`

src/test/java/g0101_0200/s0124_binary_tree_maximum_path_sum/SolutionTest.java

@@ -4,12 +4,13 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import com_github_leetcode.TreeNode;
+import java.util.Arrays;
 import org.junit.jupiter.api.Test;
 
 class SolutionTest {
     @Test
     void findMaxPathSum() {
-        TreeNode treeNode = TreeNode.create(new int[] {1, 2, 3});
+        TreeNode treeNode = TreeNode.create(Arrays.asList(1, 2, null, 3));
         assertThat(new Solution().findMaxPathSum(treeNode), equalTo(6));
     }
 }

src/test/java/g0401_0500/s0437_path_sum_iii/SolutionTest.java

@@ -0,0 +1,33 @@
+package g0401_0500.s0437_path_sum_iii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com_github_leetcode.TreeNode;
+import java.util.Arrays;
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void pathSum() {
+        assertThat(
+                new Solution()
+                        .pathSum(
+                                TreeNode.create(
+                                        Arrays.asList(10, 5, -3, 3, 2, null, 11, 3, -2, null, 1)),
+                                8),
+                equalTo(3));
+    }
+
+    @Test
+    void pathSum2() {
+        assertThat(
+                new Solution()
+                        .pathSum(
+                                TreeNode.create(
+                                        Arrays.asList(
+                                                5, 4, 8, 11, null, 13, 4, 7, 2, null, null, 5, 1)),
+                                22),
+                equalTo(3));
+    }
+}