Collect Coins in a Tree - Practice Coding Problems

Collect Coins in a Tree - Problem

🌳 Collect Coins in a Tree

Imagine you're a treasure hunter exploring a mystical tree-shaped network of caves. Each cave (node) may contain a magical coin, and you can collect all coins within a distance of 2 from your current position without moving!

You start at any cave of your choice and can perform two operations:

Collect: Gather all coins within distance ≤ 2 from your current cave
Move: Travel to any directly connected cave (costs 1 edge traversal)

Your mission: Find the minimum number of edges you need to traverse to collect all coins and return to your starting cave. Remember, each edge traversal counts separately - if you pass through the same edge multiple times, count it each time!

Input: An integer n (number of caves), a 2D array edges defining the tree structure, and a binary array coins where coins[i] = 1 means cave i contains a coin.

Output: Return the minimum number of edge traversals needed.

Input & Output

example_1.py — Basic Tree

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

› Output: 0

💡 Note: We can start at node 1 and collect the coin at node 0 (distance 1 ≤ 2) without moving. Since node 0 is the only coin, we're done and don't need to move at all.

example_2.py — Linear Chain

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

› Output: 2

💡 Note: Start at node 1. Collect coin from node 0 (distance 1). Move to node 2 (1 edge), then collect coin from node 3 (distance 1). Return to node 1 (1 edge). Total: 2 edges.

example_3.py — All Coins

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

› Output: 0

💡 Note: From either starting node, we can collect both coins since they're within distance 2 of each other. No movement needed.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all nodes and edges for trimming operations

✓ Linear Growth

Space Complexity

O(n)

Space for adjacency list and degree arrays

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 3 × 10⁴
coins.length == n
coins[i] is either 0 or 1
edges.length == n - 1
edges[i].length == 2
0 ≤ a_i, b_i < n
a_i ≠ b_i
The edges represent a valid tree structure
There is at least one coin in the tree

Asked in

The optimal solution uses tree trimming with topological sorting. First, remove all leaf nodes without coins. Then remove two more layers of leaf nodes (since coins within distance 2 can be collected remotely). The remaining tree represents the minimal path needed. Answer is 2 × (remaining_edges) since we traverse each essential edge twice.

Common Approaches

Approach	Time	Space	Notes
✓ Tree Trimming (Optimal Approach)	O(n)	O(n)	Remove unnecessary leaf nodes iteratively, then traverse the minimal required tree

Tree Trimming (Optimal Approach) — Algorithm Steps

Build adjacency list and calculate degrees for all nodes
First trimming: Remove leaf nodes without coins until no more can be removed
Second trimming: Remove leaf nodes that are within distance 1 of coins (can be collected remotely)
The remaining nodes form the minimal tree we must traverse
Answer is 2 * (remaining edges) since we traverse each edge twice

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Tree

Start with the complete tree structure

First Trim

Remove leaf nodes without coins

Second Trim

Remove nodes within distance 1 of coins

Result

Remaining nodes form minimal required tree

Code -

solution.c — C

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

#define MAX_N 30000

int adj[MAX_N][MAX_N];
int degree[MAX_N];
int coins[MAX_N];
int queue[MAX_N];
int front, rear;

void enqueue(int x) {
    queue[rear++] = x;
}

int dequeue() {
    return queue[front++];
}

int isEmpty() {
    return front >= rear;
}

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

int collectTheCoins(int n, int edges[][2], int edgeCount) {
    if (n <= 1) return 0;
    if (n == 2) return 0;
    
    // Initialize
    memset(degree, 0, sizeof(degree));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < MAX_N; j++) {
            adj[i][j] = -1;
        }
    }
    
    // Build adjacency list
    for (int i = 0; i < edgeCount; i++) {
        int u = edges[i][0], v = edges[i][1];
        adj[u][degree[u]++] = v;
        adj[v][degree[v]++] = u;
    }
    
    // First trimming: remove leaves without coins
    front = rear = 0;
    for (int i = 0; i < n; i++) {
        if (degree[i] == 1 && coins[i] == 0) {
            enqueue(i);
        }
    }
    
    int remaining = n;
    while (!isEmpty()) {
        int node = dequeue();
        remaining--;
        
        for (int i = 0; i < MAX_N && adj[node][i] != -1; i++) {
            int neighbor = adj[node][i];
            degree[neighbor]--;
            if (degree[neighbor] == 1 && coins[neighbor] == 0) {
                enqueue(neighbor);
            }
        }
    }
    
    // Second trimming: remove leaves
    front = rear = 0;
    for (int i = 0; i < n; i++) {
        if (degree[i] == 1) {
            enqueue(i);
        }
    }
    
    for (int layer = 0; layer < 2; layer++) {
        int size = rear - front;
        if (size == 0) break;
        
        int newRear = front;
        for (int i = 0; i < size; i++) {
            int node = dequeue();
            remaining--;
            
            for (int j = 0; j < MAX_N && adj[node][j] != -1; j++) {
                int neighbor = adj[node][j];
                degree[neighbor]--;
                if (degree[neighbor] == 1) {
                    queue[newRear++] = neighbor;
                }
            }
        }
        rear = newRear;
    }
    
    return max(0, 2 * (remaining - 1));
}

int main() {
    int n;
    scanf("%d", &n);
    
    for (int i = 0; i < n; i++) {
        scanf("%d", &coins[i]);
    }
    
    int edges[MAX_N][2];
    for (int i = 0; i < n - 1; i++) {
        scanf("%d %d", &edges[i][0], &edges[i][1]);
    }
    
    printf("%d\n", collectTheCoins(n, edges, n - 1));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all nodes and edges for trimming operations

✓ Linear Growth

Space Complexity

O(n)

Space for adjacency list and degree arrays

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 3 × 10⁴
coins.length == n
coins[i] is either 0 or 1
edges.length == n - 1
edges[i].length == 2
0 ≤ a_i, b_i < n
a_i ≠ b_i
The edges represent a valid tree structure
There is at least one coin in the tree

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

🌳 Collect Coins in a Tree

Input & Output

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Tree Trimming (Optimal Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler