# Solving Leetcode Interviews in Seconds with AI: Deepest Leaves Sum


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1302" 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 of a binary tree, return the sum of values of its deepest leaves.   Example 1:   Input: root = [1,2,3,4,5,null,6,7,null,null,null,null,8] Output: 15  Example 2:  Input: root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5] Output: 19    Constraints:  The number of nodes in the tree is in the range [1, 104]. 1 <= Node.val <= 100  

	# Explanation
	Here's a solution to find the sum of deepest leaves in a binary tree, incorporating efficiency and optimization:

*   **Depth-First Search (DFS):** Traverse the tree using DFS to determine the maximum depth.
*   **Conditional Summation:** During the DFS, maintain the sum of node values only for nodes at the maximum depth found. Reset the sum if a deeper level is encountered.
*   **Avoid Redundant Calculations:** The single DFS ensures each node is visited only once, preventing redundant depth calculations or summations.

*   **Runtime Complexity: O(N), Storage Complexity: O(H),** where N is the number of nodes in the tree and H is the height of the tree (due to the call stack in DFS). In the worst-case (skewed tree), H can be N.

	
	# Code
	```python
	class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def deepestLeavesSum(root: TreeNode) -> int:
    max_depth = 0
    deepest_sum = 0

    def dfs(node, depth):
        nonlocal max_depth, deepest_sum

        if not node:
            return

        if depth > max_depth:
            max_depth = depth
            deepest_sum = node.val
        elif depth == max_depth:
            deepest_sum += node.val

        dfs(node.left, depth + 1)
        dfs(node.right, depth + 1)

    dfs(root, 0)
    return deepest_sum
	```