Minimum Score After Removals on a Tree - Practice Coding Problems

Minimum Score After Removals on a Tree - Problem

Imagine you have a connected tree with n nodes (labeled 0 to n-1) where each node has a specific value. Your task is to strategically remove exactly two edges to split this tree into three separate components.

Here's the challenge: For each possible pair of edge removals, you need to:

Calculate the XOR of all node values in each of the three resulting components
Find the difference between the largest and smallest XOR values (this is your "score")
Minimize this score across all possible edge removal pairs

Example: If removing two edges creates components with node values [4,5,7], [1,9], and [3,3,3], the XOR values would be 4^5^7=6, 1^9=8, and 3^3^3=3. The score would be max(6,8,3) - min(6,8,3) = 8-3 = 5.

Return the minimum possible score among all valid edge removal combinations.

Input & Output

example_1.py — Basic Tree

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

› Output: 9

💡 Note: Removing edges [1,3] and [3,4] creates components with XOR values [1⊕5=4, 5, 4⊕11=15]. Score = 15-4 = 11. The optimal removal gives score 9.

example_2.py — Small Tree

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

› Output: 0

💡 Note: There exists a way to remove two edges such that all three components have the same XOR value, resulting in a score of 0.

example_3.py — Minimal Tree

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

› Output: 2

💡 Note: Only one way to split: remove both edges to get components [1], [2], [3] with XORs 1, 2, 3. Score = 3-1 = 2.

Constraints

3 ≤ n ≤ 1000
edges.length == n - 1
0 ≤ nums[i] ≤ 2⁸
The given edges form a valid tree
Each edge connects two distinct nodes

Asked in

The optimal approach uses DFS with subtree XOR precomputation. First, perform DFS to establish parent-child relationships and calculate XOR values for all subtrees in O(n) time. Then, for each pair of edges to remove, use the precomputed values to determine the three component XORs in O(1) time by analyzing ancestor-descendant relationships. This reduces the overall complexity from O(n³) brute force to O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Subtree XOR Precomputation	O(n²)	O(n)	First pass: compute subtree XORs; Second pass: try edge removals using precomputed values
Brute Force (Try All Edge Pairs)	O(n³)	O(n)	Try every possible pair of edges to remove and calculate the score for each combination

DFS with Subtree XOR Precomputation — Algorithm Steps

Build adjacency list and perform DFS to establish parent-child relationships
First pass: Calculate XOR values for all subtrees in bottom-up manner
Second pass: For each pair of edges, determine the three components using precomputed subtree XORs
Handle different cases: ancestor-descendant edges vs independent edges
Track minimum score across all valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

DFS Tree Construction

Build DFS tree and establish parent-child relationships

Subtree XOR Calculation

Compute XOR values for all subtrees bottom-up

Edge Pair Analysis

Analyze ancestor-descendant vs independent edge relationships

Efficient Score Computation

Use precomputed XORs to calculate scores in O(1) time

Code -

solution.c — C

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

#define MAX_N 1000

typedef struct {
    int* data;
    int size;
    int capacity;
} IntList;

IntList* createList() {
    IntList* list = (IntList*)malloc(sizeof(IntList));
    list->capacity = 10;
    list->size = 0;
    list->data = (int*)malloc(list->capacity * sizeof(int));
    return list;
}

void addToList(IntList* list, int value) {
    if (list->size >= list->capacity) {
        list->capacity *= 2;
        list->data = (int*)realloc(list->data, list->capacity * sizeof(int));
    }
    list->data[list->size++] = value;
}

static int parent[MAX_N];
static int subtreeXor[MAX_N];
static IntList* graph[MAX_N];
static int* nums_global;

void dfs(int node, int par) {
    parent[node] = par;
    subtreeXor[node] = nums_global[node];
    
    for (int i = 0; i < graph[node]->size; i++) {
        int neighbor = graph[node]->data[i];
        if (neighbor != par) {
            dfs(neighbor, node);
            subtreeXor[node] ^= subtreeXor[neighbor];
        }
    }
}

int isAncestor(int u, int v) {
    int current = v;
    while (current != -1) {
        if (current == u) return 1;
        current = parent[current];
    }
    return 0;
}

int minimumScore(int* nums, int numsSize, int** edges, int edgesSize, int* edgesColSize) {
    nums_global = nums;
    
    // Initialize
    for (int i = 0; i < numsSize; i++) {
        parent[i] = -1;
        subtreeXor[i] = 0;
        graph[i] = createList();
    }
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        addToList(graph[edges[i][0]], edges[i][1]);
        addToList(graph[edges[i][1]], edges[i][0]);
    }
    
    // First pass: DFS to compute subtree XOR values
    dfs(0, -1);
    int totalXor = subtreeXor[0];
    
    int minScore = INT_MAX;
    
    // Second pass: try all pairs of edges
    for (int i = 0; i < edgesSize; i++) {
        for (int j = i + 1; j < edgesSize; j++) {
            int u1 = edges[i][0], v1 = edges[i][1];
            int u2 = edges[j][0], v2 = edges[j][1];
            
            // Ensure parent-child relationship
            if (parent[u1] == v1) {
                int temp = u1; u1 = v1; v1 = temp;
            }
            if (parent[u2] == v2) {
                int temp = u2; u2 = v2; v2 = temp;
            }
            
            int xorValues[3];
            
            // Case 1: One edge is ancestor of another
            if (isAncestor(v1, v2) || isAncestor(v2, v1)) {
                if (isAncestor(v1, v2)) {
                    xorValues[0] = subtreeXor[v2];
                    xorValues[1] = subtreeXor[v1] ^ subtreeXor[v2];
                    xorValues[2] = totalXor ^ subtreeXor[v1];
                } else {
                    xorValues[0] = subtreeXor[v1];
                    xorValues[1] = subtreeXor[v2] ^ subtreeXor[v1];
                    xorValues[2] = totalXor ^ subtreeXor[v2];
                }
            } else {
                // Case 2: Independent edges
                xorValues[0] = subtreeXor[v1];
                xorValues[1] = subtreeXor[v2];
                xorValues[2] = totalXor ^ subtreeXor[v1] ^ subtreeXor[v2];
            }
            
            int maxVal = xorValues[0];
            int minVal = xorValues[0];
            for (int k = 1; k < 3; k++) {
                if (xorValues[k] > maxVal) maxVal = xorValues[k];
                if (xorValues[k] < minVal) minVal = xorValues[k];
            }
            
            int score = maxVal - minVal;
            if (score < minScore) {
                minScore = score;
            }
        }
    }
    
    // Free memory
    for (int i = 0; i < numsSize; i++) {
        free(graph[i]->data);
        free(graph[i]);
    }
    
    return minScore;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) for DFS preprocessing + O(n²) for trying all edge pairs with O(1) XOR lookups

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list, parent array, subtree XOR values, and DFS recursion stack

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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