add 1214

Author: fishercoder1534

README.md

@@ -56,6 +56,7 @@ _If you like this project, please leave me a star._ ★
 |1228|[Missing Number In Arithmetic Progression](https://leetcode.com/problems/missing-number-in-arithmetic-progression/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1228.java) |   |Easy||
 |1221|[Split a String in Balanced Strings](https://leetcode.com/problems/split-a-string-in-balanced-strings/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1221.java) | |Easy|Greedy|
 |1217|[Play with Chips](https://leetcode.com/problems/play-with-chips/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1217.java) |   |Easy|Array, Math, Greedy|
+|1214|[Two Sum BSTs](https://leetcode.com/problems/two-sum-bsts/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1214.java) |   |Medium| Binary Search Tree|
 |1213|[Intersection of Three Sorted Arrays](https://leetcode.com/problems/intersection-of-three-sorted-arrays/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1213.java) |   [:tv:](https://www.youtube.com/watch?v=zceoOrHSHNQ)|Easy||
 |1207|[Unique Number of Occurrences](https://leetcode.com/problems/unique-number-of-occurrences/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1207.java) | [:tv:](https://www.youtube.com/watch?v=_NYimlZY1PE)|Easy||
 |1200|[Minimum Absolute Difference](https://leetcode.com/problems/minimum-absolute-difference/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1200.java) | [:tv:](https://www.youtube.com/watch?v=mH1aEjOEjcQ)|Easy||

src/main/java/com/fishercoder/solutions/_1214.java

@@ -0,0 +1,88 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 1214. Two Sum BSTs
+ *
+ * Given two binary search trees,
+ * return True if and only if there is a node in the first tree and a node in the second tree whose values sum up to a given integer target.
+ *
+ * Example 1:
+ *        2             1
+ *       / \           / \
+ *      1  4          0  3
+ *
+ * Input: root1 = [2,1,4], root2 = [1,0,3], target = 5
+ * Output: true
+ * Explanation: 2 and 3 sum up to 5.
+ *
+ * Example 2:
+ *         0                   5
+ *        / \                 / \
+ *      -10  10              1   7
+ *                          / \
+ *                         0  2
+ *
+ * Input: root1 = [0,-10,10], root2 = [5,1,7,0,2], target = 18
+ * Output: false
+ *
+ * Constraints:
+ * Each tree has at most 5000 nodes.
+ * -10^9 <= target, node.val <= 10^9
+ * */
+public class _1214 {
+    public static class Solution1 {
+        public boolean twoSumBSTs(TreeNode root1, TreeNode root2, int target) {
+            if (root1 == null || root2 == null) {
+                return false;
+            }
+            List<Integer> inorder1 = inorderDfs(root1, new ArrayList<>());
+            List<Integer> inorder2 = inorderDfs(root2, new ArrayList<>());
+            return findTwoSum(inorder1, inorder2, target);
+        }
+
+        private boolean findTwoSum(List<Integer> sorted1, List<Integer> sorted2, int target) {
+            for (int i = 0; i < sorted1.size(); i++) {
+                if (exists(sorted2, target - sorted1.get(i))) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private boolean exists(List<Integer> sorted, int target) {
+            int left = 0;
+            int right = sorted.size() - 1;
+            while (left <= right) {
+                int mid = left + (right - left) / 2;
+                if (sorted.get(mid) == target) {
+                    return true;
+                } else if (sorted.get(mid) < target) {
+                    left = mid + 1;
+                } else {
+                    right = mid - 1;
+                }
+            }
+            return false;
+        }
+
+        private List<Integer> inorderDfs(TreeNode root, List<Integer> list) {
+            if (root == null) {
+                return list;
+            }
+            if (root.left != null) {
+                list = inorderDfs(root.left, list);
+            }
+            list.add(root.val);
+            if (root.right != null) {
+                list = inorderDfs(root.right, list);
+            }
+            return list;
+        }
+
+    }
+}

src/test/java/com/fishercoder/_1214Test.java

@@ -0,0 +1,44 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._1214;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+public class _1214Test {
+    private static _1214.Solution1 solution1;
+    private static TreeNode root1;
+    private static TreeNode root2;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _1214.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        root1 = TreeUtils.constructBinaryTree(Arrays.asList(2, 1, 4));
+        root2 = TreeUtils.constructBinaryTree(Arrays.asList(1, 0, 3));
+        assertEquals(true, solution1.twoSumBSTs(root1, root2, 5));
+    }
+
+    @Test
+    public void test2() {
+        root1 = TreeUtils.constructBinaryTree(Arrays.asList(0, -10, 10));
+        root2 = TreeUtils.constructBinaryTree(Arrays.asList(5, 1, 7, 0, 2));
+        assertEquals(false, solution1.twoSumBSTs(root1, root2, 18));
+    }
+
+    @Test
+    public void test3() {
+        root1 = TreeUtils.constructBinaryTree(Arrays.asList(0, -10, 10));
+        root2 = TreeUtils.constructBinaryTree(Arrays.asList(5, 1, 7, 0, 2));
+        assertEquals(true, solution1.twoSumBSTs(root1, root2, 17));
+    }
+
+}