Maximum Genetic Difference Query

Maximum Genetic Difference Query - Problem

There is a rooted tree consisting of n nodes numbered 0 to n - 1. Each node's number denotes its unique genetic value (i.e., the genetic value of node x is x). The genetic difference between two genetic values is defined as the bitwise-XOR of their values.

You are given the integer array parents, where parents[i] is the parent for node i. If node x is the root of the tree, then parents[x] == -1.

You are also given the array queries where queries[i] = [nodei, vali]. For each query i, find the maximum genetic difference between vali and pi, where pi is the genetic value of any node that is on the path between nodei and the root (including nodei and the root). More formally, you want to maximize vali XOR pi.

Return an array ans where ans[i] is the answer to the ith query.

Input & Output

Example 1 — Basic Tree Queries

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

› Output: [7,7]

💡 Note: Tree: 0 is root, 1 and 2 are children of 0, 3 is child of 2. Query [3,4]: ancestors of 3 are [3,2,0], max XOR is 4⊕3=7. Query [2,5]: ancestors of 2 are [2,0], XOR values are 5⊕2=7 and 5⊕0=5, so max XOR is 7.

Example 2 — Single Node Tree

$ Input: parents = [-1], queries = [[0,1]]

› Output: [1]

💡 Note: Only node 0 exists as root. Query [0,1]: only ancestor is node 0, so XOR is 1⊕0=1.

Example 3 — Linear Tree Path

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

› Output: [3]

💡 Note: Linear tree: 0→1→2. Query [2,3]: ancestors are [2,1,0], XOR values are 3⊕2=1, 3⊕1=2, 3⊕0=3, so maximum is 3.

Constraints

n == parents.length
2 ≤ n ≤ 10⁵
0 ≤ parents[i] ≤ n - 1 for i ≠ root
parents[root] == -1
1 ≤ queries.length ≤ 3 × 10⁴
0 ≤ node_i ≤ n - 1
0 ≤ val_i ≤ 2 × 10⁵

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 A Apple 12

The key insight is to use a trie data structure during DFS traversal to efficiently find maximum XOR values. The optimal approach uses DFS with trie to achieve O(N + Q × log(MAX_VAL)) time complexity. Time: O(N + Q × log V), Space: O(N × log V)

Common Approaches

✓ Greedy

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

Brute Force with Path Finding

⏱️ Time: O(Q × N) Space: O(N)

Build the tree from parents array, then for each query traverse from the query node to root collecting all genetic values, and compute maximum XOR with the query value.

DFS with Trie Optimization

⏱️ Time: O(N + Q × log(MAX_VAL)) Space: O(N × log(MAX_VAL))

Perform DFS on the tree while maintaining a trie of ancestors. For each query at current node, use trie to find maximum XOR in O(log max_value) time instead of checking all ancestors.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* enemyEnergies, int n, int currentEnergy) {
    if (n == 0) {
        return 0;
    }
    
    int minEnergy = enemyEnergies[0];
    long long totalEnergy = 0;
    
    for (int i = 0; i < n; i++) {
        if (enemyEnergies[i] < minEnergy) {
            minEnergy = enemyEnergies[i];
        }
        totalEnergy += enemyEnergies[i];
    }
    
    // If we can't defeat even the weakest enemy, return 0
    if (currentEnergy < minEnergy) {
        return 0;
    }
    
    // Defeat the weakest enemy once to get our first point
    int points = 1;
    long long energy = currentEnergy - minEnergy;
    
    // Absorb all other enemies to maximize energy
    long long totalOtherEnergy = totalEnergy - minEnergy;
    energy += totalOtherEnergy;
    
    // Keep defeating the weakest enemy with remaining energy
    if (minEnergy > 0) {
        points += (int)(energy / minEnergy);
    }
    
    return points;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array - handle format [1,2,3]
    int enemyEnergies[1000];
    int n = 0;
    
    // Remove newline if present
    line[strcspn(line, "\n")] = 0;
    
    // Skip the opening bracket
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    // Parse numbers
    char* token = strtok(ptr, ",]");
    while (token != NULL && n < 1000) {
        enemyEnergies[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int currentEnergy;
    scanf("%d", &currentEnergy);
    
    printf("%d\n", solution(enemyEnergies, n, currentEnergy));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~35 min Avg. Time

485 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