Lowest Common Ancestor of a Binary Tree IV

Lowest Common Ancestor of a Binary Tree IV - Problem

Lowest Common Ancestor of Multiple Nodes

You're given the root of a binary tree and an array of TreeNode objects called nodes. Your mission is to find the lowest common ancestor (LCA) of all the nodes in the array.

Think of it as finding the "meeting point" in a family tree - the closest common ancestor that connects all the specified family members. Unlike the classic LCA problem that deals with just two nodes, this version challenges you to handle multiple nodes simultaneously.

Key Points:
• All nodes in the array are guaranteed to exist in the tree
• All node values are unique
• A node can be considered its own descendant
• The LCA is the deepest node that has all target nodes as descendants

Goal: Return the TreeNode representing the lowest common ancestor of all nodes in the input array.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: The LCA of nodes 4, 7, and 2 is node 2. Node 2 is the deepest node that has all three target nodes as descendants (4 and 7 are in its subtree, and 2 is itself).

example_2.py — Root as LCA

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

› Output: 3

💡 Note: Node 6 is in the left subtree of 3, while nodes 1 and 8 are in the right subtree of 3. The only common ancestor that contains all three nodes is the root node 3.

example_3.py — Single Node

$ Input: root = [1,2], nodes = [2]

› Output: 2

💡 Note: When there's only one target node, the LCA is the node itself. Node 2 is its own lowest common ancestor.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁹ ≤ Node.val ≤ 10⁹
All Node.val are unique
All nodes[i] will exist in the tree
All nodes[i] are unique
1 ≤ nodes.length ≤ 10⁴

Visualization

Tap to expand

Understanding the Visualization

Identify Family Members

Create a list of all family members who want to attend the reunion (target nodes)

Trace Family Lines

Starting from the youngest generation, trace upward through the family tree

Find Meeting Point

The first ancestor whose house can accommodate all family members is the optimal meeting location

Confirm Accessibility

Verify that all target family members can trace their lineage to this ancestor

Key Takeaway

🎯 Key Insight: The LCA is like finding the perfect family reunion location - the closest common ancestor that all target family members can reach, representing the optimal meeting point in the tree hierarchy.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a single post-order traversal with a hash set for O(1) target lookup. During the bottom-up traversal, each node reports which target nodes exist in its subtree. The first node that contains all targets is immediately identified as the LCA, achieving O(n) time complexity with early termination.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Optimal Solution	O(n)	O(m + h)	Single post-order traversal with immediate LCA detection
Two-Pass with Hash Set	O(n)	O(m + h)	First pass to mark all target nodes, second pass to find LCA
Brute Force (Path Collection)	O(n * m)	O(n * m)	Find path from root to each target node, then find the deepest common node

One-Pass Optimal Solution — Algorithm Steps

Create hash set from target nodes array for O(1) lookup
Perform post-order DFS traversal
Each node collects target nodes from left and right subtrees
First node containing all targets is the LCA - return immediately

Visualization

Tap to expand

Step-by-Step Walkthrough

Post-Order Start

Begin from leaves, moving upward collecting target nodes

Target Collection

Each node reports which targets exist in its subtree

LCA Detection

First node with all targets is immediately identified as LCA

Code -

solution.c — C

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

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

struct TreeNode* lca_result;
struct TreeNode** target_nodes;
int target_count;

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

int dfs(struct TreeNode* node, struct TreeNode** found, int* found_count) {
    if (!node) {
        *found_count = 0;
        return 0;
    }
    
    struct TreeNode* left_found[1000];
    struct TreeNode* right_found[1000];
    int left_count = 0, right_count = 0;
    
    dfs(node->left, left_found, &left_count);
    dfs(node->right, right_found, &right_count);
    
    *found_count = 0;
    
    // Add targets from left subtree
    for (int i = 0; i < left_count; i++) {
        found[(*found_count)++] = left_found[i];
    }
    
    // Add targets from right subtree
    for (int i = 0; i < right_count; i++) {
        bool already_added = false;
        for (int j = 0; j < *found_count; j++) {
            if (found[j] == right_found[i]) {
                already_added = true;
                break;
            }
        }
        if (!already_added) {
            found[(*found_count)++] = right_found[i];
        }
    }
    
    // Add current node if it's a target
    if (isTarget(node)) {
        found[(*found_count)++] = node;
    }
    
    // Check if we found all targets
    if (*found_count == target_count && lca_result == NULL) {
        lca_result = node;
    }
    
    return *found_count;
}

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode** nodes, int nodesSize) {
    target_nodes = nodes;
    target_count = nodesSize;
    lca_result = NULL;
    
    struct TreeNode* found[1000];
    int found_count;
    dfs(root, found, &found_count);
    
    return lca_result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal of the tree where n is the number of nodes. Each node is visited exactly once.

✓ Linear Growth

Space Complexity

O(m + h)

Hash set stores m target nodes, recursion stack has depth h (tree height)

✓ Linear Space

52.3K Views

High Frequency

~18 min Avg. Time

1.5K 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

One-Pass Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler