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: [6, 1, 1, 1, 1]

💡 Note: Root (genetic value 1) has subtree {1,2,3,4,5}, missing 6. Node 1 (value 3) has subtree {3,5,4}, missing 1. 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: [5, 2, 2, 1]

💡 Note: Root has subtree {2,3,1,4} = {1,2,3,4}, missing 5. Node 1 has subtree {3,1,4}, missing 2. 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

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

✓ Brute Force (Nested Tree Traversal)

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

For every node in the tree, perform a complete DFS traversal of its subtree to collect all genetic values, then iterate from 1 upward to find the first missing positive integer. This approach is straightforward but inefficient.

DFS with Smart Tracking (Optimal)

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

This optimal solution uses a key insight: if a subtree doesn't contain genetic value 1, then its smallest missing value is 1. Otherwise, we need to traverse the subtree and find the actual smallest missing value. We can optimize by tracking when subtrees need recalculation.

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>
#include <string.h>

static int children[100005][50];
static int childrenSize[100005];
static bool seen[100001];
static int stack[100005];

int* smallestMissingValueQueries(int* parents, int parentsSize, int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    
    // Initialize children sizes
    memset(childrenSize, 0, sizeof(childrenSize));
    
    // Build children adjacency list
    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++) {
        memset(seen, false, sizeof(seen));
        
        // DFS to collect values using iterative approach
        int top = 0;
        stack[top++] = i;
        
        while (top > 0) {
            int node = stack[--top];
            if (nums[node] > 0 && nums[node] <= 100000) {
                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;
    }
    
    return result;
}

int* parseArray(char* line, int* size) {
    *size = 0;
    
    // Skip opening bracket
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    // Count elements first
    char* temp = ptr;
    int count = 0;
    while (*temp && *temp != ']') {
        if (*temp == '-' || (*temp >= '0' && *temp <= '9')) {
            count++;
            while (*temp && *temp != ',' && *temp != ']') temp++;
        } else {
            temp++;
        }
    }
    
    if (count == 0) return NULL;
    
    int* arr = (int*)malloc(count * sizeof(int));
    *size = 0;
    
    // Parse numbers
    while (*ptr && *ptr != ']') {
        if (*ptr == '-' || (*ptr >= '0' && *ptr <= '9')) {
            int num = 0;
            int sign = 1;
            if (*ptr == '-') {
                sign = -1;
                ptr++;
            }
            while (*ptr >= '0' && *ptr <= '9') {
                num = num * 10 + (*ptr - '0');
                ptr++;
            }
            arr[(*size)++] = sign * num;
        } else {
            ptr++;
        }
    }
    
    return arr;
}

int main() {
    char parentsLine[500000], numsLine[500000];
    if (!fgets(parentsLine, sizeof(parentsLine), stdin)) return 1;
    if (!fgets(numsLine, sizeof(numsLine), stdin)) return 1;
    
    // Remove newlines
    parentsLine[strcspn(parentsLine, "\n")] = 0;
    numsLine[strcspn(numsLine, "\n")] = 0;
    
    int parentsSize, numsSize;
    int* parents = parseArray(parentsLine, &parentsSize);
    int* nums = parseArray(numsLine, &numsSize);
    
    if (!parents || !nums) return 1;
    
    int returnSize;
    int* result = smallestMissingValueQueries(parents, parentsSize, nums, numsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(", ");
    }
    printf("]\n");
    
    free(parents);
    free(nums);
    free(result);
    
    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

✓ Linear 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