题目大意
给定一棵有
n
n
n 个点的树,回答
q
q
q 组点对
(
a
,
b
)
(a,b)
(a,b) 的最近公共祖先。
数据范围
1
⩽
N
,
M
⩽
10000000
1\leqslant N,M\leqslant 10000000
1⩽N,M⩽10000000
题解
%
维护一个并查集,一开始所有点的祖先都是自己,先进行一次深度优先遍历,每次离开一个点的时候,将其标记为已到达,并遍历询问中(邻接表储存)和这个点有关的询问,若另一个点标记为已到达,则答案为另一个点在并查集中的祖先(后面),最后让这个点在并查集中认自己的真实父亲作父亲。
如此,每个点会且仅会被遍历一次,在离开的时候,和某个点相关的询问会且只会被访问两次,考虑到此处并查集必须严格按照原树的结构合并,不能按秩合并,因而最坏时间复杂度为
T
(
n
)
=
Θ
(
n
log
1
+
m
n
n
+
2
q
)
T(n)=\Theta(n\log_{1+\frac mn} n+2q)
T(n)=Θ(nlog1+nmn+2q) 这是时间复杂度低于倍增的离线算法,名称也是
Tarjan
\texttt{Tarjan}
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;
}