Heavy-Light Decomposition - Problem

Implement heavy-light decomposition on a tree to answer path queries efficiently in O(log² n) time complexity.

Given a tree with n nodes, you need to:

1. Build the heavy-light decomposition structure

2. Handle path queries from node u to node v

3. Return the sum of values along the path

The tree is represented as an adjacency list where edges[i] = [parent, child] indicates an edge between parent and child nodes. Node values are given in the values array where values[i] is the value of node i.

Path Query: Find the sum of all node values from node u to node v in the tree.

Input & Output

Example 1 — Simple Path Query

$ Input: edges = [[0,1],[1,2],[1,3],[3,4]], values = [1,2,3,4,5], u = 0, v = 4

› Output: 12

💡 Note: Path from node 0 to node 4: 0 → 1 → 3 → 4. Sum = values[0] + values[1] + values[3] + values[4] = 1 + 2 + 4 + 5 = 12

Example 2 — Different Path

$ Input: edges = [[0,1],[1,2],[1,3]], values = [5,10,15,20], u = 2, v = 3

› Output: 45

💡 Note: Path from node 2 to node 3: 2 → 1 → 3. Sum = values[2] + values[1] + values[3] = 15 + 10 + 20 = 45

Example 3 — Single Node Path

$ Input: edges = [[0,1],[1,2]], values = [7,8,9], u = 1, v = 1

› Output: 8

💡 Note: Path from node 1 to itself contains only node 1. Sum = values[1] = 8

Constraints

2 ≤ n ≤ 10⁴
edges.length = n - 1
-10⁶ ≤ values[i] ≤ 10⁶
0 ≤ u, v < n

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8 M Microsoft 12 a Amazon 6

The key insight is to decompose the tree into heavy chains where each node connects to its largest subtree child via a heavy edge. This creates O(log n) chains, and any path can be split into O(log n) segments. Using segment trees on each chain enables O(log n) range queries, achieving O(log² n) total query time. Best approach is Heavy-Light Decomposition with Segment Trees. Time: O(log² n), Space: O(n log n)

Common Approaches

✓ Brute Force DFS Path Sum

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

For each query, use DFS to find the path from u to v via their lowest common ancestor (LCA), then sum all node values along this path. This involves finding LCA and traversing the path for every query.

Heavy-Light Decomposition with Segment Trees

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

Heavy-light decomposition divides the tree into 'heavy' and 'light' edges. Heavy edges connect a node to its largest subtree child. This creates at most O(log n) heavy chains, and any path can be decomposed into O(log n) segments on these chains, allowing segment tree queries.

Brute Force DFS Path Sum — Algorithm Steps

Find LCA of nodes u and v using DFS
Traverse path from u to LCA, collecting values
Traverse path from LCA to v, collecting values
Sum all collected values

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin DFS from node u, marking visited nodes

Explore Paths

Recursively explore all possible paths until finding node v

Sum Values

Once path is found, sum all node values along the path

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 path[MAX_N];
int pathSize;

int dfsPath(int start, int end, int parent, int n) {
    path[pathSize++] = start;
    if (start == end) {
        return 1;
    }
    
    for (int i = 0; i < graphSize[start]; i++) {
        int neighbor = graph[start][i];
        if (neighbor != parent) {
            if (dfsPath(neighbor, end, start, n)) {
                return 1;
            }
        }
    }
    
    pathSize--;
    return 0;
}

int solution(int edges[][2], int edgeCount, int values[], int n, int u, int v) {
    // Initialize graph
    for (int i = 0; i < n; i++) {
        graphSize[i] = 0;
    }
    
    // Build adjacency list
    for (int i = 0; i < edgeCount; i++) {
        int parent = edges[i][0], child = edges[i][1];
        graph[parent][graphSize[parent]++] = child;
        graph[child][graphSize[child]++] = parent;
    }
    
    // Find path using DFS
    pathSize = 0;
    dfsPath(u, v, -1, n);
    
    // Sum values along path
    int total = 0;
    for (int i = 0; i < pathSize; i++) {
        total += values[path[i]];
    }
    return total;
}

int main() {
    // Simple parsing - assume small input for demo
    int edges[10][2] = {{0,1}, {1,2}, {1,3}, {3,4}};
    int values[] = {1, 2, 3, 4, 5};
    int u = 0, v = 4;
    
    int result = solution(edges, 4, values, 5, u, v);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each query requires DFS traversal which can visit up to n nodes in worst case

⚡ Linearithmic

Space Complexity

O(n)

DFS recursion stack can go up to tree height, and path storage needs O(n) space

⚡ Linearithmic Space

8.9K Views

Low Frequency

~45 min Avg. Time

234 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

Heavy-Light Decomposition - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force DFS Path Sum — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler