Smallest Missing Genetic Value in Each Subtree

Smallest Missing Genetic Value in Each Subtree - Problem

You are a geneticist studying a family tree represented as a tree data structure. The tree consists of n individuals numbered 0 to n - 1, where person 0 is the common ancestor (root).

Each person in the family carries a unique genetic marker - an integer value between 1 and 10⁵. Your task is to analyze each person's "genetic lineage" (their subtree) and find the smallest positive genetic value that doesn't exist in their family line.

Input:

parents: Array where parents[i] is the parent of person i (with parents[0] = -1 for root)
nums: Array where nums[i] is the genetic value of person i

Goal: Return an array where each element represents the smallest missing genetic value in that person's subtree (including themselves and all descendants).

A subtree rooted at node x contains node x and all nodes that can be reached by following parent-child relationships downward from x.

Input & Output

example_1.py — Basic Family Tree

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

› Output: [2, 6, 1, 1, 1]

💡 Note: Root (genetic value 1) has subtree {1,3,2,5,4}, missing 2. Node 1 (value 3) has subtree {3,5,4}, missing 6. Leaves have subtree containing only themselves, so missing value is 1 unless they have genetic value 1.

example_2.py — Linear Family Tree

$ Input: parents = [-1, 0, 1, 2], nums = [2, 3, 1, 4]

› Output: [1, 1, 2, 1]

💡 Note: Root has value 2, doesn't contain 1 in its subtree, so answer is 1. Node 1 has value 3, also missing 1. Node 2 has subtree {1,4}, missing 2. Leaf node 3 has only value 4, missing 1.

example_3.py — Single Node

$ Input: parents = [-1], nums = [1]

› Output: [2]

💡 Note: Single node with genetic value 1. The subtree contains {1}, so the smallest missing positive value is 2.

Constraints

n == parents.length == nums.length
1 ≤ n ≤ 10⁵
parents[0] == -1
For i ≠ 0, 0 ≤ parents[i] ≤ n - 1
parents represents a valid tree
1 ≤ nums[i] ≤ 10⁵
All values in nums are distinct

Visualization

Tap to expand

Understanding the Visualization

Build Family Tree

Create tree structure from parent-child relationships

Start DFS from Root

Begin depth-first traversal from the family patriarch/matriarch

Track Genetic Values

Maintain set of genetic markers found in current lineage

Find Missing Marker

For each person, identify smallest missing genetic value in their lineage

Backtrack Efficiently

Remove current genetic value when moving back up the family tree

Key Takeaway

🎯 Key Insight: Use DFS to efficiently track genetic values in each lineage, finding missing markers in O(n) time by leveraging the tree structure and smart backtracking.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses DFS with smart genetic value tracking. Key insight: traverse the tree once using DFS while maintaining a set of genetic values in the current path. For each node, add its value to the set, recursively process children, find the smallest missing positive integer, then backtrack by removing the value. This achieves O(n) average time complexity with O(n) space for the recursion stack and value tracking.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Tree Traversal)	O(n²)	O(n)	For each node, traverse entire subtree to collect values and find smallest missing
DFS with Smart Tracking (Optimal)	O(n)	O(n)	Use DFS to track genetic values and inherit missing values from parent when possible

Brute Force (Nested Tree Traversal) — Algorithm Steps

Build adjacency list representation of the tree from parents array
For each node i, perform DFS to collect all genetic values in subtree rooted at i
For each collected set, find smallest missing positive by checking 1, 2, 3, ... until gap found
Store result for node i and continue to next node

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at root

Begin DFS traversal from root to collect all genetic values

Collect values

Gather all genetic values in the subtree into a set

Find missing

Check 1, 2, 3, ... until finding first missing value

Repeat

Repeat entire process for each node in the tree

Code -

solution.c — C

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

int* smallestMissingValueQueries(int* parents, int parentsSize, int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    
    // Build children adjacency list
    int** children = (int**)malloc(numsSize * sizeof(int*));
    int* childrenSize = (int*)calloc(numsSize, sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        children[i] = (int*)malloc(numsSize * sizeof(int));
    }
    
    for (int i = 1; i < numsSize; i++) {
        children[parents[i]][childrenSize[parents[i]]++] = i;
    }
    
    // For each node, collect subtree values and find missing
    for (int i = 0; i < numsSize; i++) {
        bool* seen = (bool*)calloc(100001, sizeof(bool));
        
        // DFS to collect values (simplified iterative approach)
        int stack[numsSize];
        int top = 0;
        stack[top++] = i;
        
        while (top > 0) {
            int node = stack[--top];
            seen[nums[node]] = true;
            for (int j = 0; j < childrenSize[node]; j++) {
                stack[top++] = children[node][j];
            }
        }
        
        // Find smallest missing
        int missing = 1;
        while (missing <= 100000 && seen[missing]) {
            missing++;
        }
        result[i] = missing;
        
        free(seen);
    }
    
    // Cleanup
    for (int i = 0; i < numsSize; i++) {
        free(children[i]);
    }
    free(children);
    free(childrenSize);
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we traverse its subtree which can be O(n) in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack and temporary sets to store genetic values for each subtree

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force (Nested Tree Traversal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler