【模板算法】LCA最近公共祖先问题——二分搜索

算法描述：

通过预处理parent数组，实现对两个节点公共祖先的二分搜索。主要目的是降低多次搜素的综合复杂度，预处理数组的复杂度为O(nlogn)，单次处理的复杂度为O(logn)。

算法实现原理：

对于任意顶点v，利用其父亲节点信息，可以通过parent[k+1][v]=parent[k][parent[k][v]]得到其每向上走2^k步所到的顶点parent[k][v]。有了k=floor(logn)以内的所有信息后，就可以进行二分搜索了。

数据保存

#define MAX_V 1000
#define MAX_LOG_V 4
using namespace std;
vector<int>G[MAX_V]; //用邻接表存储树
int root;//树的根节点
int N;//总结点数+root
int parent[MAX_LOG_V][MAX_V];
int depth[MAX_V];

预处理：

void dfs(int v,int p,int d){//初始化depth数组和parent数组第一层 
	parent[0][v]=p;
	depth[v]=d;
	for(int i=0;i<G[v].size();i++){
		dfs(G[v][i],v,d+1);
	}
} 
void init(int V){//初始化parent数组和depth数组 
	dfs(root,-1,0);
	for(int k=0;k+1<MAX_LOG_V;k++){
		for(int v=0;v<V;v++){
			if(parent[k][v]<0)parent[k+1][v]=-1;
			else parent[k+1][v]=parent[k][parent[k][v]];
		}
	}
}

LCA计算

1.让v为最深的节点
2.让v走到和u同一深度
3.让v和u走到同一节点
模拟3和8：
3为第2层，8为第4层
4-2=2，2=10(二进制)，0&1=0，所以第一次不走；1&1=1，所以走两步到达2，把2赋值给8
如果差5层，则为101，走4层再走1层；
3为第二层，2为第二层
先判断3向上走2²步与2向上走2²步是否为同一节点，明显是的，所以不走；
再判断3向上走2步与2向上走2步是否为同一节点，明显是的，所以不走；
再判断3向上走1步与2向上走1步是否为同一节点，明显是的，所以不走；
返回3的父节点，即为1。
如果差3辈，则会加2；如果差4辈，则会加2加1；

int lca(int u,int v){
	if(depth[u]>depth[v])swap(u,v);//保证v是更深的那个节点 
	printf("%d %d\n",u,v);
	for(int k=0;k<MAX_LOG_V;k++){//让v走到和u同一深度 
		if((depth[v]-depth[u])>>k&1){
			v=parent[k][v];
		}
	}
	printf("%d %d\n",u,v);
	if(u==v)return u;
	for(int k=MAX_LOG_V-1;k>=0;k--){//走到同一节点 
		if(parent[k][u]!=parent[k][v]){
			u=parent[k][u];
			v=parent[k][v];
			printf("%d %d\n",u,v);
		}
	}
	return parent[0][u];
}

测试代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<string>
#include<vector>
#include<algorithm>
#define INF 99999999
#define MAX_V 1000
#define MAX_LOG_V 4
using namespace std;
vector<int>G[MAX_V]; 
int root;//树的根节点
int N;//总结点数（起始为1）
int parent[MAX_LOG_V][MAX_V];
int depth[MAX_V];
void dfs(int v,int p,int d){//初始化depth数组和parent数组第一层 
	parent[0][v]=p;
	depth[v]=d;
	for(int i=0;i<G[v].size();i++){
		dfs(G[v][i],v,d+1);
	}
} 
void init(int V){//初始化parent数组和depth数组 
	dfs(root,-1,0);
	for(int k=0;k+1<MAX_LOG_V;k++){
		for(int v=0;v<V;v++){
			if(parent[k][v]<0)parent[k+1][v]=-1;
			else parent[k+1][v]=parent[k][parent[k][v]];
		}
	}
}
int lca(int u,int v){
	if(depth[u]>depth[v])swap(u,v);//保证v是更深的那个节点 
	printf("%d %d\n",u,v);
	for(int k=0;k<MAX_LOG_V;k++){//让v走到和u同一深度 
		if((depth[v]-depth[u])>>k&1){
			v=parent[k][v];
		}
	}
	printf("%d %d\n",u,v);
	if(u==v)return u;
	for(int k=MAX_LOG_V-1;k>=0;k--){//走到同一节点 
		if(parent[k][u]!=parent[k][v]){
			u=parent[k][u];
			v=parent[k][v];
			printf("%d %d\n",u,v);
		}
	}
	return parent[0][u];
}
int main(){
	root=1;
	N=9;
	G[1].push_back(2);
	G[1].push_back(3);
	G[2].push_back(4);
	G[2].push_back(5);
	G[3].push_back(6);
	G[5].push_back(7);
	G[5].push_back(8);
	init(N);
	for(int i=0;i<MAX_LOG_V;i++){
		for(int j=1;j<N;j++){
			printf("%d ",parent[i][j]);
		} 
		printf("\n");
	}
	printf("%d\n",lca(3,8));
	return 0;
}