LCA（最近公共祖先）

lca即两点到达的第一个公共节点

前两个方法取自：Cold_Chair，树剖方法取自：Frocean

---

目录

 

暴力往上跳

倍增算法

树剖法

---

暴力往上跳

先把x，y跳到同一深度，然后同时往上跳，最后fa[x] == fa[y]即找到LCA。

时间复杂度与树的深度有关，则最坏情况就是一条链了。

int dep[maxn];
void dfs(int u){
	for(int i=head[u]; ~i; i=edge[i].next){
		int v = edge[i].to;
		dep[v] = dep[u] + 1;
		fa[v] = u;
		dfs(v);
	}
}
int lca(int x, int y){
	if(dep[x] > dep[y]) swap(x, y);	//使y为深度较大的 
	while(dep[y] > dep[x])	y = fa[y];
	while(x != y)	x = fa[x], y = fa[y];
	return x;
}

---

倍增算法

类同暴力，也是往上跳着找，只是倍增每次跳2的幂次，更快

预处理幂次：

1. 
2. 边界  

int dep[maxn];
void dfs(int u){
	for(int i=head[u]; ~i; i=edge[i].next){
		int v = edge[i].to;
		dep[v] = dep[u] + 1;
		fa[v] = u;
		dfs(v);
	}
}
int f[maxn][maxn];
void build(int n){
	dep[1] = 1;
	dfs(1);
	for(int i=1; i<=n; ++i)
		f[i][0] = fa[i];
	for(int j=1; (1< dep[y])	swap(x, y);
	for(int i=20; i>=0; --i){
		if(dep[f[y][i]] >= dep[x])
			y = f[y][i];
	}
	for(int i=20; i>=0; --i){
		if(f[x][i] != f[y][i])
			x = f[x][i], y = f[y][i];
	}
	return f[x][0];
}

---

树剖法

树剖入门

通过重链往上跳，最后归于一条链，深度较小时即为结果。

int siz[maxn], dep[maxn], fa[maxn], top[maxn], son[maxn]; //子节点数，深度，父亲，重链头节点，重儿子	
void dfs1(int u){
	siz[u] = 1;
	for(int i=head[u]; ~i; i=edge[i].next){
		int v = edge[i].to;
		dep[v] = dep[u] + 1;
		fa[v] = u;
		dfs(v);
		siz[u] += siz[v];
		if(!son[u] || siz[v] > siz[son[u]])	son[u] = v;
	}
}
void dfs2(int u){
	if(son[u]){
		top[son[u]] = top[u];
		dfs(son[u]);
	}
	for(int i=head[u]; ~i; i=edge[i].next){
		int v = edge[i].to;
		if(v == son[v])	continue;
		top[v] = v;
		dfs(v);
	}
}
int lca(int x, int y){
	while(top[x] != top[y]){
		if(dep[top[x]] > dep[top[y]])	swap(x, y);	//y较深
			y = fa[top[y]];
	}
	if(dep[x] > dep[y])	swap(x, y);	//在一条链上，返回深度较小的一个 
	return x;
}

---

还有其他求lca方法，等需要时再补充。可查看Cold_Chair