LCA（最近公共祖先）

概念

在一颗有根树中，从根节点经过该节点的所有节点（包括它自己），就是它的祖先。而最近公共祖先，则是指两个节点共同的祖先中离得最近的一个，也就是深度最大的一个祖先节点。

朴素算法求解

首先，将两个子节点跳到同一个深度上。然后再暴力往上跳，当两个子节点所跳的点第一次重合时，那么这个节点就是要求的它们的最近公共祖先。乍一看，时间复杂度并不太高，但是在一些数据（毒瘤），暴力算法肯定是不可取的。就比如一条链也可以看作一颗树，两个深度相差很大的子节点，求公共祖先，每次询问的时间复杂度为O(n)，多次询问肯定是吃不消的。所以，就有dalao想出来了用倍增来优化LCA。

倍增优化求解

倍增算法，就是每次将区间的最值预处理出来，求得区间长度为2^i的最值，用于求静态数组。而对于LCA，相当于求出一个节点的第2^i个祖先节点。然后在跳到同一高度的时候，也可以将两个节点的差值dep划分为最多log n 个子区间，就可以大大减少所消耗的时间。跳到同一个高度后，再进行跳跃，倒序从 log n 遍历到0，如果两个子节点跳跃长度为2^i时跳到了同一个节点，就说明这个节点是它们的公共祖先，但是不一定是最近公共祖先。所以此时，应该缩短区间长度，直到两个节点跳到的不是同一个节点为止。这样，就可以一步步的逼近它们的最近公共祖先。当两个节点往上跳一格时，所接触到的节点是相同的，那么可以肯定，这个节点就一定是它们的最近公共祖先了。

Code  （略微改进）

#include<bits/stdc++.h>
#include<string>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>

#define ll long long

using namespace std;

inline int read(){
	   int x=0,f=1;char s=getchar();
	   while (s>'9'||s<'0'){
			 if (s=='-') f=-f;
			 s=getchar();
	   }
	   while (s>='0'&&s<='9'){
			 x=x*10+s-'0';
			 s=getchar();
	   }
	   return x*f;
}

const int N = 1e6+10;

int n,m,s,u,v,fa[N][21],x,y,first[N],cnt,dep[N];
struct node{
	int nxt,to;
}edges[N*2];
bool d[N];

void add(int u,int v) {
	edges[++cnt].to=v;
	edges[cnt].nxt=first[u];
	first[u]=cnt;
}

void dfs(int root) {
	d[root]=true;
	for (int t=first[root];t;t=edges[t].nxt) {
		int h=edges[t].to;
		if (d[h]) continue;
		dep[h]=dep[root]+1;
		fa[h][0]=root;
		dfs(h);
	}
}

int LCA(int x,int y) {
	int d1=x,d2=y;
	if (dep[d1]<dep[d2]) swap(d1,d2);
	for (int i=20;i>=0;--i) 
		if (dep[fa[d1][i]]>=dep[d2]) d1=fa[d1][i];
	if (d1==d2) return d1;
	for (int i=20;i>=0;--i) 
		if (fa[d1][i]!=fa[d2][i]) d1=fa[d1][i],d2=fa[d2][i];
	return fa[d1][0];
}

int main(){
	n=read();m=read();s=read();
	for (int i=1;i<n;++i) {
		u=read();v=read();
		add(u,v);add(v,u);
	}
	dep[s]=1;
	dfs(s);
	for (int i=1;i<=20;++i) {
		for (int j=1;j<=n;++j) 
			fa[j][i]=fa[fa[j][i-1]][i-1];
	}
	for (int i=1;i<=m;++i) {
		x=read();y=read();
		printf("%d\n",LCA(x,y));
	}
	return 0;
}

树链剖分求解

详情见树链剖分。