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

✓ Sort First

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

Memoization

⏱️ 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>
#include <limits.h>

#define MOD 1000000007
#define MAX_SIZE 1000

long long result = 0;

void backtrack(int* nums, int n, int k, int start, int* current, int currentSize) {
    if (currentSize == k) {
        if (k == 1) return;
        long long minDiff = LLONG_MAX;
        for (int i = 0; i < currentSize; i++) {
            for (int j = i + 1; j < currentSize; j++) {
                long long diff = abs(current[i] - current[j]);
                if (diff < minDiff) minDiff = diff;
            }
        }
        result = (result + minDiff) % MOD;
        return;
    }
    
    for (int i = start; i < n; i++) {
        current[currentSize] = nums[i];
        backtrack(nums, n, k, i + 1, current, currentSize + 1);
    }
}

int solution(int* nums, int n, int k) {
    result = 0;
    int* current = (int*)malloc(k * sizeof(int));
    backtrack(nums, n, k, 0, current, 0);
    free(current);
    return (int)result;
}

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

int main() {
    char input[MAX_SIZE];
    int k;
    
    fgets(input, MAX_SIZE, stdin);
    scanf("%d", &k);
    
    // Parse array
    int nums[100];
    int n = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", solution(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear 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