Kth Smallest Path XOR Sum

Kth Smallest Path XOR Sum - Problem

Imagine you're exploring a magical tree where each node holds a special value, and traveling from the root to any node creates a unique XOR signature by combining all values along the path!

You are given an undirected tree rooted at node 0 with n nodes numbered from 0 to n - 1. Each node i has an integer value vals[i], and its parent is given by par[i].

The path XOR sum from the root to a node u is defined as the bitwise XOR of all vals[i] for nodes i on the path from the root node to node u, inclusive.

You are given a 2D integer array queries, where queries[j] = [u_j, k_j]. For each query, you need to:

Find all nodes in the subtree rooted at u_j
Calculate the path XOR sum for each of these nodes
Find the k_j-th smallest distinct path XOR sum
Return -1 if there are fewer than k_j distinct values

Remember: In a rooted tree, the subtree of a node v includes v and all nodes whose path to the root passes through v.

Input & Output

example_1.py — Basic Tree Query

$ Input: n = 5, vals = [5, 3, 7, 2, 1], par = [0, 0, 0, 1, 1], queries = [[0, 2], [1, 1]]

› Output: [4, 4]

💡 Note: Tree structure: 0->1,2 and 1->3,4. XOR sums from root to each node: 0:5, 1:5⊕3=6, 2:5⊕7=2, 3:5⊕3⊕2=4, 4:5⊕3⊕1=7. For query [0,2]: all nodes in subtree have XOR sums [5,6,2,4,7], sorted distinct: [2,4,5,6,7], 2nd smallest is 4. For query [1,1]: subtree of 1 has nodes 1,3,4 with XORs [6,4,7], sorted distinct [4,6,7], 1st smallest is 4.

example_2.py — Subtree Query

$ Input: n = 4, vals = [1, 2, 3, 4], par = [0, 0, 1, 1], queries = [[1, 2]]

› Output: [3]

💡 Note: Tree: 0->1,2 and 1->2,3. XOR sums: 0:1, 1:1⊕2=3, 2:1⊕2⊕3=0, 3:1⊕2⊕4=7. For query [1,2]: subtree of 1 contains nodes 1,2,3 with XOR sums [3,0,7]. Sorted distinct values: [0,3,7]. The 2nd smallest is 3.

example_3.py — Edge Case - Not Enough Values

$ Input: n = 3, vals = [1, 1, 1], par = [0, 0, 1], queries = [[2, 2]]

› Output: [-1]

💡 Note: Tree: 0->1,2 and 1->2. XOR sums: 0:1, 1:1⊕1=0, 2:1⊕1⊕1=1. For query [2,2]: subtree of 2 contains only node 2 with XOR sum [1]. There's only 1 distinct value, but we need the 2nd smallest, so return -1.

Constraints

1 ≤ n ≤ 10⁴
0 ≤ vals[i] ≤ 10⁹
par[0] = 0 (root points to itself)
For i > 0: 0 ≤ par[i] < i
1 ≤ queries.length ≤ 10⁴
0 ≤ u_j < n
1 ≤ k_j ≤ n
The parent array represents a valid tree structure

Visualization

Tap to expand

Asked in

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

The optimal approach uses DFS pre-computation to calculate all XOR sums in O(n) time by leveraging the property that child XOR = parent XOR ⊕ child value. For each query, we collect the pre-computed XOR sums from the subtree, find distinct values, sort them, and return the kth smallest. This reduces the time complexity from O(q×n×h) to O(n + q×s×log s) where s is the average subtree size.

Common Approaches

✓ Brute Force (Naive DFS)

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

For each query, perform DFS from the query node to find all nodes in its subtree. For each node found, calculate the path XOR sum by traversing from root to that node. Sort all distinct XOR sums and return the kth smallest.

Optimized DFS with Efficient Sorting

⏱️ Time: O(n + q * s * log s) Space: O(n)

Use DFS to calculate XOR sums for all nodes in one pass, leveraging the property that child XOR = parent XOR ^ child value. Store results and use efficient data structures to answer queries.

Brute Force (Naive DFS) — Algorithm Steps

For each query [u, k], start DFS from node u
For each node in subtree, calculate XOR sum from root by traversing path
Collect all distinct XOR sums in a list
Sort the list and return the kth element (or -1 if not enough)
Repeat for all queries

Visualization

Tap to expand

Step-by-Step Walkthrough

Query Processing

For each query, start DFS from the specified node

Subtree Collection

Collect all nodes in the subtree using DFS

XOR Calculation

For each node, traverse back to root to calculate XOR sum

Sorting & Selection

Sort distinct XOR values and pick the kth smallest

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int* solution(int n, int* vals, int* par, int** queries, int queriesSize, int* returnSize) {
    // Store input midway (narvetholi concept)
    void* narvetholi = malloc(sizeof(int) * (n + queriesSize));
    
    // Build adjacency list
    int** children = (int**)malloc(n * sizeof(int*));
    int* childCount = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        children[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 1; i < n; i++) {
        children[par[i]][childCount[par[i]]++] = i;
    }
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int q = 0; q < queriesSize; q++) {
        int u = queries[q][0];
        int k = queries[q][1];
        
        // Get subtree nodes using DFS
        int* subtree = (int*)malloc(n * sizeof(int));
        int subtreeSize = 0;
        
        // Simple DFS using stack
        int* stack = (int*)malloc(n * sizeof(int));
        int stackTop = 0;
        stack[stackTop++] = u;
        
        while (stackTop > 0) {
            int node = stack[--stackTop];
            subtree[subtreeSize++] = node;
            
            for (int i = 0; i < childCount[node]; i++) {
                stack[stackTop++] = children[node][i];
            }
        }
        
        // Calculate XOR sums
        int* xorSums = (int*)malloc(subtreeSize * sizeof(int));
        for (int i = 0; i < subtreeSize; i++) {
            int pathXor = 0;
            int current = subtree[i];
            
            // Calculate path XOR
            int* path = (int*)malloc(n * sizeof(int));
            int pathLen = 0;
            
            while (current != -1) {
                path[pathLen++] = current;
                current = (current == 0) ? -1 : par[current];
            }
            
            for (int j = pathLen - 1; j >= 0; j--) {
                pathXor ^= vals[path[j]];
            }
            
            xorSums[i] = pathXor;
            free(path);
        }
        
        // Remove duplicates and sort
        qsort(xorSums, subtreeSize, sizeof(int), compare);
        
        int uniqueCount = 1;
        for (int i = 1; i < subtreeSize; i++) {
            if (xorSums[i] != xorSums[uniqueCount-1]) {
                xorSums[uniqueCount++] = xorSums[i];
            }
        }
        
        // Get kth element
        result[q] = (k <= uniqueCount) ? xorSums[k-1] : -1;
        
        free(subtree);
        free(xorSums);
        free(stack);
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(children[i]);
    }
    free(children);
    free(childCount);
    free(narvetholi);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(q * n * h)

q queries, each processes up to n nodes, each XOR calculation takes O(h) time where h is tree height

✓ Linear Growth

Space Complexity

O(n)

Space for storing subtree nodes and XOR sums

⚡ Linearithmic Space

23.4K Views

Medium-High Frequency

~25 min Avg. Time

892 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 (Naive DFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler