Minimum Increments to Equalize Leaf Paths

Minimum Increments to Equalize Leaf Paths - Problem

Tree Path Balancing Challenge

Imagine you're a park designer tasked with creating a fair hiking trail system! You have a tree-structured network of trails rooted at the main entrance (node 0), where each trail segment has a difficulty cost.

The problem: hikers complain that some paths from the entrance to scenic viewpoints (leaf nodes) are much easier than others. Your job is to increase the difficulty of certain trail segments so that every path from the entrance to any viewpoint has the same total difficulty score.

You can only increase the cost of trail segments (you can't make them easier), and you want to modify the minimum number of segments possible to keep costs down.

Goal: Return the minimum number of nodes whose cost must be increased to make all root-to-leaf path scores equal.

Example: If one path has score 10 and another has score 15, you need to increase costs along the first path by 5 to equalize them.

Input & Output

example_1.py — Basic Tree

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

› Output: 8

💡 Note: Tree has paths: 0→1→3 (sum=10), 0→1→4 (sum=14), 0→2→5 (sum=10). To equalize all paths to sum 14, we need 8 total increments: 4 increments for path 0→1→3 and 4 increments for path 0→2→5.

example_2.py — Already Balanced

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

› Output: 0

💡 Note: Both paths 0→1 (sum=3) and 0→2 (sum=3) already have equal sums, so no increments are needed.

example_3.py — Single Node

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

› Output: 0

💡 Note: Single node tree has only one 'path' with sum=5. No other paths to balance, so 0 increments needed.

Visualization

Tap to expand

Understanding the Visualization

Build Tree Structure

Convert edge list into adjacency list representation for easy traversal

DFS from Root

Start depth-first search from root node, processing children before parents

Calculate Child Maximums

For each internal node, find the maximum path sum among all child subtrees

Balance Subtrees

Add increments equal to the difference between max child sum and other child sums

Return Balanced Sum

Each node returns its cost plus the balanced maximum child sum upward

Key Takeaway

🎯 Key Insight: By processing the tree bottom-up, we can balance all subtrees locally at each internal node, ensuring global path equality with minimum increments in just one traversal!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal visits each node exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, which is O(log n) for balanced trees

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
edges.length == n - 1
0 ≤ u_i, v_i < n
1 ≤ cost[i] ≤ 10⁴
The input represents a valid tree (connected and acyclic)

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22

The optimal solution uses single DFS traversal with a bottom-up approach. For each internal node, we calculate the maximum path sum among all child subtrees and increment the count by the difference needed to balance weaker subtrees. This ensures all root-to-leaf paths have equal sums while minimizing the number of increments in O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple DFS)	O(n²)	O(n²)	Find all leaf paths, calculate max score, then greedily increment nodes
Single DFS (Optimal)	O(n)	O(h)	Solve in one bottom-up DFS traversal by balancing subtrees at each node

Brute Force (Multiple DFS) — Algorithm Steps

Find all root-to-leaf paths using DFS
Calculate the score of each path
Determine the target score (maximum among all paths)
For each path with score less than target, increment nodes along the path
Count total number of nodes that were incremented

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All Paths

DFS from root to enumerate all root-to-leaf paths

Calculate Scores

Sum up costs along each path to get path scores

Find Maximum

Determine the target score (maximum among all paths)

Increment Nodes

For each path below target, increment nodes to reach target score

Code -

solution.c — C

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

#define MAX_N 1000

int graph[MAX_N][MAX_N];
int graphSize[MAX_N];
int cost[MAX_N];
int paths[MAX_N][MAX_N];
int pathScores[MAX_N];
int pathSizes[MAX_N];
int numPaths = 0;

void dfs(int node, int parent, int* path, int pathLen, int score, int n) {
    path[pathLen] = node;
    score += cost[node];
    pathLen++;
    
    bool isLeaf = true;
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (neighbor != parent) {
            isLeaf = false;
            int newPath[MAX_N];
            for (int j = 0; j < pathLen; j++) {
                newPath[j] = path[j];
            }
            dfs(neighbor, node, newPath, pathLen, score, n);
        }
    }
    
    if (isLeaf) {
        for (int i = 0; i < pathLen; i++) {
            paths[numPaths][i] = path[i];
        }
        pathSizes[numPaths] = pathLen;
        pathScores[numPaths] = score;
        numPaths++;
    }
}

int minIncrements(int n, int edges[][2], int* costs) {
    // Initialize
    for (int i = 0; i < n; i++) {
        graphSize[i] = 0;
        cost[i] = costs[i];
    }
    
    // Build graph
    for (int i = 0; i < n-1; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    int path[MAX_N];
    dfs(0, -1, path, 0, 0, n);
    
    int maxScore = 0;
    for (int i = 0; i < numPaths; i++) {
        if (pathScores[i] > maxScore) {
            maxScore = pathScores[i];
        }
    }
    
    bool nodesToIncrement[MAX_N] = {false};
    for (int i = 0; i < numPaths; i++) {
        if (pathScores[i] < maxScore) {
            int deficit = maxScore - pathScores[i];
            for (int j = pathSizes[i] - 1; j >= 0 && deficit > 0; j--) {
                nodesToIncrement[paths[i][j]] = true;
                deficit--;
            }
        }
    }
    
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (nodesToIncrement[i]) count++;
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We traverse each path multiple times - once to find it, once to calculate score, and once to update

⚠ Quadratic Growth

Space Complexity

O(n²)

Storing all paths explicitly can take O(n²) space in worst case (skewed tree)

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 10⁵
edges.length == n - 1
0 ≤ u_i, v_i < n
1 ≤ cost[i] ≤ 10⁴
The input represents a valid tree (connected and acyclic)

42.8K Views

Medium Frequency

~25 min Avg. Time

1.1K 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

Brute Force (Multiple DFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler