Tree of Coprimes - Practice Coding Problems

Tree of Coprimes - Problem

Array Math Tree Depth-First Search Number Theory Hard

Imagine you're exploring a family tree where each person has a special numerical value, and you need to find their closest compatible ancestor!

Given a tree with n nodes numbered from 0 to n-1, where node 0 is the root, each node has an associated value. Two values are coprime if their greatest common divisor (GCD) equals 1 - meaning they share no common factors except 1.

Your task: For each node, find its closest ancestor (on the path to root) whose value is coprime with the current node's value. If no such ancestor exists, return -1 for that node.

Input: An array nums where nums[i] is the value of node i, and a 2D array edges representing tree connections.

Output: An array where result[i] is the closest coprime ancestor of node i, or -1 if none exists.

Input & Output

example_1.py — Basic Tree Example

$ Input: nums = [2,3,5,4], edges = [[0,1],[1,2],[1,3]]

› Output: [-1,0,0,1]

💡 Note: Node 0 (root) has no ancestors. Node 1 (val=3): ancestor 0 (val=2), gcd(3,2)=1 ✓. Node 2 (val=5): ancestor 0 (val=2), gcd(5,2)=1 ✓. Node 3 (val=4): ancestors are 1(val=3) and 0(val=2). gcd(4,3)=1, so closest coprime ancestor is node 1.

example_2.py — No Coprime Ancestors

$ Input: nums = [4,8,12], edges = [[0,1],[0,2]]

› Output: [-1,-1,-1]

💡 Note: Root has no ancestors. Node 1 (val=8): ancestor 0 (val=4), gcd(8,4)=4≠1. Node 2 (val=12): ancestor 0 (val=4), gcd(12,4)=4≠1. No coprime ancestors exist for nodes 1 and 2.

example_3.py — Deep Tree Chain

$ Input: nums = [5,6,10,2,3,6,15], edges = [[0,1],[1,2],[0,3],[3,4],[3,5],[0,6]]

› Output: [-1,0,-1,0,3,3,0]

💡 Note: Complex tree where some nodes have multiple potential coprime ancestors, and we need the closest one. Node 4 (val=3) finds ancestor 3 (val=2) as gcd(3,2)=1, which is closer than root 0 (val=5).

Constraints

nums.length == n
1 ≤ n ≤ 10⁵
1 ≤ nums[i] ≤ 50
edges.length == n - 1
edges[i].length == 2
0 ≤ a_i, b_i < n
a_i ≠ b_i
The given edges form a valid tree

Visualization

Tap to expand

Understanding the Visualization

Build the Family Tree

Create connections between family members and establish parent-child relationships

Precompute Compatibility

Create a lookup table showing which numbers are coprime (share no factors except 1)

DFS Family Traversal

Visit each family member, tracking ancestors by their lucky numbers

Find Compatible Mentor

For each person, check their coprime numbers against tracked ancestors to find the closest match

Key Takeaway

🎯 Key Insight: By precomputing coprime relationships and tracking ancestors by value during DFS, we can efficiently find the closest compatible ancestor for each node in O(n×k) time.

Asked in

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

The optimal solution uses DFS traversal with ancestor value tracking. Key insight: since values are limited to 1-50, we can precompute coprime relationships and track the deepest ancestor for each value during traversal. This achieves O(n × k) time complexity where k ≤ 50, making it efficient for large trees.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized DFS with Ancestor Tracking	O(n * k)	O(n + k²)	Single DFS traversal tracking ancestors by value for efficient coprime lookup

Optimized DFS with Ancestor Tracking — Algorithm Steps

Precompute coprime relationships for all values 1-50
Build adjacency list from edges
DFS from root, maintaining ancestor_depth arrays indexed by value
For each node, check coprime values to find closest ancestor
Update ancestor tracking when entering/leaving each node

Visualization

Tap to expand

Step-by-Step Walkthrough

Precompute Coprimes

Build lookup table for all coprime pairs (1-50)

DFS with Tracking

Track deepest ancestor for each value as we traverse

Quick Lookup

For each node, check coprime values for closest ancestor

Code -

solution.c — C

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

#define MAX_VAL 50

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

typedef struct {
    int* data;
    int size;
    int capacity;
} IntList;

IntList* createIntList() {
    IntList* list = (IntList*)malloc(sizeof(IntList));
    list->capacity = 10;
    list->data = (int*)malloc(list->capacity * sizeof(int));
    list->size = 0;
    return list;
}

void addToList(IntList* list, int val) {
    if (list->size == list->capacity) {
        list->capacity *= 2;
        list->data = (int*)realloc(list->data, list->capacity * sizeof(int));
    }
    list->data[list->size++] = val;
}

int** graph;
int* graphSize;
IntList* coprimes[MAX_VAL + 1];
int* result;
int ancestorDepth[MAX_VAL + 1][2];

void dfs(int* nums, int node, int parent, int depth) {
    // Find closest coprime ancestor
    int bestAncestor = -1;
    int bestDepth = -1;
    
    for (int i = 0; i < coprimes[nums[node]]->size; i++) {
        int coprimeVal = coprimes[nums[node]]->data[i];
        if (ancestorDepth[coprimeVal][0] != -1) {
            if (ancestorDepth[coprimeVal][1] > bestDepth) {
                bestDepth = ancestorDepth[coprimeVal][1];
                bestAncestor = ancestorDepth[coprimeVal][0];
            }
        }
    }
    
    result[node] = bestAncestor;
    
    // Save current state
    int oldNode = ancestorDepth[nums[node]][0];
    int oldDepth = ancestorDepth[nums[node]][1];
    ancestorDepth[nums[node]][0] = node;
    ancestorDepth[nums[node]][1] = depth;
    
    // Visit children
    for (int i = 0; i < graphSize[node]; i++) {
        int child = graph[node][i];
        if (child != parent) {
            dfs(nums, child, node, depth + 1);
        }
    }
    
    // Restore state
    ancestorDepth[nums[node]][0] = oldNode;
    ancestorDepth[nums[node]][1] = oldDepth;
}

int* getCoprimeAncestor(int* nums, int numsSize, int** edges, int edgesSize, int* returnSize) {
    *returnSize = numsSize;
    if (numsSize == 1) {
        int* res = (int*)malloc(sizeof(int));
        res[0] = -1;
        return res;
    }
    
    // Precompute coprime relationships
    for (int i = 0; i <= MAX_VAL; i++) {
        coprimes[i] = createIntList();
    }
    
    for (int i = 1; i <= MAX_VAL; i++) {
        for (int j = 1; j <= MAX_VAL; j++) {
            if (gcd(i, j) == 1) {
                addToList(coprimes[i], j);
            }
        }
    }
    
    // Build adjacency list
    graph = (int**)malloc(numsSize * sizeof(int*));
    graphSize = (int*)calloc(numsSize, sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        graph[i] = (int*)malloc(numsSize * sizeof(int));
    }
    
    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;
    }
    
    result = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        result[i] = -1;
    }
    
    // Initialize ancestor depth tracking
    for (int i = 0; i <= MAX_VAL; i++) {
        ancestorDepth[i][0] = -1;
        ancestorDepth[i][1] = -1;
    }
    
    dfs(nums, 0, -1, 0);
    
    // Cleanup (in real implementation)
    return result;
}

int main() {
    // Input parsing would be implemented here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

O(n) for DFS traversal, with O(k) coprime checks per node where k ≤ 50 (max value)

✓ Linear Growth

Space Complexity

O(n + k²)

O(n) for recursion stack and result, O(k²) for coprime relationships and ancestor tracking

⚡ Linearithmic Space

24.7K Views

Medium Frequency

~25 min Avg. Time

847 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

Optimized DFS with Ancestor Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler