Maximum Score After Applying Operations on a Tree

Maximum Score After Applying Operations on a Tree - Problem

Imagine you're a resource collector in a mystical tree where each node contains valuable points. You can collect points from any node, but there's a crucial constraint: the tree must remain "healthy".

Given an undirected tree with n nodes (labeled 0 to n-1) rooted at node 0, you need to:

Collect points from nodes to maximize your score
Ensure every path from root to any leaf has a non-zero sum (healthy tree)

Operations: Pick any node, add its value to your score, then set that node's value to 0.

Goal: Find the maximum score while keeping the tree healthy!

Example: If you have a path root→leaf with values [5, 3, 2], you can collect at most 2 nodes' values (leaving at least one non-zero for health).

Input & Output

example_1.py — Simple Tree

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

› Output: 6

💡 Note: We can take nodes 1 and 4 (values 2+4=6). The paths remain healthy: [3→3→2] sum=5, [3→3→0→5] sum=8, [3→2] sum=5. All paths have non-zero sums.

example_2.py — Linear Tree

$ Input: edges = [[0,1],[1,2],[2,3]] values = [10,5,3,1]

› Output: 15

💡 Note: We can take nodes 0, 1, and 2 (values 10+5+3=18), but this makes the path sum 0. Instead, take nodes 0 and 1 (10+5=15), leaving path [0→3→1] with sum=4.

example_3.py — Single Node

$ Input: edges = [] values = [5]

› Output: 0

💡 Note: With only one node (the root), we cannot take it because then the path from root to itself would have sum 0, making the tree unhealthy.

Constraints

1 ≤ n ≤ 2 × 10⁴
edges.length == n - 1
0 ≤ a_i, b_i < n
All edges are distinct and form a valid tree
1 ≤ values[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses Dynamic Programming on Trees. For each node, we compute two states: the maximum score if we keep the node vs if we take the node. The key insight is that taking a node forces us to keep all its children to maintain health, while keeping a node allows optimal choices in subtrees. Time complexity: O(n), Space: O(n).

Common Approaches

✓ Brute Force (Try All Combinations)

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

Generate all possible combinations of nodes to collect from, and for each combination, verify that every root-to-leaf path has at least one non-zero node. This approach explores the entire solution space but is extremely inefficient.

Dynamic Programming (Optimal)

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

This is the optimal approach using dynamic programming on trees. For each node, we calculate two values: the maximum score if we must keep this node (to maintain health), and the maximum score if we can take this node. The key insight is that for each subtree, we either take the current node's value OR we take everything from the subtree but sacrifice the current node to keep paths healthy.

Brute Force (Try All Combinations) — Algorithm Steps

Generate all 2^n possible subsets of nodes
For each subset, simulate collecting from those nodes
Check if all root-to-leaf paths have non-zero sum
Track the maximum valid score found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Subsets

Create all 2^n possible combinations of nodes to collect from

Apply Operations

For each subset, collect values and set those nodes to 0

Validate Health

Check that every root-to-leaf path has non-zero sum

Track Maximum

Keep track of the highest valid score found

Code -

solution.c — C

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

#define MAX_N 20000

static int adj[MAX_N][MAX_N];
static int adjCount[MAX_N];
static int* values_global;
static int n_global;

long long min_ll(long long a, long long b) {
    return a < b ? a : b;
}

long long get_subtree_sum(int node, int parent) {
    long long total = values_global[node];
    
    for (int i = 0; i < adjCount[node]; i++) {
        int child = adj[node][i];
        if (child != parent) {
            total += get_subtree_sum(child, node);
        }
    }
    
    return total;
}

long long min_to_keep_healthy(int node, int parent) {
    int children[MAX_N];
    int childCount = 0;
    
    // Get children
    for (int i = 0; i < adjCount[node]; i++) {
        int child = adj[node][i];
        if (child != parent) {
            children[childCount++] = child;
        }
    }
    
    if (childCount == 0) {
        // Leaf node - must keep it
        return values_global[node];
    }
    
    // Option 1: keep current node (then children can be handled optimally)
    long long option1 = values_global[node];
    
    // Option 2: take current node, but then all children subtrees must be healthy
    long long option2 = 0;
    for (int i = 0; i < childCount; i++) {
        option2 += min_to_keep_healthy(children[i], node);
    }
    
    return min_ll(option1, option2);
}

long long maximumScoreAfterOperations(int edges[][2], int edgesSize, int* values, int valuesSize) {
    int n = valuesSize;
    if (n == 1) return 0;
    
    n_global = n;
    memset(adjCount, 0, sizeof(adjCount));
    values_global = values;
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1];
        adj[a][adjCount[a]++] = b;
        adj[b][adjCount[b]++] = a;
    }
    
    long long total_sum = get_subtree_sum(0, -1);
    long long min_keep = min_to_keep_healthy(0, -1);
    return total_sum - min_keep;
}

int main() {
    char line[10000];
    
    // Read edges line
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    static int edges[MAX_N][2];
    int edgesSize = 0;
    
    if (strcmp(line, "[]") != 0) {
        char* p = line + 1;
        while (*p && edgesSize < MAX_N) {
            if (*p == '[') {
                p++;
                edges[edgesSize][0] = strtol(p, &p, 10);
                if (*p == ',') p++;
                edges[edgesSize][1] = strtol(p, &p, 10);
                edgesSize++;
                while (*p && *p != ']') p++;
                if (*p == ']') p++;
            } else {
                p++;
            }
        }
    }
    
    // Read values line
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    static int values[MAX_N];
    int valuesSize = 0;
    
    char* p = line;
    while (*p && valuesSize < MAX_N) {
        if (*p >= '0' && *p <= '9') {
            values[valuesSize++] = strtol(p, &p, 10);
            while (*p == ',' || *p == ' ') p++;
        } else {
            p++;
        }
    }
    
    long long result = maximumScoreAfterOperations(edges, edgesSize, values, valuesSize);
    printf("%lld\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

2^n subsets to check, each requiring O(n) time to validate all paths

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and temporary storage for path validation

⚡ Linearithmic Space

34.8K Views

Medium Frequency

~25 min Avg. Time

1.5K 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler