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

Understanding the Visualization

Leaf Nodes

Leaves can only be taken (giving their value) or kept (giving 0)

Internal Nodes

For each internal node, calculate keep vs take scenarios

Propagate Up

Use children's optimal values to compute parent's optimal choice

Root Decision

The root's optimal choice gives the maximum possible score

Key Takeaway

🎯 Key Insight: Each node presents a binary choice that affects the entire subtree's optimization strategy

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

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(n)	Use tree DP to decide for each subtree: keep root or take all children
Brute Force (Try All Combinations)	O(2^n × n)	O(n)	Try every possible subset of nodes and check if the tree remains healthy

Dynamic Programming (Optimal) — Algorithm Steps

Build the tree structure from edges
Define DP states: keep[node] and take[node]
For each node, calculate maximum score keeping it vs taking it
Use post-order traversal to compute bottom-up
Return the maximum of keeping or taking the root

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Leaves

Compute DP values for leaf nodes first

Propagate Upward

For each internal node, compute keep vs take options

Make Optimal Choice

Choose between keeping node or taking it based on children

Return Root Result

Final answer is maximum of keeping or taking root

Code -

solution.c — C

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

#define MAX_N 20000

typedef struct {
    int adj[MAX_N][MAX_N];
    int adjCount[MAX_N];
} Graph;

typedef struct {
    long long keep;
    long long take;
} DPResult;

Graph graph;
int* values;

DPResult dfs(int node, int parent, int n) {
    DPResult result = {0, 0};
    
    // Base case: leaf node
    if (graph.adjCount[node] == 1 && node != 0) {
        result.keep = 0;
        result.take = values[node];
        return result;
    }
    
    // For internal nodes, we have children
    long long childrenKeepSum = 0;  // Sum if we keep all children
    long long childrenTakeSum = 0;  // Sum if we optimally choose from children
    
    for (int i = 0; i < graph.adjCount[node]; i++) {
        int child = graph.adj[node][i];
        if (child != parent) {
            DPResult childResult = dfs(child, node, n);
            childrenKeepSum += childResult.keep;
            childrenTakeSum += (childResult.take > childResult.keep) ? childResult.take : childResult.keep;
        }
    }
    
    // Option 1: Keep current node, take optimally from children
    result.keep = childrenTakeSum;
    
    // Option 2: Take current node, but ensure at least one child is kept
    result.take = values[node] + childrenKeepSum;
    
    return result;
}

long long maximumScoreAfterOperations(int** edges, int edgesSize, int* edgesColSize, int* vals, int valuesSize) {
    int n = valuesSize;
    if (n == 1) return 0;
    
    values = vals;
    memset(&graph, 0, sizeof(graph));
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1];
        graph.adj[a][graph.adjCount[a]++] = b;
        graph.adj[b][graph.adjCount[b]++] = a;
    }
    
    DPResult result = dfs(0, -1, n);
    return (result.take > result.keep) ? result.take : result.keep;
}

int main() {
    // Example usage
    int edgesArray[][2] = {{0,2},{1,2},{1,3},{2,4}};
    int* edges[4];
    for (int i = 0; i < 4; i++) {
        edges[i] = edgesArray[i];
    }
    int edgesColSize[] = {2,2,2,2};
    int values[] = {1,2,3,4,5};
    
    long long result = maximumScoreAfterOperations(edges, 4, edgesColSize, values, 5);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal visiting each node exactly once

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and memoization arrays

⚡ 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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler