feat(algorithms, arrays, two-sum): two sum input as bst

Author: BrianLusina

algorithms/arrays/two_sum/README.md

@@ -35,6 +35,74 @@ Output: [1,2]
 Explanation: The sum of -1 and 0 is -1. Therefore index1 = 1, index2 = 2. We return [1, 2].
 ```
 
+---
+
+# Two Sum IV - Input Is a BST
+
+Given the root of a binary search tree and an integer k, determine whether there are two elements in the BST whose sum 
+equals k. Return TRUE if such elements exist or FALSE otherwise.
+
+## Constraints
+
+- The number of nodes in the tree is in the range [1, 10^3].
+- 10^3 <= Node.data <= 10^3
+- root is guaranteed to be a valid binary search tree.
+- 10^4 <= k <= 10^4
+
+## Examples
+
+![Example 1](./images/examples/two_sum_4_input_is_bst_example_1.png)
+![Example 2](./images/examples/two_sum_4_input_is_bst_example_2.png)
+![Example 3](./images/examples/two_sum_4_input_is_bst_example_3.png)
+
+## Solution
+
+The core intuition behind solving this problem is to use a set to track values encountered during a breadth-first search
+of the binary search tree (BST). We calculate each node’s complement (i.e., the difference between k and the node’s value)
+and check if this complement already exists in the set. If it does, it means there is another node in the BST whose value,
+when added to the current node’s value, equals k, and we return TRUE. Otherwise, we add the current node’s value to the set.
+If no two nodes with the required sum are found by the end of the traversal, we return FALSE.
+
+Using the intuition above, the solution can be implemented as follows:
+
+1. If the BST is empty, return FALSE.
+2. Define a set, seen, to store the visited node values.
+3. Define a queue, q, to perform the level-order traversal of the BST.
+   - Enqueue root to q to start the traversal from the root node.
+4. While the queue is not empty, repeat the following steps:
+   - Dequeue a node from the front of the queue.
+   - Check if the complement of the current node’s value exists in the seen set. If yes, return TRUE.
+   - Add the current node’s value to the seen set.
+   - Enqueue its left and right children.
+5. If no two nodes with the required sum are found, return FALSE.
+
+Let’s look at the following illustration to get a better understanding of the solution:
+
+![Solution 1](./images/solutions/two_sum_4_input_is_bst_solution_1.png)
+![Solution 2](./images/solutions/two_sum_4_input_is_bst_solution_2.png)
+![Solution 3](./images/solutions/two_sum_4_input_is_bst_solution_3.png)
+![Solution 4](./images/solutions/two_sum_4_input_is_bst_solution_4.png)
+![Solution 5](./images/solutions/two_sum_4_input_is_bst_solution_5.png)
+![Solution 6](./images/solutions/two_sum_4_input_is_bst_solution_6.png)
+![Solution 7](./images/solutions/two_sum_4_input_is_bst_solution_7.png)
+![Solution 8](./images/solutions/two_sum_4_input_is_bst_solution_8.png)
+![Solution 9](./images/solutions/two_sum_4_input_is_bst_solution_9.png)
+![Solution 10](./images/solutions/two_sum_4_input_is_bst_solution_10.png)
+![Solution 11](./images/solutions/two_sum_4_input_is_bst_solution_11.png)
+![Solution 12](./images/solutions/two_sum_4_input_is_bst_solution_12.png)
+![Solution 13](./images/solutions/two_sum_4_input_is_bst_solution_13.png)
+![Solution 14](./images/solutions/two_sum_4_input_is_bst_solution_14.png)
+
+### Time Complexity
+
+The algorithm’s time complexity is O(n), where n is the number of nodes in the binary search tree.
+
+### Space Complexity
+
+The algorithm’s space complexity is O(n), as the size of the set can grow up to at most n.
+
+---
+
 ## Related Topics
 
 - Array

algorithms/arrays/two_sum/__init__.py

@@ -1,4 +1,6 @@
-from typing import List
+from typing import List, Deque, Set
+from collections import deque
+from datastructures.trees.binary.node import BinaryTreeNode
 
 
 def two_sum(numbers: List[int], target: int) -> List[int]:
@@ -59,3 +61,44 @@ def two_sum_with_pointers(numbers: List[int], target: int) -> List[int]:
             first_pointer += 1
         else:
             last_pointer -= 1
+    return []
+
+
+def two_sum_find_target(root: BinaryTreeNode, k: int) -> bool:
+    """
+    Checks if two nodes in the binary search tree add up to the given target number
+
+    Args:
+        root (BinaryTreeNode): root of the binary search tree
+        k (int): target number
+    Returns:
+        bool: True if there are two nodes in the binary search tree that add up to the target, False otherwise
+    """
+    if not root:
+        return False
+
+    # store the seen values so far during the traversal
+    seen: Set[int] = set()
+
+    # Keep track of visited nodes, we start with the root node. We use a FIFO queue here
+    queue: Deque[BinaryTreeNode] = deque()
+    queue.append(root)
+
+    while queue:
+        # dequeue the first node, the front of the queue.
+        curr = queue.popleft()
+
+        if curr:
+            # check if the complement of this node's value exists in the values we have seen so far
+            if (k - curr.data) in seen:
+                return True
+
+            # if not, add the value
+            seen.add(curr.data)
+
+            # enqueue the left and right children of the current node
+            queue.append(curr.left)
+            queue.append(curr.right)
+
+    # if we reach here, we have not found two nodes that add up to the target
+    return False