Minimum Increments to Equalize Leaf Paths

Minimum Increments to Equalize Leaf Paths - Problem

You are given an integer n and an undirected tree rooted at node 0 with n nodes numbered from 0 to n - 1. This is represented by a 2D array edges of length n - 1, where edges[i] = [u_i, v_i] indicates an edge from node u_i to v_i.

Each node i has an associated cost given by cost[i], representing the cost to traverse that node. The score of a path is defined as the sum of the costs of all nodes along the path.

Your goal is to make the scores of all root-to-leaf paths equal by increasing the cost of any number of nodes by any non-negative amount. Return the minimum number of nodes whose cost must be increased to make all root-to-leaf path scores equal.

Input & Output

Example 1 — Basic Tree

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

› Output: 2

💡 Note: Tree has paths: 0→1→2 (sum=6), 0→1→3 (sum=7), 0→4 (sum=6). Maximum sum is 7, so paths to nodes 2 and 4 need increments.

Example 2 — Balanced Tree

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

› Output: 0

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

Example 3 — Single Node

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

› Output: 0

💡 Note: Only one node, no paths to equalize.

Constraints

1 ≤ n ≤ 10⁵
edges.length == n - 1
0 ≤ u_i, v_i ≤ n - 1
1 ≤ cost[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to use DFS to calculate maximum path sums in each subtree and count nodes that need increments during traversal. The optimal approach uses bottom-up DFS in O(n) time and O(n) space.

Common Approaches

✓ Brute Force Path Enumeration

⏱️ Time: O(n²) Space: O(n²)

First enumerate all possible root-to-leaf paths in the tree. Calculate the sum for each path to find the maximum sum. Then for each path that has a sum less than the maximum, increment nodes along that path to match the maximum sum.

Optimized DFS with Path Tracking

⏱️ Time: O(n) Space: O(n)

Use a single DFS traversal to calculate the maximum path sum from each subtree. During the traversal, determine which nodes need increments to equalize all paths. This avoids storing all paths explicitly.

Brute Force Path Enumeration — Algorithm Steps

Step 1: Build adjacency list from edges
Step 2: Use DFS to find all root-to-leaf paths
Step 3: Calculate sum for each path and find maximum
Step 4: For each path with sum < max, increment nodes to match

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Tree

Create adjacency list from edges

Find Paths

DFS to enumerate all root-to-leaf paths

Calculate Sums

Sum costs for each path, find maximum

Mark Nodes

Mark all nodes on paths that need increments

Code -

solution.c — C

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

#define MAX_N 1000

int graph[MAX_N][MAX_N];
int graphSize[MAX_N];
int n;
int cost[MAX_N];

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

// Find max path sum in subtree rooted at node
int findMaxPathSum(int node, int parent) {
    int maxSum = cost[node];
    
    for (int i = 0; i < graphSize[node]; i++) {
        int child = graph[node][i];
        if (child != parent) {
            int childMax = findMaxPathSum(child, node);
            maxSum = max(maxSum, cost[node] + childMax);
        }
    }
    
    return maxSum;
}

// Brute force path enumeration: for each node, enumerate all child subtrees
int bruteForceEnumeration(int node, int parent) {
    // Enumerate all children and their max path sums
    int childMaxPaths[MAX_N];
    int children[MAX_N];
    int childCount = 0;
    
    for (int i = 0; i < graphSize[node]; i++) {
        int child = graph[node][i];
        if (child != parent) {
            children[childCount] = child;
            int childMaxPath = findMaxPathSum(child, node);
            childMaxPaths[childCount] = childMaxPath;
            childCount++;
        }
    }
    
    // If no children, return 0
    if (childCount == 0) {
        return 0;
    }
    
    // Find maximum among all children
    int maxChildPath = childMaxPaths[0];
    for (int i = 1; i < childCount; i++) {
        if (childMaxPaths[i] > maxChildPath) {
            maxChildPath = childMaxPaths[i];
        }
    }
    
    // Count how many children have max path < global max
    int incrementsAtThisNode = 0;
    for (int i = 0; i < childCount; i++) {
        if (childMaxPaths[i] < maxChildPath) {
            incrementsAtThisNode++;
        }
    }
    
    // Recursively process all children
    int totalIncrements = incrementsAtThisNode;
    for (int i = 0; i < childCount; i++) {
        totalIncrements += bruteForceEnumeration(children[i], node);
    }
    
    return totalIncrements;
}

int solution(int numNodes, int edges[][2], int edgeCount, int costArr[]) {
    n = numNodes;
    if (n == 1) return 0;
    
    for (int i = 0; i < n; i++) {
        graphSize[i] = 0;
        cost[i] = costArr[i];
    }
    
    for (int i = 0; i < edgeCount; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    return bruteForceEnumeration(0, -1);
}

int main() {
    int n;
    scanf("%d", &n);
    
    int edges[MAX_N][2];
    int edgeCount = n - 1;
    char line[10000];
    fgets(line, sizeof(line), stdin); // consume newline
    fgets(line, sizeof(line), stdin);
    
    int edgeIdx = 0;
    for (int i = 0; line[i] && edgeIdx < edgeCount; i++) {
        if (line[i] == '[' && i + 1 < strlen(line) && line[i+1] >= '0' && line[i+1] <= '9') {
            i++;
            
            int num1 = 0;
            while (i < strlen(line) && line[i] >= '0' && line[i] <= '9') {
                num1 = num1 * 10 + (line[i] - '0');
                i++;
            }
            
            while (i < strlen(line) && (line[i] == ',' || line[i] == ' ')) i++;
            
            int num2 = 0;
            while (i < strlen(line) && line[i] >= '0' && line[i] <= '9') {
                num2 = num2 * 10 + (line[i] - '0');
                i++;
            }
            
            edges[edgeIdx][0] = num1;
            edges[edgeIdx][1] = num2;
            edgeIdx++;
        }
    }
    
    int costArr[MAX_N];
    fgets(line, sizeof(line), stdin);
    
    int costIdx = 0;
    for (int i = 0; line[i] && costIdx < n; i++) {
        if (line[i] >= '0' && line[i] <= '9') {
            int num = 0;
            while (i < strlen(line) && line[i] >= '0' && line[i] <= '9') {
                num = num * 10 + (line[i] - '0');
                i++;
            }
            costArr[costIdx++] = num;
            i--;
        }
    }
    
    printf("%d\n", solution(n, edges, edgeCount, costArr));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

DFS to find all paths takes O(n), and we may have O(n) paths, each requiring O(n) operations

⚠ Quadratic Growth

Space Complexity

O(n²)

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

⚠ Quadratic Space

58.0K Views

Medium Frequency

~25 min Avg. Time

1.5K 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 Path Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler