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

Maximum Points After Collecting Coins From All Nodes

Imagine you're a treasure hunter exploring an ancient tree-shaped dungeon! 🏴‍☠️

You're given an undirected tree with n nodes (labeled 0 to n-1), rooted at node 0. The tree structure is defined by a 2D array edges where edges[i] = [ai, bi] represents a connection between nodes ai and bi.

Each node contains a treasure chest with coins[i] coins, and you have a magical parameter k. Here's the catch: you can only collect coins from a node after collecting from all its ancestors!

When collecting coins from node i, you have two magical choices:
1. Direct Collection: Get coins[i] - k points (can be negative!)
2. Halving Spell: Get floor(coins[i] / 2) points, but this spell affects the entire subtree - all coins in nodes below get halved too!

Goal: Return the maximum points you can collect from all nodes in the tree.

Input & Output

example_1.py — Basic Tree

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

› Output: 7

💡 Note: At node 0: direct collection gives 1-2=-1. At node 1: halving gives 4//2=2 and halves subtree. Node 2 becomes 2//2=1, node 3 becomes 3//2=1. Collecting: 1-2=-1 + 2 + (1-2) + (1-2) = -1+2-1-1 = -1. Better: Use halving at root level strategically to maximize total points = 7.

example_2.py — Single Node

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

› Output: 7

💡 Note: Only one node. Direct collection: 10-3=7. Halving: 10//2=5. Direct collection is better, so answer is 7.

example_3.py — Large K Value

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

› Output: -2

💡 Note: Node 0: direct=2-5=-3, halving=2//2=1. Node 1: direct=1-5=-4, halving=1//2=0. If we halve at node 0, node 1 becomes 1//2=0, so halving at node 1 gives 0. Best strategy gives -2 total points.

Constraints

n == coins.length
1 ≤ n ≤ 2 × 10⁴
0 ≤ coins[i] ≤ 10⁴
edges.length == n - 1
edges[i].length == 2
0 ≤ a_i, b_i < n
0 ≤ k ≤ 10⁴
The input represents a valid tree

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Begin at the root node (treasure chamber entrance). You must decide: direct collection or halving spell?

Decision Impact

Direct collection gets coins[i]-k points. Halving spell gets coins[i]/2 but halves all treasures in the subtree.

Recursive Choices

Continue this decision process for every node in the tree, considering the cumulative effect of previous halving spells.

Memoization

Cache results for (node, halving_count) pairs since the same subtree state can be reached multiple ways.

Key Takeaway

🎯 Key Insight: The halving operation can only be applied a limited number of times (≤14) before all coin values become 0, making memoization highly effective with bounded state space.

Asked in

G Google 42 f Meta 38 a Amazon 35 ⊞ Microsoft 29

The optimal approach uses Dynamic Programming with Memoization during DFS traversal. Key insight: halving can only happen ≤14 times before coins become 0, so we can memoize states based on (node, halving_count). For each node, we try both direct collection (coins[i] - k) and halving spell (coins[i] / 2), choosing the maximum. The halving spell affects the entire subtree, which we handle by incrementing the halving count for child nodes. Time complexity: O(n × 14).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(n × 14)	O(n × 14)	Use DFS with memoization, tracking halving count to avoid recomputation
Brute Force (Try All Combinations)	O(2^n)	O(n)	Try all 2^n possible combinations of direct vs halving choices

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Build adjacency list from edges
Use DFS with memoization on (node, halving_count) states
For each node, try direct collection vs halving spell
Memoize results to avoid recomputing same subtree states
Return maximum points from root with 0 initial halvings

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Memoization

Create memo table for (node, halving_count) states

DFS Traversal

Perform DFS, checking memo before computing

Cache Results

Store computed results to avoid future recalculation

Limited States

Only ≤14 halving levels possible due to value constraints

Code -

solution.c — C

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

#define MAX_N 100000
#define MAX_HALVING 14

int adj[MAX_N][MAX_N];
int adjCount[MAX_N];
int memo[MAX_N][MAX_HALVING + 1];
int memoized[MAX_N][MAX_HALVING + 1];
int* coins;
int k;

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

int dfs(int node, int parent, int halvingCount) {
    if (memoized[node][halvingCount]) {
        return memo[node][halvingCount];
    }
    
    // Current coin value after halvingCount halvings
    int currentValue = coins[node] >> halvingCount;
    
    // Option 1: Direct collection
    int points1 = currentValue - k;
    for (int i = 0; i < adjCount[node]; i++) {
        int child = adj[node][i];
        if (child != parent) {
            points1 += dfs(child, node, halvingCount);
        }
    }
    
    // Option 2: Halving spell
    int points2 = currentValue / 2;
    if (halvingCount < MAX_HALVING) {
        for (int i = 0; i < adjCount[node]; i++) {
            int child = adj[node][i];
            if (child != parent) {
                points2 += dfs(child, node, halvingCount + 1);
            }
        }
    }
    
    int result = max(points1, points2);
    memo[node][halvingCount] = result;
    memoized[node][halvingCount] = 1;
    return result;
}

int maximumPoints(int** edges, int edgesSize, int* coinsArr, int n, int kVal) {
    coins = coinsArr;
    k = kVal;
    
    if (n == 1) {
        return max(coins[0] - k, coins[0] / 2);
    }
    
    // Initialize
    memset(adjCount, 0, sizeof(adjCount));
    memset(memoized, 0, sizeof(memoized));
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0];
        int b = edges[i][1];
        adj[a][adjCount[a]++] = b;
        adj[b][adjCount[b]++] = a;
    }
    
    return dfs(0, -1, 0);
}

int main() {
    // Parse input and solve
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 14)

Each node can be visited at most 14 times (halving limit), so total states are bounded

✓ Linear Growth

Space Complexity

O(n × 14)

Memoization table stores results for each (node, halving_count) pair

⚡ Linearithmic Space

54.0K Views

Medium Frequency

~35 min Avg. Time

1.8K 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 with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler