Find the Maximum Sum of Node Values - Practice Coding Problems

Find the Maximum Sum of Node Values - Problem

Array Dynamic Programming Greedy Bit Manipulation Tree Sorting Hard

Imagine you have a magical tree where you can enhance the values of nodes through strategic operations! You're given an undirected tree with n nodes numbered from 0 to n-1, connected by edges, where each node has an initial value stored in the nums array.

The magic happens when you choose any edge [u, v] and simultaneously transform both connected nodes using the XOR operation with a special key k:

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

Your mission is to maximize the total sum of all node values by performing this magical transformation operation any number of times (including zero) on any edges you choose.

Key insight: Since it's a tree, there's exactly one path between any two nodes, and XOR operations can be strategically chained to achieve optimal results!

Input & Output

example_1.py — Basic Tree

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

› Output: 6

💡 Note: We can XOR nodes 1 and 2 by choosing edge [0,1] and then edge [0,2]. This gives us nums = [1,2^3,1^3] = [1,1,2]. The sum is 1+1+2 = 4. But we can do better by XORing nodes 0 and 1 via edge [0,1], getting [1^3,2^3,1] = [2,1,1], sum = 4. Actually, the optimal is to XOR all nodes: use edge [0,1] to XOR nodes 0,1, then edge [0,2] to XOR nodes 0,2. This gives [1^3^3, 2^3, 1^3] = [1,1,2] with sum 4. Wait, let me recalculate: we want maximum sum, so we try [2,1,2] which sums to 5, or [2,1,1] = 4. Actually optimal is [2,1,2] = 5, but that requires odd XORs which isn't possible. The answer is 6 when we XOR pairs optimally.

example_2.py — Larger Tree

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

› Output: 9

💡 Note: We have two nodes connected by one edge. We can either keep the original values (sum = 2+3 = 5) or XOR both nodes using the edge [0,1]. If we XOR: nums[0] = 2^7 = 5, nums[1] = 3^7 = 4. New sum = 5+4 = 9, which is better than 5.

example_3.py — No Improvement Case

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

› Output: 42

💡 Note: Each node has value 7. If we XOR any node with k=3, we get 7^3=4, which is worse. Since any XOR operation must be applied to pairs (even count), and all XOR operations decrease values, the optimal strategy is to perform no XOR operations. Sum = 6*7 = 42.

Visualization

Tap to expand

Understanding the Visualization

Initial Tree

Start with the tree and initial node values

Calculate Benefits

For each node, calculate (value ^ k) - value to see if XOR helps

Apply Parity Rule

Only even numbers of nodes can be XORed in a tree

Find Optimal

Use DP to find the maximum sum respecting the parity constraint

Key Takeaway

🎯 Key Insight: The tree structure constrains us to XOR an even number of nodes. We use DP to efficiently explore all valid configurations while respecting this parity constraint, achieving optimal O(n log n) complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting the benefits, then O(n) for DP processing

⚡ Linearithmic

Space Complexity

O(n)

Space for storing benefits array and DP states

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 2 * 10⁴
1 ≤ k ≤ 10⁹
0 ≤ nums[i] ≤ 10⁹
edges.length == n - 1
The input represents a valid tree

Asked in

G Google 28 ⊞ Microsoft 22 a Amazon 15 f Meta 12

The optimal approach uses dynamic programming with parity tracking. Key insight: since XOR operations in a tree must affect an even number of nodes, we calculate the benefit of XORing each node, sort benefits in descending order, and use DP to track maximum sums for even/odd XOR counts. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Possible States)	O(2^n * n)	O(n)	Try all possible combinations of XOR operations on each node
Dynamic Programming (Optimal)	O(n log n)	O(n)	Use DP to track states with even/odd number of XOR operations

Brute Force (Try All Possible States) — Algorithm Steps

Generate all possible states (2^n combinations)
For each state, check if it's achievable by XOR operations on tree edges
Calculate the sum for each valid state
Return the maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate States

Create all 2^n possible combinations of XOR operations

Filter Valid

Keep only states with even number of XORed nodes

Calculate Sums

Compute the total sum for each valid state

Find Maximum

Return the state that gives maximum sum

Code -

solution.c — C

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

long long maximumValueSum(int* nums, int numsSize, int k, int** edges, int edgesSize, int* edgesColSize) {
    int n = numsSize;
    long long maxSum = 0;
    for (int i = 0; i < n; i++) {
        maxSum += nums[i];
    }
    
    // Try all possible XOR states
    for (int mask = 0; mask < (1 << n); mask++) {
        // Count number of XORed nodes
        int xorCount = 0;
        int temp = mask;
        while (temp > 0) {
            if (temp & 1) xorCount++;
            temp >>= 1;
        }
        
        // Skip if odd number of XORed nodes
        if (xorCount % 2 != 0) continue;
        
        // Calculate sum for this state
        long long currentSum = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                currentSum += nums[i] ^ k;
            } else {
                currentSum += nums[i];
            }
        }
        
        if (currentSum > maxSum) {
            maxSum = currentSum;
        }
    }
    
    return maxSum;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

We try 2^n states, and for each state we need O(n) time to verify validity and calculate sum

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the tree structure and current state

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 2 * 10⁴
1 ≤ k ≤ 10⁹
0 ≤ nums[i] ≤ 10⁹
edges.length == n - 1
The input represents a valid tree

18.7K Views

Medium-High Frequency

~25 min Avg. Time

847 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 (Try All Possible States) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler