Maximum XOR of Two Non-Overlapping Subtrees

Maximum XOR of Two Non-Overlapping Subtrees - Problem

Given an undirected tree with n nodes labeled from 0 to n-1, find the maximum XOR of the sums of values from two non-overlapping subtrees.

You are provided with:

An integer n representing the number of nodes
A 2D array edges of length n-1 where edges[i] = [ai, bi] indicates an edge between nodes ai and bi
An array values where values[i] is the value associated with the i-th node

The tree is rooted at node 0. Your task is to select any two non-overlapping subtrees and calculate the bitwise XOR of their sums. Two subtrees are non-overlapping if they share no common nodes.

Goal: Return the maximum possible XOR score. If no two non-overlapping subtrees exist, return 0.

Input & Output

example_1.py — Basic Tree

$ Input: n = 6, edges = [[0,1],[0,2],[1,3],[1,4],[2,5]], values = [4,6,1,3,1,2]

› Output: 16

💡 Note: Select subtree rooted at node 1 (sum = 6+3+1 = 10) and subtree rooted at node 2 (sum = 1+2 = 3). XOR = 10 ^ 3 = 9. However, selecting subtree at node 1 (sum = 10) and single node 5 (sum = 2) gives XOR = 10 ^ 2 = 8. The optimal is selecting subtree at node 3 (sum = 3) and the remaining tree gives better result.

example_2.py — Linear Tree

$ Input: n = 3, edges = [[0,1],[1,2]], values = [5,3,7]

› Output: 12

💡 Note: Select subtree rooted at node 1 (sum = 3+7 = 10) and single node 0 (sum = 5). XOR = 10 ^ 5 = 15. Alternatively, select node 2 (sum = 7) and node 0 (sum = 5) for XOR = 7 ^ 5 = 2. The maximum is 15.

example_3.py — Single Node

$ Input: n = 1, edges = [], values = [10]

› Output: 0

💡 Note: Only one node exists, so we cannot select two non-overlapping subtrees. Return 0.

Visualization

Tap to expand

Understanding the Visualization

Build Network Tree

Construct the tree structure and establish parent-child relationships

Calculate Segment Values

Use DFS to compute total value for each network segment (subtree)

Smart XOR Matching

Use Trie to efficiently find best XOR pairs without checking all combinations

Optimize Locally

Check XOR between child segments at each node for additional optimization

Key Takeaway

🎯 Key Insight: The Trie data structure transforms an O(n²) brute force approach into an O(n log S) optimal solution by enabling efficient maximum XOR queries during tree traversal.

Time & Space Complexity

Time Complexity

⏱️

O(n log S)

O(n) for DFS traversal, O(log S) for each Trie operation where S is maximum sum value

⚡ Linearithmic

Space Complexity

O(n log S)

O(n) for recursion stack, O(n log S) for Trie storage

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 5 × 10⁴
edges.length == n - 1
0 ≤ ai, bi < n
ai ≠ bi
edges represents a valid tree
1 ≤ values[i] ≤ 10⁹

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

The optimal solution uses DFS traversal combined with a Trie data structure to efficiently find maximum XOR pairs. Key insight: instead of checking all O(n²) pairs, we use a Trie to store subtree sums and query for maximum XOR in O(log S) time, achieving overall O(n log S) complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Pairs)	O(n²)	O(n)	Generate all possible subtree sums and check every pair for maximum XOR
DFS + Trie Optimization (Optimal)	O(n log S)	O(n log S)	Use Trie to store subtree sums and find maximum XOR efficiently during DFS traversal

Brute Force (All Pairs) — Algorithm Steps

Build adjacency list from edges
Use DFS to compute sum for every subtree rooted at each node
For each pair of subtrees, check if they are non-overlapping
Calculate XOR of their sums and track maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Compute Subtree Sums

Use DFS to calculate sum for each subtree

Check All Pairs

For each pair, verify they don't overlap

Calculate XOR

Compute XOR and track maximum

Code -

solution.c — C

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

#define MAX_N 1000

int graph[MAX_N][MAX_N];
int graphSize[MAX_N];
long long subtreeSums[MAX_N];
int parent[MAX_N];

long long dfs(int node, int par, int* values) {
    parent[node] = par;
    subtreeSums[node] = values[node];
    
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (neighbor != par) {
            subtreeSums[node] += dfs(neighbor, node, values);
        }
    }
    
    return subtreeSums[node];
}

int areNonOverlapping(int u, int v) {
    // Check if u is ancestor of v
    int curr = v;
    while (curr != -1) {
        if (curr == u) return 0;
        curr = parent[curr];
    }
    
    // Check if v is ancestor of u
    curr = u;
    while (curr != -1) {
        if (curr == v) return 0;
        curr = parent[curr];
    }
    
    return 1;
}

int maxXorOfTwoNonOverlappingSubtrees(int n, int** edges, int edgesSize, int* values) {
    if (n < 2) return 0;
    
    // Initialize graph
    memset(graphSize, 0, sizeof(graphSize));
    memset(parent, -1, sizeof(parent));
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1];
        graph[a][graphSize[a]++] = b;
        graph[b][graphSize[b]++] = a;
    }
    
    dfs(0, -1, values);
    
    long long maxXor = 0;
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (areNonOverlapping(i, j)) {
                long long xor = subtreeSums[i] ^ subtreeSums[j];
                if (xor > maxXor) {
                    maxXor = xor;
                }
            }
        }
    }
    
    return (int)maxXor;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to compute all subtree sums, then O(n²) to check all pairs

⚠ Quadratic Growth

Space Complexity

O(n)

O(n) for recursion stack and storing subtree sums

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 5 × 10⁴
edges.length == n - 1
0 ≤ ai, bi < n
ai ≠ bi
edges represents a valid tree
1 ≤ values[i] ≤ 10⁹

28.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler