Centroid Decomposition

Introduction

Centroids

A centroid of a tree is defined as a node such that when the tree is rooted at it, no other nodes have a subtree of size greater than $\frac{N}{2}$.

We can find a centroid in a tree by starting at the root. Each step, loop through all of its children. If all of its children have subtree size less than or equal to $\frac{N}{2}$, then it is a centroid. Otherwise, move to the child with a subtree size that is more than $\frac{N}{2}$ and repeat until you find a centroid.

Implementation

Copy
#include <iostream>
#include <vector>

using namespace std;

const int maxn = 200010;

int n;
vector<int> adj[maxn];
int subtree_size[maxn];

Copy
import java.io.*;
import java.util.*;

public class FindCentroid {
	public static int[] subSize;
	public static List<Integer>[] adj;
	public static int N;

	public static void main(String[] args) {
		Kattio io = new Kattio();

Centroid decomposition

Centroid Decomposition is a divide and conquer technique for trees. Centroid Decomposition works by repeated splitting the tree and each of the resulting subgraphs at the centroid, producing $\mathcal{O}(\log N)$ layers of subgraphs.

Implementation

General centroid code is shown below.

Copy
vector<vector<int>> adj;
vector<bool> is_removed;
vector<int> subtree_size;

/** DFS to calculate the size of the subtree rooted at `node` */
int get_subtree_size(int node, int parent = -1) {
	subtree_size[node] = 1;
	for (int child : adj[node]) {
		if (child == parent || is_removed[child]) { continue; }
		subtree_size[node] += get_subtree_size(child, node);

Copy
private static class Centroid {
	int n;
	int[][] g;
	int[] size;
	int[] parent;
	boolean[] seen;

	Centroid(int n, int[][] g) {
		this.n = n;
		this.g = g;

Solution - Xenia & Tree

For every node, there are at most $\log N$ centroid components that include this node, where $N$ denotes the number of nodes. Let's call the centroid whose component contains one node the centroid ancestor of this node. Also note that the path between every two nodes in the tree must include one of their common centroid ancestors, since the tree is being split into subtrees with the centroids as their respective roots. If we store the distance to the nearest red node for every centroid, we can query the minimal distance between any node and the nearest red node by calculating the minimum distance between the node and one of its centroid ancestors with the minimal distance from that centroid to a red node. To paint a node red, we just update all centroid ancestors of this node. Both operations can be done in $\mathcal{O} (\log N)$ time, as there are at most that many centroid ancestors for one node.

Copy
#include <bits/stdc++.h>
using namespace std;

// a number that is large enough while not causing overflow
const int INF = 1e9;

vector<vector<int>> adj;
vector<int> subtree_size;
// min_dist[v] := the minimal distance between v and a red node
vector<int> min_dist;

Problems