洛谷 P3379 【模板】最近公共祖先（LCA）

题目描述

如题，给定一棵有根多叉树，请求出指定两个点直接最近的公共祖先。

输入输出格式

输入格式：

第一行包含三个正整数N、M、S，分别表示树的结点个数、询问的个数和树根结点的序号。

接下来N-1行每行包含两个正整数x、y，表示x结点和y结点之间有一条直接连接的边（数据保证可以构成树）。

接下来M行每行包含两个正整数a、b，表示询问a结点和b结点的最近公共祖先。

输出格式：

输出包含M行，每行包含一个正整数，依次为每一个询问的结果。

输入输出样例

输入样例#1：

5 5 4
3 1
2 4
5 1
1 4
2 4
3 2
3 5
1 2
4 5

输出样例#1：

4
4
1
4
4

说明

时空限制：1000ms,128M

数据规模：

对于30%的数据：N<=10，M<=10

对于70%的数据：N<=10000，M<=10000

对于100%的数据：N<=500000，M<=500000

样例说明：

该树结构如下：

第一次询问：2、4的最近公共祖先，故为4。

第二次询问：3、2的最近公共祖先，故为4。

第三次询问：3、5的最近公共祖先，故为1。

第四次询问：1、2的最近公共祖先，故为4。

第五次询问：4、5的最近公共祖先，故为4。

故输出依次为4、4、1、4、4。

 #include<cstdio>
 #include<iostream>
 #include<cstring>
 using namespace std;
 long long read()
 {
     long long x=,f=;
     char ch=getchar();
     while(ch>''||ch<'')
     {
         if(ch=='-')
             f=-;
         ch=getchar();
     }
     while(ch>=''&&ch<='')
     {
         x=x*+ch-'';
         ch=getchar();
     }
     return x*f;
 }
 const int maxn=;
 int n,m,s,k,a,b;
 int head[maxn],d[maxn],p[maxn][];
 struct node
 {
     int v,next;
 } e[maxn*];
 void add(int u,int v)
 {
     e[k].v=v;
     e[k].next=head[u];
     head[u]=k++;
 }
 void dfs(int u,int fa)
 {
     d[u]=d[fa]+;
     p[u][]=fa;
     for(int i=; (<<i)<=d[u]; i++)
         p[u][i]=p[p[u][i-]][i-];
     for(int i=head[u]; i!=-; i=e[i].next)
     {
         int v=e[i].v;
         if(v!=fa)
             dfs(v,u);
     }
 }
 int lca(int a,int b)
 {
     if(d[a]>d[b])
         swap(a,b);
     for(int i=; i>=; i--)
         if(d[a]<=d[b]-(<<i))
             b=p[b][i];
     if(a==b)
         return a;
     for(int i=; i>=; i--)
     {
         if(p[a][i]==p[b][i])
             continue;
         else
             a=p[a][i],b=p[b][i];
     }
     return p[a][];
 }
 int main()
 {
     memset(head,-,sizeof(head));
     n=read(),m=read(),s=read();
     for(int i=; i<n; i++)
     {
         a=read(),b=read();
         add(a,b);
         add(b,a);
     }
     dfs(s,);
     for(int i=; i<=m; i++)
     {
         a=read(),b=read();
         printf("%d\n",lca(a,b));
     }
     return ;
 }

倍增求LCA

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 using namespace std;
 const int maxn=2e6+;
 #define ls k<<1
 #define rs k<<1|1
 long long read()
 {
     long long x=,f=;
     char ch=getchar();
     while(ch>''||ch<'')
     {
         if(ch=='-')
             f=-;
         ch=getchar();
     }
     while(ch>=''&&ch<='')
     {
         x=x*+ch-'';
         ch=getchar();
     }
     return x*f;
 }
 struct node
 {
     int v,nxt;
 } e[maxn];
 int head[maxn],fa[maxn],deep[maxn],tot[maxn],son[maxn],top[maxn];
 int num=,cnt;
 void add(int x,int y)
 {
     e[num].v=y;
     e[num].nxt=head[x];
     head[x]=num++;
 }
 int dfs1(int now,int f,int dep)
 {
     deep[now]=dep;
     fa[now]=f;
     tot[now]=;
     int maxson=-;
     for(int i=head[now]; i; i=e[i].nxt)
     {
         if(e[i].v==f)
             continue;
         tot[now]+=dfs1(e[i].v,now,dep+);
         if(tot[e[i].v]>maxson)
             maxson=tot[e[i].v],son[now]=e[i].v;
     }
     return tot[now];
 }
 void dfs2(int now,int topf)
 {
     top[now]=topf;
     if(!son[now])
         return ;
     dfs2(son[now],topf);
     for(int i=head[now]; i; i=e[i].nxt)
         if(e[i].v!=son[now]&&e[i].v!=fa[now])
             dfs2(e[i].v,e[i].v);
 }
 int LCA(int x,int y)
 {
     while(top[x]!=top[y])
     {
         if(deep[top[x]]<deep[top[y]])
             swap(x,y);
         x=fa[top[x]];
     }
     if(deep[x]>deep[y])
         swap(x,y);
     return x;
 }
 int main()
 {
     memset(head,,sizeof(head));
     int n=read(),m=read(),root=read();
     for(int i=; i<=n-; i++)
     {
         int x=read(),y=read();
         add(x,y),add(y,x);
     }
     dfs1(root,,);
     dfs2(root,root);
     while(m--)
     {
         int x=read(),y=read();
         printf("%d\n",LCA(x,y));
     }
     return ;
 }

树链剖分求LCA