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

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

✓ Brute Force (Path Collection)

⏱️ Time: O(n * m) Space: O(n * m)

For each target node, find the complete path from root to that node. Then compare all paths to find the deepest node that appears in every path. This approach requires multiple tree traversals and path storage.

One-Pass Optimal Solution

⏱️ Time: O(n) Space: O(m + h)

The optimal approach uses a single post-order traversal with a hash set for O(1) target lookup. As we traverse bottom-up, each node reports what target nodes exist in its subtree. The moment a node finds all targets in its combined subtrees, it's the LCA.

Two-Pass with Hash Set

⏱️ Time: O(n) Space: O(m + h)

Convert the array of target nodes into a hash set for O(1) lookup. Then perform a post-order traversal where each node reports how many target nodes exist in its subtree. The first node that contains all target nodes is the LCA.

Brute Force (Path Collection) — Algorithm Steps

Find the path from root to each target node
Store all paths in a list of arrays
Compare paths element by element to find common prefix
Return the last common node in all paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Paths

Traverse from root to each target node, recording the complete path

Compare Paths

Compare all paths element by element from root downward

Find LCA

The last common node in all paths is the LCA

Code -

solution.c — C

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

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

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* buildTree(char* str) {
    if (!str || strlen(str) == 0) return NULL;
    
    char* token = strtok(str, ",");
    if (!token || strcmp(token, "null") == 0 || strlen(token) == 0) return NULL;
    
    struct TreeNode* root = createNode(atoi(token));
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        
        token = strtok(NULL, ",");
        if (token && strcmp(token, "null") != 0 && strlen(token) > 0) {
            node->left = createNode(atoi(token));
            queue[rear++] = node->left;
        }
        
        token = strtok(NULL, ",");
        if (token && strcmp(token, "null") != 0 && strlen(token) > 0) {
            node->right = createNode(atoi(token));
            queue[rear++] = node->right;
        }
    }
    
    return root;
}

struct TreeNode* findNode(struct TreeNode* root, int val) {
    if (!root) return NULL;
    if (root->val == val) return root;
    struct TreeNode* left = findNode(root->left, val);
    if (left) return left;
    return findNode(root->right, val);
}

bool findPath(struct TreeNode* root, struct TreeNode* target, struct TreeNode** path, int* pathLen) {
    if (!root) return false;
    
    path[*pathLen] = root;
    (*pathLen)++;
    
    if (root == target) return true;
    
    if (findPath(root->left, target, path, pathLen) || 
        findPath(root->right, target, path, pathLen)) {
        return true;
    }
    
    (*pathLen)--;
    return false;
}

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, int* nodeVals, int nodesSize) {
    static struct TreeNode* paths[10000][1000];
    static int pathLengths[10000];
    
    // Find actual nodes from values and their paths
    int validPaths = 0;
    for (int i = 0; i < nodesSize; i++) {
        struct TreeNode* node = findNode(root, nodeVals[i]);
        if (node) {
            pathLengths[validPaths] = 0;
            findPath(root, node, paths[validPaths], &pathLengths[validPaths]);
            validPaths++;
        }
    }
    
    if (validPaths == 0) return NULL;
    
    struct TreeNode* lca = paths[0][0];
    int minLength = pathLengths[0];
    for (int i = 1; i < validPaths; i++) {
        if (pathLengths[i] < minLength) {
            minLength = pathLengths[i];
        }
    }
    
    for (int i = 0; i < minLength; i++) {
        struct TreeNode* currentNode = paths[0][i];
        bool allMatch = true;
        for (int j = 0; j < validPaths; j++) {
            if (paths[j][i] != currentNode) {
                allMatch = false;
                break;
            }
        }
        if (allMatch) {
            lca = currentNode;
        } else {
            break;
        }
    }
    
    return lca;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char treeStr[10000], nodesStr[10000];
    
    // Read input
    fgets(treeStr, sizeof(treeStr), stdin);
    fgets(nodesStr, sizeof(nodesStr), stdin);
    
    // Remove newlines
    treeStr[strcspn(treeStr, "\n")] = 0;
    nodesStr[strcspn(nodesStr, "\n")] = 0;
    
    // Build tree
    struct TreeNode* root = buildTree(treeStr);
    
    // Parse node values
    int nodeVals[10000];
    int nodesSize = 0;
    char* token = strtok(nodesStr, ",");
    while (token) {
        nodeVals[nodesSize++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    struct TreeNode* result = lowestCommonAncestor(root, nodeVals, nodesSize);
    printf("%d\n", result->val);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

n is tree size, m is number of target nodes. We traverse the tree m times to find each path

✓ Linear Growth

Space Complexity

O(n * m)

We store m paths, each potentially of length n (tree height)

⚡ Linearithmic 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

Lowest Common Ancestor of a Binary Tree IV - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Path Collection) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler