Centroid Decomposition - Problem

Centroid decomposition is a powerful technique used to analyze tree structures by recursively finding and removing centroids. A centroid of a tree is a node whose removal results in no subtree having more than n/2 nodes, where n is the total number of nodes.

Given a tree with n nodes (numbered from 0 to n-1) represented as an edge list, perform centroid decomposition and use it to efficiently answer distance queries between pairs of nodes.

Your task is to:

Build the centroid decomposition tree
Preprocess distances from each centroid to all nodes in its subtree
Answer distance queries in O(log n) time

Input: An array of edges representing the tree, followed by an array of query pairs.

Output: An array containing the shortest distance between each queried pair of nodes.

Input & Output

Example 1 — Basic Linear Tree

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

› Output: [3,1]

💡 Note: For query (0,3): path 0→1→2→3 has distance 3. For query (1,2): direct edge 1→2 has distance 1.

Example 2 — Star Tree

$ Input: edges = [[1,0],[1,2],[1,3],[1,4]], queries = [[0,4],[2,3]]

› Output: [2,2]

💡 Note: For query (0,4): path 0→1→4 has distance 2. For query (2,3): path 2→1→3 has distance 2.

Example 3 — Same Node Query

$ Input: edges = [[0,1],[1,2]], queries = [[1,1],[0,2]]

› Output: [0,2]

💡 Note: Query (1,1): same node has distance 0. Query (0,2): path 0→1→2 has distance 2.

Constraints

1 ≤ n ≤ 10⁴
edges.length = n - 1
0 ≤ edges[i][0], edges[i][1] < n
1 ≤ queries.length ≤ 10⁴
0 ≤ queries[i][0], queries[i][1] < n

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 a Amazon 15 M Microsoft 12

The key insight is that centroid decomposition creates a balanced tree structure where any path query can be answered in O(log n) time by finding the lowest common ancestor in the centroid tree. Best approach is centroid decomposition with distance preprocessing. Time: O(n log n + q log n), Space: O(n log n)

Common Approaches

✓ Brute Force BFS/DFS

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

Build the tree from edges, then for every distance query, run a breadth-first search or depth-first search from the source node until we reach the target node.

Centroid Decomposition

⏱️ Time: O(n log n + q log n) Space: O(n log n)

Recursively find centroids to decompose the tree into a logarithmic-height structure. Precompute distances from each centroid to all nodes in its subtree for fast query answering.

Brute Force BFS/DFS — Algorithm Steps

Build adjacency list from edges
For each query (u,v), run BFS from u
Count levels until reaching v
Return distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from edges

BFS Search

For each query, start BFS from source

Find Distance

Count levels until reaching target

Code -

solution.c — C

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

#define MAX_NODES 1000
#define MAX_QUERIES 100

int graph[MAX_NODES][MAX_NODES];
int graphSize[MAX_NODES];

int bfsDistance(int start, int end, int n) {
    if (start == end) return 0;
    
    int queue[MAX_NODES * 2];
    int visited[MAX_NODES] = {0};
    int front = 0, rear = 0;
    
    queue[rear++] = start;
    queue[rear++] = 0; // distance
    visited[start] = 1;
    
    while (front < rear) {
        int node = queue[front++];
        int dist = queue[front++];
        
        for (int i = 0; i < graphSize[node]; i++) {
            int neighbor = graph[node][i];
            if (neighbor == end) {
                return dist + 1;
            }
            if (!visited[neighbor]) {
                visited[neighbor] = 1;
                queue[rear++] = neighbor;
                queue[rear++] = dist + 1;
            }
        }
    }
    
    return -1;
}

int* solution(int edges[][2], int edgesSize, int queries[][2], int queriesSize, int* returnSize) {
    int n = edgesSize + 1;
    memset(graphSize, 0, sizeof(graphSize));
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        result[i] = bfsDistance(queries[i][0], queries[i][1], n);
    }
    
    return result;
}

int main() {
    // Simple implementation for demonstration
    int edges[][2] = {{0,1}, {1,2}, {2,3}};
    int queries[][2] = {{0,3}, {1,2}};
    
    int returnSize;
    int* result = solution(edges, 3, queries, 2, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × n)

q queries, each requiring O(n) BFS traversal in worst case

⚡ Linearithmic

Space Complexity

O(n)

Adjacency list storage and BFS queue

⚡ Linearithmic Space

12.0K Views

Low Frequency

~45 min Avg. Time

450 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

Centroid Decomposition - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force BFS/DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler