Distribute Coins in Binary Tree - Practice Coding Problems

Distribute Coins in Binary Tree - Problem

Distribute Coins in Binary Tree

You are given the root of a binary tree with n nodes where each node contains node.val coins. The total number of coins in the entire tree equals exactly n (the number of nodes).

In one move, you can transfer one coin between two adjacent nodes (parent-child or child-parent). Your goal is to redistribute the coins so that every node has exactly one coin.

Return the minimum number of moves required to achieve this balanced distribution.

Example: If a node has 3 coins and needs only 1, it must give away 2 coins. If a node has 0 coins, it needs to receive 1 coin from a neighbor.

Key insight: This is a classic tree rebalancing problem where we need to calculate the flow of excess/deficit coins through each edge.

Input & Output

example_1.py — Basic Tree

$ Input: [3, 0, 0]

› Output: 2

💡 Note: The root has 3 coins but needs only 1. Both children have 0 coins but need 1 each. So we move 1 coin from root to left child and 1 coin from root to right child. Total moves = 2.

example_2.py — Unbalanced Tree

$ Input: [0, 3, 0]

› Output: 3

💡 Note: Left child has 3 coins but needs only 1, so it has 2 excess. Root and right child each need 1 coin. We move 1 coin from left child to root (1 move), then 1 coin from root to right child (1 move), and 1 more coin from left child through root to right child (1 more move through root). Total = 3 moves.

example_3.py — Single Node

$ Input: [1]

› Output: 0

💡 Note: The tree has only one node with exactly 1 coin, which is already the target state. No moves are needed.

Visualization

Tap to expand

Understanding the Visualization

Identify Imbalances

Mark nodes with excess coins (red) and nodes needing coins (green)

Calculate Subtree Needs

Each subtree calculates total excess or deficit

Flow Through Edges

Coins flow from excess areas to deficit areas through tree edges

Count Total Flow

Sum absolute values of flow through all edges

Key Takeaway

🎯 Key Insight: Every coin that moves passes through exactly one edge in the tree. By calculating the net flow through each edge using post-order DFS, we can count the minimum moves in a single traversal.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n nodes in the tree

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(log n) for balanced tree, O(n) worst case

✓ Linear Space

Constraints

The number of nodes in the tree is n
1 ≤ n ≤ 100
0 ≤ Node.val ≤ n
The sum of all Node.val is n
Each node initially has between 0 and n coins

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a single post-order DFS traversal where each subtree calculates its coin excess/deficit and reports to its parent. The key insight is that every coin that moves will pass through exactly one edge, so we count the absolute flow through each parent-child connection. Time: O(n), Space: O(h).

Common Approaches

Approach	Time	Space	Notes
✓ Post-order DFS (Optimal)	O(n)	O(h)	Single post-order traversal calculating coin flow through each edge
Brute Force (Try All Sequences)	O(k^n)	O(n * depth)	Try all possible sequences of moves until balance is achieved

Post-order DFS (Optimal) — Algorithm Steps

Use post-order DFS to process children before parent
For each node, calculate excess = (coins in subtree) - (nodes in subtree)
Positive excess means subtree has extra coins to give to parent
Negative excess means subtree needs coins from parent
Add absolute value of excess to total moves (coins flowing through edge)
Return excess to parent for further calculation

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin post-order traversal from root

Process Leaves

Calculate excess/deficit for leaf nodes first

Flow Calculation

Each subtree reports its excess to parent

Count Moves

Add absolute flow value to total moves

Complete Tree

Process all nodes bottom-up to get final answer

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int moves = 0;

int dfs(struct TreeNode* node) {
    if (!node) return 0;
    
    // Post-order: process children first
    int leftExcess = dfs(node->left);
    int rightExcess = dfs(node->right);
    
    // Add absolute flow through edges to total moves
    moves += abs(leftExcess) + abs(rightExcess);
    
    // Calculate this subtree's excess/deficit
    // excess = (coins in subtree) - (nodes in subtree)
    int subtreeExcess = node->val + leftExcess + rightExcess - 1;
    
    return subtreeExcess;
}

int distributeCoins(struct TreeNode* root) {
    moves = 0;
    dfs(root);
    return moves;
}

// Create a new tree node
struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int main() {
    // Example: create tree [3,0,0]
    struct TreeNode* root = createNode(3);
    root->left = createNode(0);
    root->right = createNode(0);
    
    printf("%d\n", distributeCoins(root));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n nodes in the tree

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(log n) for balanced tree, O(n) worst case

✓ Linear Space

Constraints

The number of nodes in the tree is n
1 ≤ n ≤ 100
0 ≤ Node.val ≤ n
The sum of all Node.val is n
Each node initially has between 0 and n coins

89.5K Views

Medium Frequency

~15 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Post-order DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler