# Solving Leetcode Interviews in Seconds with AI: Range Sum of BST


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "938" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> Given the root node of a binary search tree and two integers low and high, return the sum of values of all nodes with a value in the inclusive range [low, high].   Example 1:   Input: root = [10,5,15,3,7,null,18], low = 7, high = 15 Output: 32 Explanation: Nodes 7, 10, and 15 are in the range [7, 15]. 7 + 10 + 15 = 32.  Example 2:   Input: root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10 Output: 23 Explanation: Nodes 6, 7, and 10 are in the range [6, 10]. 6 + 7 + 10 = 23.    Constraints:  The number of nodes in the tree is in the range [1, 2 * 104]. 1 <= Node.val <= 105 1 <= low <= high <= 105 All Node.val are unique.  

	# Explanation
	Here's the breakdown:

*   **Leverage BST Properties:** Exploit the inherent ordering of a Binary Search Tree (BST). This allows us to selectively explore branches, significantly reducing the search space. If the current node's value is less than `low`, we only need to explore the right subtree. If the current node's value is greater than `high`, we only need to explore the left subtree.
*   **Recursive Traversal:** Implement a recursive function to traverse the tree. The function checks if the current node's value falls within the range `[low, high]`. If it does, the value is added to the running sum.
*   **Pruning the Search Space:** Conditionally traverse the left and right subtrees based on the current node's value relative to `low` and `high`. This pruning step is crucial for efficiency.

*   **Time & Space Complexity:** O(N) in the worst case (skewed tree), but can be closer to O(log N) for balanced trees. Space complexity is O(H) due to the recursion stack, where H is the height of the tree.

	
	# Code
	```python
	# Definition for a binary tree node.
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def rangeSumBST(self, root: TreeNode, low: int, high: int) -> int:
        """
        Calculates the sum of values of nodes within the inclusive range [low, high] in a BST.
        """
        total_sum = 0

        def dfs(node):
            nonlocal total_sum  # Allows modification of the outer scope variable

            if not node:
                return

            if low <= node.val <= high:
                total_sum += node.val

            if node.val > low:
                dfs(node.left)  # Explore left subtree if node value is greater than low

            if node.val < high:
                dfs(node.right) # Explore right subtree if node value is less than high

        dfs(root)
        return total_sum
	```