Smallest Subtree with all the Deepest Nodes

Smallest Subtree with all the Deepest Nodes - Problem

Given the root of a binary tree, your task is to find the smallest subtree that contains all the deepest nodes in the tree.

The depth of a node is defined as the shortest distance from the root to that node. The deepest nodes are those nodes that have the maximum depth among all nodes in the tree.

A subtree of a node consists of that node and all its descendants. You need to return the root of the smallest such subtree.

Example: If the deepest nodes are leaves at depth 3, and they have different parents, you need to find their lowest common ancestor that forms the smallest subtree containing all of them.

Input & Output

example_1.py — Python

$ Input: root = [3,5,1,6,2,0,8,null,null,7,4]

› Output: [2,7,4]

💡 Note: The deepest nodes are 7 and 4 at depth 3. The smallest subtree containing both is rooted at node 2.

example_2.py — Python

$ Input: root = [1]

› Output: [1]

💡 Note: The tree has only one node, so it's both the deepest and the answer.

example_3.py — Python

$ Input: root = [0,1,3,null,2]

› Output: [2]

💡 Note: The deepest node is 2 at depth 2. The smallest subtree containing it is just node 2 itself.

Constraints

The number of nodes in the tree will be in the range [1, 500]
-500 ≤ Node.val ≤ 500
The values of the nodes in the tree are unique

Visualization

Tap to expand

Understanding the Visualization

Identify Deepest Level

Find all nodes at the maximum depth - these are like the youngest generation in a family

Find Common Ancestor

The answer is the lowest common ancestor of all deepest nodes - the closest family connection

Single Pass Solution

Instead of multiple passes, calculate depths and find LCA simultaneously using post-order traversal

Key Takeaway

🎯 Key Insight: The problem reduces to finding the LCA of all deepest nodes, which can be solved optimally in O(n) time with a single DFS that compares subtree depths.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses a single DFS traversal that simultaneously calculates subtree depths and identifies the answer node. The key insight is that the smallest subtree containing all deepest nodes is always the lowest common ancestor (LCA) of those nodes. By comparing left and right subtree depths at each node, we can determine if the current node is the LCA (equal depths) or if we need to recurse deeper.

Common Approaches

Approach	Time	Space	Notes
✓ Multiple DFS Traversals	O(n)	O(h + d)	Find max depth, collect deepest nodes, then find their LCA
Two-Pass DFS with Depth Mapping	O(n)	O(n)	First pass maps node depths, second pass finds the answer using depth information
One-Pass DFS (Optimal)	O(n)	O(h)	Calculate depth and find answer simultaneously in single DFS traversal

Multiple DFS Traversals — Algorithm Steps

First DFS: Find the maximum depth in the tree
Second DFS: Collect all nodes that are at the maximum depth
Third DFS: Find the lowest common ancestor of all deepest nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Maximum Depth

First DFS traversal calculates the maximum depth of the tree

Collect Deepest Nodes

Second DFS traversal identifies all nodes at the maximum depth

Find LCA

Third DFS traversal finds the lowest common ancestor of all deepest nodes

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int findMaxDepth(struct TreeNode* node) {
    if (!node) return 0;
    int leftDepth = findMaxDepth(node->left);
    int rightDepth = findMaxDepth(node->right);
    return 1 + (leftDepth > rightDepth ? leftDepth : rightDepth);
}

void collectDeepest(struct TreeNode* node, int depth, int maxDepth, 
                   struct TreeNode** result, int* count) {
    if (!node) return;
    if (depth == maxDepth) {
        result[(*count)++] = node;
    }
    collectDeepest(node->left, depth + 1, maxDepth, result, count);
    collectDeepest(node->right, depth + 1, maxDepth, result, count);
}

bool isTarget(struct TreeNode* node, struct TreeNode** targets, int count) {
    for (int i = 0; i < count; i++) {
        if (targets[i] == node) return true;
    }
    return false;
}

struct TreeNode* findLCA(struct TreeNode* node, struct TreeNode** targets, int count) {
    if (!node || isTarget(node, targets, count)) return node;
    
    struct TreeNode* left = findLCA(node->left, targets, count);
    struct TreeNode* right = findLCA(node->right, targets, count);
    
    if (left && right) return node;
    return left ? left : right;
}

struct TreeNode* subtreeWithAllDeepest(struct TreeNode* root) {
    if (!root) return NULL;
    
    int maxDepth = findMaxDepth(root);
    
    struct TreeNode* deepestNodes[1000]; // Assuming max 1000 nodes
    int count = 0;
    collectDeepest(root, 1, maxDepth, deepestNodes, &count);
    
    return findLCA(root, deepestNodes, count);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three separate DFS traversals, each O(n), but still linear overall

✓ Linear Growth

Space Complexity

O(h + d)

O(h) for recursion stack plus O(d) for storing deepest nodes, where d is number of deepest nodes

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Multiple DFS Traversals — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler