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<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
struct node
{
	int to;
	int next; 
}edge[N<<2];
int cnt=0;
int head[N];
void addedge(int from,int to)
{
	edge[cnt].to=to;
	edge[cnt].next=head[from];
	head[from]=cnt++;
}
int pa[N];
int depth[N];
void dfs(int v,int p,int d)
{
	pa[v]=p;
	depth[v]=d;
	for(int i=head[v];i!=-1;i=edge[i].next){
		int to=edge[i].to;
		if(to!=p){
			dfs(to,v,d+1);
		}
	} 
}
int lca(int u,int v)
{
	while(depth[u]>depth[v]) u=pa[u];
	while(depth[v]>depth[u]) v=pa[v];
	while(u!=v){
		u=pa[u];
		v=pa[v];
	}
	return u;
}
int main()
{
	memset(head,-1,sizeof(head));
	int n,m,s;
	scanf("%d %d %d",&n,&m,&s);
	for(int i=0;i<n-1;i++){
		int a,b;
		scanf("%d %d",&a,&b);
		addedge(a,b);
		addedge(b,a);
	}	
	dfs(s,-1,0);
	while(m--){
		int a,b;
		scanf("%d %d",&a,&b);
		printf("%d\n",lca(a,b));
	}	
	return 0;
} 

节点的最大深度是O(n) ,所以该算法的复杂度也是O(n) 如果只是询问一次lca的话 ， 那么这个算法的复杂度是可以的，但是多次计算lca的话就不行了。

 

 

可以用倍增的思想来优化这个求lca的算法。

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
int fa[N][30];//fa[i][k]表示节点i的上2^k层的祖先是哪个点 注意是点 
int depth[N];
/*
如果用vector 也过不了 所以用数组模拟邻接表 
*/ 
struct node
{
	int to;
	int next; 
}edge[N<<2];
int cnt=0;
int head[N];
void addedge(int from,int to)
{
	edge[cnt].to=to;
	edge[cnt].next=head[from];
	head[from]=cnt++;
}
void dfs(int v,int p,int d)
{
	depth[v]=d;
	fa[v][0]=p;
	for(int i=1;i<=20;i++){
		fa[v][i]=fa[fa[v][i-1]][i-1];
		//这个转移可以说是算法的核心之一
        //意思是fa的2^i祖先等于f的2^(i-1)祖先的2^(i-1)祖先
        //2^i=2^(i-1)+2^(i-1)
	}
	for(int i=head[v];i!=-1;i=edge[i].next){
		int to=edge[i].to;
		if(to!=p){
			dfs(to,v,d+1);
		}
	} 
}
int lca(int u,int v)
{
	if(depth[u]<depth[v]) swap(u,v);
	int t=depth[u] - depth[v];
	//让 u v在同一层 
	for(int i=20;i>=0;i--){
		if(t&(1<<i)){
			u=fa[u][i];
		}
	}
	if(u==v) return u;
	//因为我们要跳到它们LCA的下面一层，所以它们肯定不相等，如果不相等就跳过去。
	for(int i=20;i>=0;i--){
		if(fa[u][i]!=fa[v][i]){
			u=fa[u][i];
			v=fa[v][i];
		}
	}
	return fa[u][0];
}
int main()
{
	memset(head,-1,sizeof(head));
	int n,m,s;
	scanf("%d %d %d",&n,&m,&s);
	for(int i=0;i<n-1;i++){
		int a,b;
		scanf("%d %d",&a,&b);
		addedge(a,b);
		addedge(b,a);
	}	
	dfs(s,0,0);
	while(m--){
		int a,b;
		scanf("%d %d",&a,&b);
		printf("%d\n",lca(a,b));
	}	
	return 0;
}