Codestin Search App

Clone N-ary Tree - Problem

Imagine you need to create an exact duplicate of a complex organizational chart or family tree structure. That's exactly what we're doing here - creating a deep copy of an N-ary tree!

Given the root of an N-ary tree, your task is to return a complete clone of the entire tree structure. Each node in the tree contains:

An integer value (val)
A list of child nodes (children)

The clone must be completely independent - modifying the original tree should not affect the cloned tree and vice versa. Think of it as creating a photocopy of a document where changes to the original don't affect the copy.

Key Challenge: Unlike binary trees which have at most 2 children, N-ary trees can have any number of children, making the cloning process more complex as we need to handle variable-length child lists.

Input & Output

example_1.py — Basic N-ary Tree

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

› Output: Cloned tree with same structure: [1,null,3,2,4,null,5,6]

💡 Note: The tree has root with value 1 and three children (3,2,4). Node 3 has two children (5,6). The clone maintains the exact same structure but creates completely new node objects.

example_2.py — Single Node Tree

$ Input: root = [1]

› Output: Cloned single node: [1]

💡 Note: A tree with only one node (the root) is cloned to create a new node with the same value but different memory address.

example_3.py — Empty Tree

$ Input: root = null

› Output: null

💡 Note: An empty tree (null root) returns null as there's nothing to clone. This is the base case for our recursive solution.

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-1000 ≤ Node.val ≤ 1000
The depth of the n-ary tree is less than or equal to 1000
Follow up: Can you solve this problem iteratively using BFS?

Visualization

Tap to expand

Asked in

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

The optimal approach uses recursive DFS traversal with optional hash map memoization. For each node, create a new node with the same value, then recursively clone all children. The hash map prevents duplicate work and handles edge cases. Time complexity is O(n) where n is the number of nodes, and space complexity is O(h + n) for recursion depth and clone storage.

Common Approaches

✓ Brute Force Optimized

⏱️ Time: N/A Space: N/A

DFS with Memoization (Hash Map)

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

Enhance the recursive approach with memoization using a hash map. This prevents redundant cloning if the same node reference appears multiple times (though this is rare in typical tree structures, it's good practice).

Recursive DFS (Naive Approach)

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

Create a new node for each original node and recursively clone all children. This approach is straightforward but doesn't handle potential optimizations like memoization for repeated subtrees.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_N 1005
#define MAX_LOG 20

int graph[MAX_N][MAX_N];
int graphSize[MAX_N];
int parent[MAX_N][MAX_LOG];
int depth[MAX_N];
int LOG_VAL;

void dfs(int node, int par, int d) {
    parent[node][0] = par;
    depth[node] = d;
    
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (neighbor != par) {
            dfs(neighbor, node, d + 1);
        }
    }
}

int lca(int u, int v) {
    if (depth[u] < depth[v]) {
        int temp = u; u = v; v = temp;
    }
    
    // Bring u to same level as v
    int diff = depth[u] - depth[v];
    for (int i = 0; i < LOG_VAL; i++) {
        if ((diff >> i) & 1) {
            u = parent[u][i];
        }
    }
    
    if (u == v) return u;
    
    // Binary lifting
    for (int i = LOG_VAL - 1; i >= 0; i--) {
        if (parent[u][i] != parent[v][i]) {
            u = parent[u][i];
            v = parent[v][i];
        }
    }
    
    return parent[u][0];
}

int distance(int u, int v) {
    return depth[u] + depth[v] - 2 * depth[lca(u, v)];
}

int getPath(int start, int end, int* path) {
    int lcaNode = lca(start, end);
    int pathSize = 0;
    
    // Path from start to lca
    int curr = start;
    while (curr != lcaNode) {
        path[pathSize++] = curr;
        curr = parent[curr][0];
    }
    path[pathSize++] = lcaNode;
    
    // Path from lca to end (collect in temp array)
    int temp[MAX_N];
    int tempSize = 0;
    curr = end;
    while (curr != lcaNode) {
        temp[tempSize++] = curr;
        curr = parent[curr][0];
    }
    
    // Add temp in reverse order
    for (int i = tempSize - 1; i >= 0; i--) {
        path[pathSize++] = temp[i];
    }
    
    return pathSize;
}

int* closestNode(int n, int** edges, int edgesSize, int** queries, int queriesSize, int* returnSize) {
    // Initialize
    LOG_VAL = 0;
    int temp = n;
    while (temp > 0) {
        LOG_VAL++;
        temp >>= 1;
    }
    
    for (int i = 0; i < n; i++) {
        graphSize[i] = 0;
        for (int j = 0; j < LOG_VAL; j++) {
            parent[i][j] = -1;
        }
    }
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    // Root the tree at node 0
    dfs(0, -1, 0);
    
    // Fill parent table for binary lifting
    for (int j = 1; j < LOG_VAL; j++) {
        for (int i = 0; i < n; i++) {
            if (parent[i][j-1] != -1) {
                parent[i][j] = parent[parent[i][j-1]][j-1];
            }
        }
    }
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int start = queries[i][0];
        int end = queries[i][1];
        int target = queries[i][2];
        
        int path[MAX_N];
        int pathSize = getPath(start, end, path);
        
        int minDist = INT_MAX;
        int closest = path[0];
        
        for (int j = 0; j < pathSize; j++) {
            int dist = distance(path[j], target);
            if (dist < minDist) {
                minDist = dist;
                closest = path[j];
            }
        }
        
        result[i] = closest;
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

58.0K Views

Medium Frequency

~15 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