LCA详解（洛谷模板题）

一、算法定义

 LCA是在线查询树上两点的最近公共祖先的算法，可运用倍增的方法，时间复杂组O（nlogn）

二、算法过程

    1.倍增使深度较深的点跳到和深度较浅的点同一深度。

    2.两个点一起往上跳，直到找到公共祖先

三、分步代码详解

1.预处理：通过dfs，求出树上每个节点的深度。注：p[x][0]是x的父节点，如果遍历到父节点则跳过，其他的与该点相邻的点都是他的子节点

void dfs(int x)
{
	for(int i=head[x];i;i=next[i]){
		int go=to[i];
		if(go==p[x][0]) continue;
		d[go]=d[x]+1;
		dis[go]=dis[x]+len[i];
		p[go][0]=x;
		dfs(go);
	}
}

2.处理处树上各个节点的u上的2^i的祖先p[u][i];

void init()
{
	for(int j=1;(1<

3.找出查询点a和b中较深的一个点，使其和较浅的一个点达到相同深度

int lca(int a,int b)
{
	if(d[a]>d[b]) swap(a,b);
	f=d[b]-d[a];//两者相差的深度
	for(int i=0;(1<


4.a,b两个点一起倍增向上跳，直到找到公共祖先，这个祖先就是他们的最近公共祖先（a，b每次跳都将自身更新成现在已经跳到的祖先）

	if(a!=b){
		for(int i=log2(n);i>=0;i--){
			if(p[a][i]!=p[b][i]){
				a=p[a][i]; b=p[b][i];//更新a,b
			}
		}
		a=p[a][0];
	}
	return a;
}

四、LCA总代码

#include
#include
#include
#include
using namespace std;
const int maxn=1000000;
int head[maxn],next[maxn],to[maxn],len[maxn],size=0,d[maxn],dis[maxn],p[maxn][20];
int n,m,gen,from,go,f;
inline int read()
{
    int X=0,w=1; char ch=0;
    while(ch<'0' || ch>'9') {if(ch=='-') w=-1;ch=getchar();}
    while(ch>='0' && ch<='9') X=(X<<3)+(X<<1)+ch-'0',ch=getchar();
    return X*w;
}
void addedge(int x,int y,int z){
	size++;
	len[size]=z;
	to[size]=y;
	next[size]=head[x];
	head[x]=size;
}
void dfs(int x)
{
	for(int i=head[x];i;i=next[i]){
		int go=to[i];
		if(go==p[x][0]) continue;
		d[go]=d[x]+1;
		dis[go]=dis[x]+len[i];
		p[go][0]=x;
		dfs(go);
	}
}
void init()
{
	for(int j=1;(1<d[b]) swap(a,b);
	f=d[b]-d[a];
	for(int i=0;(1<=0;i--){
			if(p[a][i]!=p[b][i]){
				a=p[a][i]; b=p[b][i];
			}
		}
		a=p[a][0];
	}
	return a;
}
int main()
{
	n=read(); m=read(); gen=read();
	for(int i=1;i