Introduction

In this blog post, we will explore how to solve the LeetCode problem "623" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, 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 and two integers val and depth, add a row of nodes with value val at the given depth depth. Note that the root node is at depth 1. The adding rule is: Given the integer depth, for each not null tree node cur at the depth depth - 1, create two tree nodes with value val as cur's left subtree root and right subtree root. cur's original left subtree should be the left subtree of the new left subtree root. cur's original right subtree should be the right subtree of the new right subtree root. If depth == 1 that means there is no depth depth - 1 at all, then create a tree node with value val as the new root of the whole original tree, and the original tree is the new root's left subtree. Example 1: Input: root = [4,2,6,3,1,5], val = 1, depth = 2 Output: [4,1,1,2,null,null,6,3,1,5] Example 2: Input: root = [4,2,null,3,1], val = 1, depth = 3 Output: [4,2,null,1,1,3,null,null,1] Constraints: The number of nodes in the tree is in the range [1, 104]. The depth of the tree is in the range [1, 104]. -100 <= Node.val <= 100 -105 <= val <= 105 1 <= depth <= the depth of tree + 1

Explanation

Here's the solution to the problem, incorporating the requested elements:

High-Level Approach:

• Depth-First Search (DFS): Traverse the tree using DFS to reach the appropriate level (depth - 1).
• Insertion at Depth: At depth - 1, create new nodes with the given value and attach the original subtrees to these new nodes.

• Handle Depth 1: Treat the case where depth == 1 separately by creating a new root and making the original tree its left child.

• Runtime Complexity: O(N), where N is the number of nodes in the tree. We visit each node once. Storage Complexity: O(W), where W is the maximum width of the tree. This is due to the recursion stack in the worst-case scenario (e.g., a skewed tree).

Code

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

def addOneRow(root: TreeNode, val: int, depth: int) -> TreeNode:
    if depth == 1:
        new_root = TreeNode(val)
        new_root.left = root
        return new_root

    def dfs(node: TreeNode, current_depth: int):
        if not node:
            return

        if current_depth == depth - 1:
            # Create new nodes
            left_node = TreeNode(val)
            right_node = TreeNode(val)

            # Attach original subtrees
            left_node.left = node.left
            right_node.right = node.right

            # Update current node's children
            node.left = left_node
            node.right = right_node
            return

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

    dfs(root, 1)
    return root