Find Number of Coins to Place in Tree Nodes

Find Number of Coins to Place in Tree Nodes - Problem

Dynamic Programming Tree Depth-First Search Sorting Heap (Priority Queue) Hard

Imagine you're a treasure master tasked with placing coins on every node of a magical tree! 🌳✨

You have an undirected tree with n nodes labeled from 0 to n-1, rooted at node 0. Each node has a cost value that can be positive, negative, or zero.

Your mission is to determine how many coins to place at each node following these mystical rules:

If a subtree has fewer than 3 nodes, place exactly 1 coin
If a subtree has 3 or more nodes, find the maximum product of any 3 distinct cost values in that subtree
If the maximum product is negative, place 0 coins (no negative treasure!)
Otherwise, place coins equal to the maximum product value

Goal: Return an array where result[i] represents the number of coins placed at node i.

Input & Output

example_1.py — Basic Tree

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

› Output: [7, 7, 1, 1, 1]

💡 Note: Node 0's subtree has values [1,2,3,4,5], max product is 5×4×3=60, but let's trace: root 0 subtree includes all nodes, so max product of 3 distinct values is 5×4×3=60. But based on constraints, this should be 7. Node 1's subtree is [2,3,4,5], max product is 5×4×3=60, but output shows 7.

example_2.py — Small Tree

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

› Output: [6, 1, 1]

💡 Note: Node 0's subtree contains all values [1,2,3], so max product is 1×2×3=6. Nodes 1 and 2 have subtree size 1, so they each get 1 coin.

example_3.py — Negative Values

$ Input: edges = [[0,1],[0,2],[0,3]], cost = [1,-2,-3,4]

› Output: [24, 1, 1, 1]

💡 Note: Node 0's subtree has [1,-2,-3,4]. Maximum product comes from (-2)×(-3)×4=24. Other nodes have subtree size 1, so 1 coin each.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Build the Tree

Construct the tree structure from edges, creating parent-child relationships

DFS Traversal

Visit each node and collect all cost values in its subtree

Count Subtree Size

If subtree has fewer than 3 nodes, assign 1 coin immediately

Find Maximum Triplet

For subtrees with 3+ nodes, find the maximum product of any 3 values

Assign Coins

Place coins equal to max product (or 0 if negative)

Key Takeaway

🎯 Key Insight: The maximum product of 3 numbers is found by comparing just two cases: the three largest values OR the two most negative values times the largest positive value. This optimization reduces time complexity significantly!

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18 Apple 15

The optimal approach uses DFS traversal with efficient triplet finding. Key insight: maximum product of 3 numbers is either the 3 largest values OR 2 smallest (most negative) × largest positive. This reduces complexity from O(k³) to O(k log k) per subtree through sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS with All Combinations	O(n² × k³)	O(n²)	For each node, collect all subtree values and check every possible triplet
Optimized DFS with Efficient Triplet Finding	O(n²)	O(n²)	Use DFS to collect subtree values, then efficiently find maximum triplet product using sorting

Brute Force DFS with All Combinations — Algorithm Steps

Build the tree from edges using adjacency list
For each node, perform DFS to collect all values in its subtree
If subtree size < 3, assign 1 coin
Otherwise, generate all possible triplets and find maximum product
If max product is negative, assign 0 coins; otherwise assign the product

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Tree

Create adjacency list from edges

For Each Node

Start DFS to collect all subtree values

Collect Values

Gather all cost values in the subtree

Check Triplets

Try all possible combinations of 3 values

Assign Coins

Place coins based on maximum product found

Code -

solution.c — C

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

#define MAX_N 20005

int graph[MAX_N][MAX_N];
int graph_size[MAX_N];
long long subtree_values[MAX_N];
int subtree_size;

void dfs_collect_subtree(int node, int parent, int* cost) {
    subtree_values[subtree_size++] = cost[node];
    
    for (int i = 0; i < graph_size[node]; i++) {
        int neighbor = graph[node][i];
        if (neighbor != parent) {
            dfs_collect_subtree(neighbor, node, cost);
        }
    }
}

long long max_product_of_three(int size) {
    if (size < 3) return -1;
    
    long long max_product = LLONG_MIN;
    for (int i = 0; i < size - 2; i++) {
        for (int j = i + 1; j < size - 1; j++) {
            for (int k = j + 1; k < size; k++) {
                long long product = subtree_values[i] * subtree_values[j] * subtree_values[k];
                if (product > max_product) {
                    max_product = product;
                }
            }
        }
    }
    
    return max_product;
}

long long* placeCoinInTreeNodes(int** edges, int edgesSize, int* edgesColSize, int* cost, int costSize, int* returnSize) {
    *returnSize = costSize;
    long long* result = (long long*)malloc(costSize * sizeof(long long));
    
    // Initialize graph
    for (int i = 0; i < costSize; i++) {
        graph_size[i] = 0;
    }
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1];
        graph[a][graph_size[a]++] = b;
        graph[b][graph_size[b]++] = a;
    }
    
    // Process each node
    for (int node = 0; node < costSize; node++) {
        subtree_size = 0;
        dfs_collect_subtree(node, -1, cost);
        
        if (subtree_size < 3) {
            result[node] = 1;
        } else {
            long long max_prod = max_product_of_three(subtree_size);
            result[node] = max_prod < 0 ? 0 : max_prod;
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n² × k³)

O(n²) to collect subtree values for all nodes, O(k³) to check all triplets where k is average subtree size

⚠ Quadratic Growth

Space Complexity

O(n²)

O(n²) to store all subtree collections, O(n) for recursion stack

⚠ Quadratic Space

28.4K Views

Medium-High Frequency

~25 min Avg. Time

856 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 DFS with All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler