最近公共祖先（LCA）

tips:9.18 改进格式

前题引入

给定一棵有根多叉树，请求出指定两个点直接最近的公共祖先。就这么简单，可能有入回想到直接把两个点的所有父亲都弄出来，再找最近的不就可以啦，那就恭喜你直接TLE满屏，那么该怎么办呢？

问题分析

既然他要让我们找到最近的公共祖先，通过思考我们可以让两个点同时往上面窜，这样就可以找到最近公共祖先了。这是估计有些小朋友就会跳出来大喊不对呀，如果两个的点的深度不一样，那更高（上）的会一直往上窜，切更低的点就得等到最上面（根）才能会和，要接解决这个问题就得引出今天BOSSLCA了

算法引入

初始化

我们这里可以定义一个二维数组f[i][j]表示对于节点i跳2^j层的节点。因为是2^j所以第二个树的范围是50左右，不是N!!!

可能有点抽象，举个例子f[i][0]就是他的爸爸，f[i][1]就是他的爷爷（抽象呃呃呃）。

既然我们懂得这一点就可以想到f[u][i] = f[f[u][i-1]][i-1];

因为从u跳2ⁱ层 = 先跳2^(i-1)层到中间节点，再从中跳2^(i-1)层。这个得弄明白不然后面写不下去

现在我们预处理，把所有的点的深度和f数组按照公式算出来（ 注意：这里在算之前要想让f[u][0]=fa;！！！）

这里给大家看一下预处理函数dfs：

void dfs(int u,int fa){//u:当前节点，fa:他的爸爸
	dep[u]=dep[fa]+1;//深度为他爸爸+1
	f[u][0]=fa;
	for(int i=1;i<=20;i++){
		f[u][i]=f[f[u][i-1]][i-1];//公式
	}
	for(int v:vi[u]){//遍历所有儿子
		if(v!=fa){//不可以是他爸！
			dfs(v,u);
		}
	}
	return;
}

求值函数LCA

好了，讲完预处理，下面讲lca函数。

这里我们lca函数两个参数x,y。这里我们可以先规定y的深度更大（或者等于），然后从20（大概）往下走，如果f[y][i]的深度比x的深度还要大，直接将y往上拔，因为这里的y的在更下面，跑完后如果x==y其实就说明x其实就是y的祖先，直接返回就可以了。

既然我们的深度差不多了那就两个开始同时往上跳，直到他们在同一个点，这个点就是他们的公共最近祖先。

下面来看一下，lca函数的代码：

int lca(int x,int y){
	if(dep[y]<dep[x]){//确定那个在更下面
		swap(x,y); 
	}
	for(int i=20;i>=0;i--){
		if(dep[f[y][i]]>=dep[x]){//如果在x下面
			y=f[y][i];//跳上来
		}
	}
	if(x==y){//x是y的祖先
		return x;
	}
	for(int i=20;i>=0;i--){
		if(f[y][i]!=f[x][i]){//不停往上跳
			y=f[y][i],x=f[x][i];
		}
	}
	return f[x][0];//注意：这里里节点还要跳一下！！！
}

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

既然都讲的如此明白了，直接上代码

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e5+5;

int n,s,q,f[maxn][50],u,v,dep[maxn];
vector<int> vi[maxn];

void dfs(int u,int fa){
	dep[u]=dep[fa]+1;
	f[u][0]=fa;
	for(int i=1;i<=20;i++){
		f[u][i]=f[f[u][i-1]][i-1];//公式
	}
	for(int v:vi[u]){
		if(v!=fa){
			dfs(v,u);
		}
	}
	return;
}

int lca(int x,int y){
	if(dep[y]<dep[x]){
		swap(x,y); 
	}
	for(int i=20;i>=0;i--){
		if(dep[f[y][i]]>=dep[x]){
			y=f[y][i];
		}
	}
	if(x==y){
		return x;
	}
	for(int i=20;i>=0;i--){
		if(f[y][i]!=f[x][i]){
			y=f[y][i],x=f[x][i];
		}
	}
	return f[x][0];
}

int main(){
	cin>>n>>q>>s;
	for(int i=1;i<n;i++){
		cin>>u>>v;
		vi[u].push_back(v); 
		vi[v].push_back(u); 
	}
	dfs(s,0);
	while(q--){
		cin>>u>>v;
		cout<<lca(u,v)<<'\n';
	}
	return 0;
}

算法应用

LCA最擅长来解决树上求两个点的之间的最短路，我现在知道了两个点的最近公共祖先，那我们就可以知道，x到y的距离=x到根的距离（深度）+y到根的距离-2*LCA到根的距离。

这个时间复杂的为O(log n)的主要是求LCA，算是O（1）的，也是比其他的算法快亿点（额，不会有人用SPFA，或Dijkstra吧）。

现在给道U153071试试手

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e5+10;
int dep[N],dp[N][30],n,dis[N];
vector<int> g[N],k[N];
void init(int u,int fa){
	dep[u]=dep[fa]+1;
	dp[u][0]=fa;
	int s;
	for(int i=0;i<k[u].size();i++){
		if(g[u][i]==fa){
			s=k[u][i];
		}
	}
	if(fa!=0) dis[u]=dis[fa]+s;
	for(int i=1;i<=20;i++){
		dp[u][i]=dp[dp[u][i-1]][i-1];
	}
	for(int i=0;i<g[u].size();i++){
		int v=g[u][i];
		if(v!=fa){
			init(v,u);
		}
	}
}
int lca(int x,int y){
	if(dep[y]<dep[x]){
		swap(x,y);
	}
	for(int i=20;i>=0;i--){
		if(dep[dp[y][i]]>=dep[x]){
			y=dp[y][i];
		}
	}
	if(x==y){
		return x;
	}
	for(int i=20;i>=0;i--){
		if(dp[x][i]!=dp[y][i]){
			x=dp[x][i],y=dp[y][i];
		}
	}
	return dp[x][0];
}
signed main(){
	int m;
	cin>>n>>m;
	for(int i=1;i<n;i++){
		int u,v,s;
		cin>>u>>v>>s;
		g[u].push_back(v);
		k[u].push_back(s);
		g[v].push_back(u); 
		k[v].push_back(s);
	}
	dis[1]=0;
	init(1,0);
	while(m--){
		int x,y;
		cin>>x>>y;
		cout<<dis[x]+dis[y]-2*dis[lca(x,y)]<<endl;
	} 
	return 0;
}

完结撒花，给个关注吧!