2024/9/2 Hot100 binaryTree

src/main/java/com/cool/hot100/binary_tree/Num236.java

@@ -0,0 +1,46 @@
+package com.cool.hot100.binary_tree;
+
+import java.util.*;
+
+/**
+ * Created with IntelliJ IDEA.
+ *
+ * @Author: Cool
+ * @Date: 2024/09/02/14:38
+ * DayNumber 2
+ * Hard 2
+ * Level ?
+ */
+public class Num236 {
+
+    Map<Integer, TreeNode> map = new HashMap<>();
+    LinkedList<TreeNode> list = new LinkedList<>();
+    List<LinkedList<TreeNode>> linkedLists = new ArrayList<>();
+
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == null) return null;
+        dfs(root, p, q);
+        TreeNode node=new TreeNode();
+        LinkedList<TreeNode> treeNodes = linkedLists.get(0);
+        for (TreeNode treeNode : treeNodes) {
+            if(linkedLists.get(1).contains(treeNode)){
+                node=treeNode;
+            }
+        }
+        return node;
+    }
+
+    private void dfs(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == null) return;
+        list.add(root);
+        map.put(root.val, root);
+        if (root==p||root==q){
+            LinkedList<TreeNode> copyList = new LinkedList<>(list);
+            linkedLists.add(copyList);
+        }
+        dfs(root.left, p, q);
+        dfs(root.right, p, q);
+        list.pollLast();
+    }
+
+}

src/main/java/com/cool/hot100/binary_tree/Num437.java

@@ -0,0 +1,64 @@
+package com.cool.hot100.binary_tree;
+
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+
+/**
+ * Created with IntelliJ IDEA.
+ *
+ * @Author: Cool
+ * @Date: 2024/09/02/10:25
+ * DayNumber 1
+ * Hard 2
+ * Level ?
+ */
+public class Num437 {
+
+    Map<Long, Integer> map = new HashMap<>();
+
+    public int pathSum(TreeNode root, int targetSum) {
+        map.put(0L, 1);
+        return  pathSum(root, targetSum, 0L);
+    }
+
+    public int pathSum(TreeNode root, int targetSum, Long sum) {
+        if (root == null) {
+            return 0;
+        }
+        int returnNum = 0;
+        sum += root.val;
+        returnNum = map.getOrDefault(sum - targetSum, 0);
+        map.put(sum, map.getOrDefault(sum, 0) + 1);
+        returnNum += pathSum(root.left, targetSum, sum);
+        returnNum += pathSum(root.right, targetSum, sum);
+        map.put(sum, map.getOrDefault(sum, 0) - 1);
+        return returnNum;
+    }
+
+    @Test
+    public void test() {
+        TreeNode node11 = new TreeNode(1);
+        TreeNode node121 = new TreeNode(-2);
+        TreeNode node = new TreeNode(1);
+        TreeNode node1 = new TreeNode(3);
+        TreeNode node2 = new TreeNode(11);
+        TreeNode node3 = new TreeNode(2);
+        TreeNode node4 = new TreeNode(3);
+        TreeNode node5 = new TreeNode(-3);
+        TreeNode node6 = new TreeNode(5);
+        TreeNode node7 = new TreeNode(10);
+        node7.left = node6;
+        node7.right = node5;
+        node6.left = node4;
+        node6.right = node3;
+        node5.right = node2;
+        node4.left = node1;
+        node4.right = node121;
+        node3.right = node11;
+    }
+}
+
+