Minimum Score After Removals on a Tree

Minimum Score After Removals on a Tree - Problem

There is an undirected connected tree with n nodes labeled from 0 to n - 1 and n - 1 edges.

You are given a 0-indexed integer array nums of length n where nums[i] represents the value of the ith node. You are also given a 2D integer array edges of length n - 1 where edges[i] = [ai, bi] indicates that there is an edge between nodes ai and bi in the tree.

Remove two distinct edges of the tree to form three connected components. For a pair of removed edges, the following steps are defined:

Get the XOR of all the values of the nodes for each of the three components respectively.
The difference between the largest XOR value and the smallest XOR value is the score of the pair.

For example, say the three components have the node values: [4,5,7], [1,9], and [3,3,3]. The three XOR values are 4 ^ 5 ^ 7 = 6, 1 ^ 9 = 8, and 3 ^ 3 ^ 3 = 3. The largest XOR value is 8 and the smallest XOR value is 3. The score is then 8 - 3 = 5.

Return the minimum score of any possible pair of edge removals on the given tree.

Input & Output

Example 1 — Basic Tree

$ Input: nums = [1,5,5,4,11], edges = [[0,1],[1,2],[1,3],[3,4]]

› Output: 9

💡 Note: Remove edges (0,1) and (1,3) to get components {0}, {1,2}, {3,4}. XORs are 1, 0, 15. Score = 15-0 = 15. Remove edges (1,3) and (3,4) to get components {0,1,2}, {3}, {4}. XORs are 1^5^5=1, 4, 11. Score = 11-1 = 10. The minimum is 9.

Example 2 — Minimum Size

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

› Output: 0

💡 Note: With 4 edges and 5 nodes, this tree has multiple ways to create 3 components. Some combinations result in XOR values that are equal, giving a score of 0.

Constraints

3 ≤ n ≤ 1000
edges.length == n - 1
0 ≤ a_i, b_i < n
1 ≤ nums[i] ≤ 2³¹ - 1
The given input represents a valid tree.

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to precompute subtree XOR values using DFS, then systematically try all edge removal pairs. The optimal approach uses tree structure to avoid redundant calculations. Time: O(n³), Space: O(n)

Common Approaches

✓ Brute Force

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

For every pair of edges, remove them, find the three connected components using DFS/BFS, calculate XOR for each component, and find the minimum score.

DFS with Subtree XOR Precomputation

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

First, build the tree and compute XOR values for all subtrees using DFS. Then systematically try removing edge pairs, using precomputed values to quickly determine component XORs.

Brute Force — Algorithm Steps

Generate all possible pairs of edges
For each pair, remove edges and find 3 components
Calculate XOR for each component
Find max-min difference
Return minimum score

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Pairs

Create all possible pairs of edges to remove

Find Components

For each pair, identify the 3 resulting components

Calculate Score

XOR each component and find max-min difference

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int** edges, int edgesSize, int* edgesColSize) {
    if (numsSize < 3) return 0;
    
    int minScore = INT_MAX;
    
    for (int i = 0; i < edgesSize; i++) {
        for (int j = i + 1; j < edgesSize; j++) {
            // Create adjacency list without edges i and j
            int** graph = (int**)malloc(numsSize * sizeof(int*));
            int* graphSize = (int*)calloc(numsSize, sizeof(int));
            
            for (int k = 0; k < numsSize; k++) {
                graph[k] = (int*)malloc(numsSize * sizeof(int));
            }
            
            for (int k = 0; k < edgesSize; k++) {
                if (k != i && k != j) {
                    int u = edges[k][0], v = edges[k][1];
                    if (u < numsSize && v < numsSize) {
                        graph[u][graphSize[u]++] = v;
                        graph[v][graphSize[v]++] = u;
                    }
                }
            }
            
            // Find connected components using DFS
            int* visited = (int*)calloc(numsSize, sizeof(int));
            int components[3][1000];
            int componentSizes[3] = {0};
            int numComponents = 0;
            
            for (int node = 0; node < numsSize && numComponents < 3; node++) {
                if (!visited[node]) {
                    int stack[1000];
                    int stackSize = 0;
                    stack[stackSize++] = node;
                    
                    while (stackSize > 0) {
                        int curr = stack[--stackSize];
                        if (!visited[curr]) {
                            visited[curr] = 1;
                            if (numComponents < 3 && componentSizes[numComponents] < 1000) {
                                components[numComponents][componentSizes[numComponents]++] = curr;
                            }
                            
                            for (int k = 0; k < graphSize[curr]; k++) {
                                if (!visited[graph[curr][k]]) {
                                    stack[stackSize++] = graph[curr][k];
                                }
                            }
                        }
                    }
                    if (numComponents < 3) numComponents++;
                }
            }
            
            if (numComponents == 3) {
                int xorValues[3] = {0};
                for (int k = 0; k < 3; k++) {
                    for (int l = 0; l < componentSizes[k]; l++) {
                        xorValues[k] ^= nums[components[k][l]];
                    }
                }
                
                int maxXor = xorValues[0];
                int minXor = xorValues[0];
                for (int k = 1; k < 3; k++) {
                    if (xorValues[k] > maxXor) maxXor = xorValues[k];
                    if (xorValues[k] < minXor) minXor = xorValues[k];
                }
                
                int score = maxXor - minXor;
                if (score < minScore) minScore = score;
            }
            
            // Cleanup
            for (int k = 0; k < numsSize; k++) {
                free(graph[k]);
            }
            free(graph);
            free(graphSize);
            free(visited);
        }
    }
    
    return minScore;
}

int main() {
    // For the C version, I'll read from stdin properly
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing - this is basic but works for the format
    int nums[1000];
    int numsSize = 0;
    
    // Parse nums array [1,5,5,4,11]
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        int val = atoi(token);
        if (val != 0 || strcmp(token, "0") == 0) {
            nums[numsSize++] = val;
        }
        token = strtok(NULL, "[,]");
    }
    
    // Read edges line
    fgets(line, sizeof(line), stdin);
    
    int edges[1000][2];
    int edgesSize = 0;
    int edgesColSize[1000];
    
    // Parse edges - simplified parsing
    char* start = strchr(line, '[');
    if (start) {
        start++;
        char* ptr = start;
        while (*ptr && edgesSize < 1000) {
            if (*ptr == '[') {
                ptr++;
                edges[edgesSize][0] = atoi(ptr);
                while (*ptr && *ptr != ',') ptr++;
                if (*ptr == ',') ptr++;
                edges[edgesSize][1] = atoi(ptr);
                edgesColSize[edgesSize] = 2;
                edgesSize++;
                while (*ptr && *ptr != ']') ptr++;
                if (*ptr == ']') ptr++;
            } else {
                ptr++;
            }
        }
    }
    
    int* edgePointers[1000];
    for (int i = 0; i < edgesSize; i++) {
        edgePointers[i] = edges[i];
    }
    
    int result = solution(nums, numsSize, edgePointers, edgesSize, edgesColSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) edge pairs × O(n) component finding and XOR calculation

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list and visited arrays during DFS

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler