Find the Maximum Sum of Node Values

Find the Maximum Sum of Node Values - Problem

Array Dynamic Programming Greedy Bit Manipulation Tree Sorting Hard

There exists an undirected tree with n nodes numbered 0 to n - 1. You are given a 0-indexed 2D integer array edges of length n - 1, where edges[i] = [u_i, v_i] indicates that there is an edge between nodes u_i and v_i in the tree.

You are also given a positive integer k, and a 0-indexed array of non-negative integers nums of length n, where nums[i] represents the value of the node numbered i.

Alice wants the sum of values of tree nodes to be maximum, for which Alice can perform the following operation any number of times (including zero) on the tree:

Choose any edge [u, v] connecting the nodes u and v, and update their values as follows:

nums[u] = nums[u] XOR k
nums[v] = nums[v] XOR k

Return the maximum possible sum of the values Alice can achieve by performing the operation any number of times.

Input & Output

Example 1 — Basic Tree

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

› Output: 6

💡 Note: Calculate XOR benefits: node 0: (1^3)-1=1, node 1: (2^3)-2=-1, node 2: (1^3)-1=1. Sort benefits: [1,1,-1]. Since we need even number of XORed nodes, we can select 0 nodes (sum=4) or 2 nodes with highest benefits (sum=4+1+1=6). Maximum is 6.

Example 2 — Single Node

$ Input: nums = [2], k = 5, edges = []

› Output: 7

💡 Note: Single node: choose max(2, 2^5) = max(2, 7) = 7

Example 3 — No Benefit

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

› Output: 21

💡 Note: 7^3=4 for all nodes, so XOR reduces values. Keep original: 7+7+7=21

Constraints

2 ≤ nums.length ≤ 2 * 10⁴
1 ≤ k ≤ 10⁹
0 ≤ nums[i] ≤ 10⁹
edges.length == nums.length - 1
edges[i].length == 2
0 ≤ edges[i][0], edges[i][1] ≤ nums.length - 1

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that XOR operations on tree edges create parity constraints - we need an even number of node transformations. The optimal approach calculates XOR benefits for each node independently, sorts them, and selects the maximum even-sized subset. Time: O(n log n), Space: O(n)

Common Approaches

✓ Memoization

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

Sort First

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

Brute Force - Try All Combinations

⏱️ Time: O(2^(n²)) Space: O(n)

Generate all possible states by trying every combination of applying XOR operations to each edge. Since each edge can be used 0, 1, 2, or more times, we need to consider the effect of multiple operations.

Greedy - Maximize Individual Benefits

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

For each node, calculate the benefit of applying XOR operation (nums[i] ^ k - nums[i]). Sort nodes by benefit and greedily apply operations that give positive benefit, considering parity constraints.

Optimal - XOR Parity Analysis

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

Key insight: XOR operations on edges can be viewed as flipping node states. The tree structure means we need an even number of flipped nodes. We can calculate the optimal solution by considering all nodes independently with parity constraint.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_SIZE 1000

static int nums[MAX_SIZE];
static long long benefits[MAX_SIZE];
static int edges[MAX_SIZE][2];

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    if (strcmp(str, "[]") == 0 || strcmp(str, "[]\n") == 0) return;
    
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        char* endptr;
        arr[(*size)++] = (int)strtol(p, &endptr, 10);
        p = endptr;
    }
}

void parseEdges(const char* str, int edges[][2], int* edgeCount) {
    *edgeCount = 0;
    if (strcmp(str, "[]") == 0 || strcmp(str, "[]\n") == 0) return;
    
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        if (*p == '[') {
            p++;
            char* endptr;
            edges[*edgeCount][0] = (int)strtol(p, &endptr, 10);
            p = endptr;
            
            while (*p == ' ' || *p == ',') p++;
            
            edges[*edgeCount][1] = (int)strtol(p, &endptr, 10);
            p = endptr;
            
            (*edgeCount)++;
            
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
        } else {
            p++;
        }
        
        while (*p == ' ' || *p == ',') p++;
    }
}

int compareLongLong(const void* a, const void* b) {
    long long diff = *(long long*)b - *(long long*)a;
    return (diff > 0) ? 1 : (diff < 0) ? -1 : 0;
}

long long solution(int* nums, int n, int k, int edges[][2], int edgeCount) {
    if (n == 1) {
        long long original = (long long)nums[0];
        long long xored = (long long)(nums[0] ^ k);
        return (original > xored) ? original : xored;
    }
    
    long long originalSum = 0;
    
    for (int i = 0; i < n; i++) {
        originalSum += nums[i];
        benefits[i] = (long long)(nums[i] ^ k) - nums[i];
    }
    
    qsort(benefits, n, sizeof(long long), compareLongLong);
    
    long long maxSum = originalSum;
    long long currentBonus = 0;
    
    for (int count = 2; count <= n; count += 2) {
        currentBonus += benefits[count-2] + benefits[count-1];
        long long candidate = originalSum + currentBonus;
        maxSum = (maxSum > candidate) ? maxSum : candidate;
    }
    
    return maxSum;
}

int main() {
    char numsStr[MAX_SIZE];
    char kStr[MAX_SIZE];
    char edgesStr[MAX_SIZE];
    
    fgets(numsStr, MAX_SIZE, stdin);
    fgets(kStr, MAX_SIZE, stdin);
    fgets(edgesStr, MAX_SIZE, stdin);
    
    int n;
    parseArray(numsStr, nums, &n);
    int k = atoi(kStr);
    int edgeCount;
    parseEdges(edgesStr, edges, &edgeCount);
    
    printf("%lld\n", solution(nums, n, k, edges, edgeCount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~35 min Avg. Time

890 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