Maximum Points After Collecting Coins From All Nodes

Maximum Points After Collecting Coins From All Nodes - Problem

Array Dynamic Programming Bit Manipulation Tree Depth-First Search Memoization Hard

There exists an undirected tree rooted at node 0 with n nodes labeled from 0 to n - 1. You are given a 2D integer array edges of length n - 1, where edges[i] = [a_i, b_i] indicates that there is an edge between nodes a_i and b_i in the tree.

You are also given a 0-indexed array coins of size n where coins[i] indicates the number of coins in the vertex i, and an integer k.

Starting from the root, you have to collect all the coins such that the coins at a node can only be collected if the coins of its ancestors have been already collected.

Coins at node i can be collected in one of the following ways:

Collect all the coins, but you will get coins[i] - k points. If coins[i] - k is negative then you will lose abs(coins[i] - k) points.
Collect all the coins, but you will get floor(coins[i] / 2) points. If this way is used, then for all the node j present in the subtree of node i, coins[j] will get reduced to floor(coins[j] / 2).

Return the maximum points you can get after collecting the coins from all the tree nodes.

Input & Output

Example 1 — Basic Tree

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

› Output: 7

💡 Note: Node 0: take 1-3=-2, Node 1: take 4/2=2 (halve subtree), Node 2: take 1-3=-2, Node 3: take 1-3=-2. Total = -2+2+(-2)+(-2) = -4. Better: Node 0: 1/2=0, Node 1: 2-3=-1, Node 2: 1-3=-2, Node 3: 1-3=-2. Try Node 1 halve: gets 2, children get halved to 1 each, then 1-3=-2 each. Total = 0+2+(-2)+(-2) = -2. Optimal is 7 with careful choices.

Example 2 — Single Node

$ Input: edges = [], coins = [10], k = 3

› Output: 7

💡 Note: Only one node: max(10-3, 10/2) = max(7, 5) = 7

Example 3 — Linear Chain

$ Input: edges = [[0,1],[1,2]], coins = [8,6,4], k = 2

› Output: 12

💡 Note: Node 0: 8-2=6, Node 1: 6-2=4, Node 2: 4-2=2. Total = 6+4+2=12

Constraints

2 ≤ n ≤ 10⁵
edges.length == n - 1
0 ≤ a_i, b_i < n
0 ≤ coins[i] ≤ 10⁴
0 ≤ k ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 25 f Meta 15 a Amazon 20

The key insight is to use dynamic programming with memoization to track how many ancestors chose the 'halve' operation. Each node can either take coins[i] - k points or take coins[i] / 2 points while halving all descendants. Best approach uses DFS with state tracking: Time O(n × log(max_coins)), Space O(n × log(max_coins))

Common Approaches

✓ Brute Force Recursion

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

For each node, recursively try both collection methods (subtract k vs halve) and return the maximum points. This explores all 2^n possible combinations.

Memoization with State Tracking

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

Track how many times ancestors chose 'halve' operation using a counter. Use memoization to cache results for (node, halve_count) pairs to avoid redundant calculations.

Brute Force Recursion — Algorithm Steps

Build adjacency list from edges
For each node, try both collection methods
Recursively solve for all children
Return maximum of both options

Visualization

Tap to expand

Step-by-Step Walkthrough

Tree Structure

Build tree from edges

Try Both Options

For each node, try subtract-k and halve methods

Recursive Exploration

Recursively solve for all subtrees

Code -

solution.c — C

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

#define MAX_N 100005
int graph[MAX_N][MAX_N];
int graph_size[MAX_N];
int coins[MAX_N];
int k_global;

int max(int a, int b) {
    return a > b ? a : b;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int dfs(int node, int parent, int n, int halveCount) {
    // Limit halveCount to prevent infinite recursion
    halveCount = min(halveCount, 14);
    
    // Calculate current coin value after halveCount operations
    int currentValue = coins[node];
    for (int i = 0; i < halveCount; i++) {
        currentValue /= 2;
    }
    
    // Option 1: Take currentValue - k
    int option1 = currentValue - k_global;
    for (int i = 0; i < graph_size[node]; i++) {
        int child = graph[node][i];
        if (child != parent) {
            option1 += dfs(child, node, n, halveCount);
        }
    }
    
    // Option 2: Take currentValue / 2 and increment halveCount for children
    int option2 = currentValue / 2;
    for (int i = 0; i < graph_size[node]; i++) {
        int child = graph[node][i];
        if (child != parent) {
            option2 += dfs(child, node, n, halveCount + 1);
        }
    }
    
    return max(option1, option2);
}

int solution(int edges[][2], int edge_count, int* coinsArray, int n, int k) {
    if (n == 1) {
        return max(coinsArray[0] - k, coinsArray[0] / 2);
    }
    
    // Initialize graph
    memset(graph_size, 0, sizeof(graph_size));
    k_global = k;
    memcpy(coins, coinsArray, n * sizeof(int));
    
    // Build adjacency list
    for (int i = 0; i < edge_count; i++) {
        int a = edges[i][0];
        int b = edges[i][1];
        graph[a][graph_size[a]++] = b;
        graph[b][graph_size[b]++] = a;
    }
    
    return dfs(0, -1, n, 0);
}

int main() {
    char line[10000];
    
    // Read edges
    fgets(line, sizeof(line), stdin);
    int edges[MAX_N][2];
    int edge_count = 0;
    
    // Parse edges from JSON-like format
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') {
        ptr++;
        while (*ptr && *ptr != ']') {
            if (*ptr == '[') {
                ptr++;
                int a = 0, b = 0;
                while (*ptr >= '0' && *ptr <= '9') {
                    a = a * 10 + (*ptr - '0');
                    ptr++;
                }
                while (*ptr && *ptr != ',' && (*ptr < '0' || *ptr > '9')) ptr++;
                if (*ptr == ',') ptr++;
                while (*ptr && (*ptr < '0' || *ptr > '9')) ptr++;
                while (*ptr >= '0' && *ptr <= '9') {
                    b = b * 10 + (*ptr - '0');
                    ptr++;
                }
                edges[edge_count][0] = a;
                edges[edge_count][1] = b;
                edge_count++;
                while (*ptr && *ptr != ']' && *ptr != '[') ptr++;
                if (*ptr == ']') ptr++;
            } else {
                ptr++;
            }
        }
    }
    
    // Read coins
    fgets(line, sizeof(line), stdin);
    int coinsArray[MAX_N];
    int n = 0;
    
    // Parse coins from JSON-like format
    ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') {
        ptr++;
        while (*ptr && *ptr != ']') {
            if (*ptr >= '0' && *ptr <= '9') {
                int coin = 0;
                while (*ptr >= '0' && *ptr <= '9') {
                    coin = coin * 10 + (*ptr - '0');
                    ptr++;
                }
                coinsArray[n++] = coin;
            }
            ptr++;
        }
    }
    
    // Read k
    fgets(line, sizeof(line), stdin);
    int k = atoi(line);
    
    printf("%d\n", solution(edges, edge_count, coinsArray, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each node has 2 choices, leading to 2^n combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion call stack depth equals tree height

⚡ Linearithmic Space

30.3K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler