最近公共祖先线性算法

题目大意

给定一棵有 $n$ 个点的树，回答 $q$ 组点对 $(a,b)$ 的最近公共祖先。
数据范围　$1⩽N,M⩽10000000$

题解

%　　维护一个并查集，一开始所有点的祖先都是自己，先进行一次深度优先遍历，每次离开一个点的时候，将其标记为已到达，并遍历询问中（邻接表储存）和这个点有关的询问，若另一个点标记为已到达，则答案为另一个点在并查集中的祖先（后面），最后让这个点在并查集中认自己的真实父亲作父亲。
　　如此，每个点会且仅会被遍历一次，在离开的时候，和某个点相关的询问会且只会被访问两次，考虑到此处并查集必须严格按照原树的结构合并，不能按秩合并，因而最坏时间复杂度为 $$T(n)=\Theta (n{\log }_{1+\frac{m}{n}}n+2q)$$　　这是时间复杂度低于倍增的离线算法，名称也是$\text{Tarjan}$算法。

代码

#include<bits/stdc++.h>
using namespace std;
#define maxn 500010
struct edge{
	int v,next,code;
}edges[maxn<<1],que[maxn<<1];
int head[maxn],hque[maxn],len=0,ques=0;
void ins_edge(int u,int v){
	edges[++len]=(edge){v,head[u]};
	head[u]=len;
}
void ins_que(int u,int v,int code){
	que[++ques]=(edge){v,hque[u],code};
	hque[u]=ques;
}
int n,q,f[maxn],d[maxn];
int findfa(int x){
	if(f[x]==x) return x;
	return f[x]=findfa(f[x]);
}
struct dfss{
	int u,fa;
}sta[maxn];
int top=0;
bool vis[maxn];
int ans[maxn];
void dfs(int tt){
	sta[++top]=(dfss){tt,-1};
	while(top>0){
		int u=sta[top].u,fa=sta[top].fa;
		for(int &i=head[u];i;i=edges[i].next){
			int v=edges[i].v;
			if(v==fa)continue;
			sta[++top]=(dfss){v,u};
			break;
		} head[u]=edges[head[u]].next;
		if(sta[top].u==u){
			for(int i=hque[u];i;i=que[i].next)
				if(vis[que[i].v]) ans[que[i].code]=findfa(que[i].v);
			vis[u]=true;
			f[findfa(u)]=findfa(fa);
			--top;
		}
	}
}
int main(){
	int tt;
	scanf("%d%d%d",&n,&q,&tt);
	for(int i=1;i<=n;i++) f[i]=i;
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		ins_edge(a,b),ins_edge(b,a);
	}
	for(int i=1,a,b;i<=q;i++){
		scanf("%d%d",&a,&b);
		ins_que(a,b,i),ins_que(b,a,i);
	}
	dfs(tt);
	for(int i=1;i<=q;i++)
		printf("%d\n",ans[i]);
	return 0;
}