Make Costs of Paths Equal in a Binary Tree

Make Costs of Paths Equal in a Binary Tree - Problem

Make Costs of Paths Equal in a Binary Tree

You're given a perfect binary tree with n nodes numbered from 1 to n, where node 1 is the root. In this tree structure, each node i has:
• Left child: 2 * i
• Right child: 2 * i + 1

Each node has an associated cost given by a 0-indexed array cost where cost[i] represents the cost of node i + 1.

🎯 Your Goal: Make all root-to-leaf path costs equal by incrementing any node's cost by 1 (as many times as needed).

📊 Return: The minimum number of increments needed.

Note: A perfect binary tree means every internal node has exactly 2 children, and all leaves are at the same level.

Input & Output

example_1.py — Small Perfect Tree

$ Input: n = 7, cost = [1,5,2,2,3,3,1]

› Output: 6

💡 Note: Tree structure: 1(cost=1) -> 2(cost=5), 3(cost=2) -> leaves 4,5,6,7 with costs [2,3,3,1]. Path costs initially: 1+5+2=8, 1+5+3=9, 1+2+3=6, 1+2+1=4. Maximum is 9, so we need 1+3=4 increments to make all paths cost 9.

example_2.py — Balanced Costs

$ Input: n = 3, cost = [5,3,3]

› Output: 0

💡 Note: Tree has root 1(cost=5) with leaves 2(cost=3) and 3(cost=3). Path costs: 5+3=8 and 5+3=8. Already equal, so 0 increments needed.

example_3.py — Single Level Tree

$ Input: n = 1, cost = [1]

› Output: 0

💡 Note: Only one node (root), so only one path with cost 1. No increments needed.

Constraints

3 ≤ n ≤ 10⁵
n is odd (perfect binary tree property)
1 ≤ cost[i] ≤ 10⁴
cost.length == n

Visualization

Tap to expand

Understanding the Visualization

Identify Trail Junctions

Start from the junctions closest to the peaks (bottom-up)

Balance Each Junction

At each junction, make both paths equally difficult by adding training stations to the easier path

Propagate Upward

The balanced cost becomes the new cost for that junction

Continue to Base

Repeat until you reach the base camp (root)

Key Takeaway

🎯 Key Insight: The greedy bottom-up approach works because at each junction, matching the cheaper path to the expensive one minimizes total increments while ensuring all final paths are equal.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a bottom-up greedy approach. Process internal nodes from bottom to top, ensuring both children have equal maximum costs by incrementing the cheaper child. This greedy choice is always optimal and runs in O(n) time with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recursive DFS)	O(n²)	O(h)	Calculate all path costs and increment nodes until all paths are equal
Bottom-Up Greedy (Optimal)	O(n)	O(1)	Work from leaves upward, making greedy optimal choices at each internal node

Brute Force (Recursive DFS) — Algorithm Steps

Calculate costs of all root-to-leaf paths
Find the maximum path cost (target cost)
For each path with cost less than target, increment nodes along the path
Repeat until all paths have equal cost

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All Paths

Traverse tree to find all root-to-leaf paths

Calculate Costs

Sum costs along each path

Find Maximum

Identify the highest path cost

Increment Nodes

Add costs to make all paths equal to maximum

Code -

solution.c — C

int minIncrements(int n, int* cost, int costSize) {
    int paths[1000][20];  // Assuming max 1000 paths, max depth 20
    int pathCosts[1000];
    int pathLengths[1000];
    int numPaths = 0;
    
    void dfs(int node, int* path, int pathLen, int pathCost) {
        if (node > n) return;
        
        int newCost = pathCost + cost[node - 1];
        path[pathLen] = node;
        
        if (2 * node > n) {
            // Leaf node - save path
            for (int i = 0; i <= pathLen; i++) {
                paths[numPaths][i] = path[i];
            }
            pathCosts[numPaths] = newCost;
            pathLengths[numPaths] = pathLen + 1;
            numPaths++;
            return;
        }
        
        dfs(2 * node, path, pathLen + 1, newCost);
        dfs(2 * node + 1, path, pathLen + 1, newCost);
    }
    
    int path[20];
    dfs(1, path, 0, 0);
    
    int maxCost = 0;
    for (int i = 0; i < numPaths; i++) {
        if (pathCosts[i] > maxCost) {
            maxCost = pathCosts[i];
        }
    }
    
    int increments = 0;
    for (int i = 0; i < numPaths; i++) {
        if (pathCosts[i] < maxCost) {
            int diff = maxCost - pathCosts[i];
            int leafNode = paths[i][pathLengths[i] - 1];
            cost[leafNode - 1] += diff;
            increments += diff;
        }
    }
    
    return increments;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We traverse the tree O(n) times to find all paths, then potentially make O(n) increments

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion depth equals tree height h = log(n) for perfect binary tree

✓ Linear Space

34.2K Views

Medium Frequency

~18 min Avg. Time

1.4K 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 (Recursive DFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler