最近公共祖先（Lowest Common Ancestor，LCA）是计算机科学中针对有根树结构的术语，定义为两个节点在树中深度最大的共同祖先节点。该概念在数据结构、图论等领域常用于解决节点间关系问题。
对于有根树T的两个节点u和v，其LCA需满足同时为两者的祖先且深度最大。该问题可转化为无向无环图中两节点最短路径上深度最小的点。常见算法包括离线Tarjan算法与在线倍增法：Tarjan算法通过深度优先搜索与并查集结合，以线性时间复杂度处理批量查询；倍增法则基于预处理节点祖先信息，实现单次查询对数级时间复杂度。
Tarjan算法由罗伯特·塔扬提出，利用并查集优化遍历过程，适用于静态树结构下的离线查询场景。倍增法则侧重于动态处理在线查询，通过递推预处理每个节点的2^j倍祖先信息，利用二进制提升思想加速搜索过程。两种算法分别针对不同应用需求，成为解决LCA问题的经典方案。
- 中文名
- 最近公共祖先
- 外文名
- Lowest Common Ancestors
- 简 称
- LCA
- 算 法
- 离线算法，倍增法
算法简介
播报编辑
另一种理解方式是把T理解为一个无向无环图，而LCA(T,u,v)即u到v的最短路上深度最小的点。
这里给出一个LCA的例子：
对于T=<V,E>
V={1,2,3,4,5}
E={(1,2),(1,3),(3,4),(3,5)}
则有：
LCA(T,5,2)=1
LCA(T,3,4)=3
LCA(T,4,5)=3
算法
播报编辑
离线算法 Tarjan
Tarjan算法基于深度优先搜索的框架，对于新搜索到 的一个结点，首先创建由这个结点构成的集合，再对当前结点的每一个子树进行搜索，每搜索罪道迁完一棵子树，则可确定子树内的LCA询问都已解决。其他档榜酷的LCA询问的结果颈戏葛微必然在这个子树之外，这时把子树所形成的集合与当前结点的集合合并，并将当前结点设为这个集合的祖先。
之后继续搜索下一棵子树，直到当前结点的所 有子树搜索完。这时把当前结点也设为已被检查过的，同时可以处理有关当前结点的LCA询问，如果有一个从当前结点到结点v的询问，且v已被检查过，则由于 进行的是深度优先搜索，当前结点与v的最近公共祖先一定还没有被检查，而这个最近公共祖先的包涵v的子树一定已经搜索过了，那么这个最近公共祖先一定是v 所在集合的祖先。
LCA(u){
Make-Set(u)
ancestor[Find-Set(u)]=u
对于u的每一个孩子v{
LCA(v)
Union(u)
ancestor[Find-Set(u)]=u
}
checked[u]=true
对于每个(u,v)属于P{
ifchecked[v]=true
then回答u和v的最近公共祖先为ancestor[Find-Set(v)]
}
}
在线算甩达套愉键法 倍增法
每次询问O(logN)
d[i] 表示 i节点的深度， p[i,j] 表示 i 的 2^j 倍祖先
这样子一个O(NlogN)的预处理求出每个节点的 2^k 的祖先
然后对于每一个询问的点对(a, b)的最垫体戏近公共祖先就是：
先判断是否 d[a] ＞ d[b] ,如果是的话就交换一下(保证 a 的深度小于 b 方便下面的操作)，然后把b 调到与a 同深度, 同深度以后再把a, b 同时往上调，找到有一个最小的j 满足p[a,j]!=p[b,j] (a b 是在不断更新的), 最后再把 a, b 往上调 (a=p[a,j], b=p[b,j]) 一个一个向上调直到a = b, 这时 a or b 就是他们的最近公共祖先。
算法实例
播报编辑
问题描述：
设计一个算法，对于给定的树中 结点返回它们的最近公共祖先。
编程任务：
对于给定的树和树中结点对，计算结点对的最近公共祖先。
数据输入：
由文件input.txt给出输入数据。
第一行有1个正整数n，表示给定的树有n个顶点，编0号为1，2，…，n。编号为1 的顶点是树根。接下来的n 行中，第i+1 行描述与i 个顶点相关联的子结点的信息。每行的第一个正整数k表示该顶点的儿子结点数。其后k个数中，每1 个数表示1 个儿子结点的编号。当k=0 时表示相应的结点是叶结点。文件的第n+2 行是1 个正整数m，表示要计算最近公共祖先的m个结点对。接下来的m行，每行2 个正整数，是要计算最近公共祖先的结点编号。
结果输出:
将编程计算出的m个结点对的最近公共祖先结点编号输出到文件output.txt。每行3 个
正整数，前2 个是结点对编号，第3 个是它们的最近公共祖先结点编号。
输入文件示例(input.txt)
12
3 2 3 4
2 5 6
0
0
2 7 8
2 9 10
0
0
0
2 11 12
0
0
5
3 11
7 12
4 8
9 12
8 10
输出文件示例(output.txt)
3 11 1
7 12 2
4 8 1
9 12 6
8 10 2
C代码实现：
#include<iostream>
#include<fstream>
using namespace std;
inline void Swap(int&a,int&b){
int temp=a;
a=b;
b=temp;
}
int Partition(int *a,int p,int r){
int i=p;
int j=r+1;
int x=a[p];
while(true){
while(a[++i]<x&&i<r);
while(a[--j]>x);
if(i>=j) break;
Swap(a[i],a[j]);
}
a[p]=a[j];
a[j]=x;
return j;
}
void QuickSort(int *a,int p,int r){
if(p<r){
int q=Partition(a,p,r);
QuickSort(a,p,q-1);
QuickSort(a,q+1,r);
}
}
int FindSource(int *array,int source,int low,int high){
int mid;
while(low<=high){
mid=(low+high)/2;
if(source==array[mid]) return source;
else{
if(source<array[mid]) high=mid-1;
else low=mid+1;
}
}
return -1;
}
class CommonTree{
public:
CommonTree(int Max=10);
~CommonTree();
void getdata(int *treedata,int num);
int find_same_ancestor(int Node1,int Node2,int array_num);
void getroot(int i);
int Size();
void Print()
const;
private:
int *TreeArray;
int size;
int root;
};/
CommonTree::CommonTree(int Max){
size=Max;
TreeArray=newint[size];
if (TreeArray==NULL) exit(1);
}
CommonTree::~CommonTree(){
delete[]TreeArray;
}
voidCommonTree::getdata(int*treedata,intnum){
int *p_temp=TreeArray;
TreeArray=treedata;
treedata=p_temp;
size=num;
delete[]treedata;
treedata=NULL;
}
int CommonTree::find_same_ancestor(int Node1,int Node2,int array_num){
int *array_Node1=newint[array_num];
int *array_Node2=newint[array_num];
if(array_Node1==NULL&&array_Node2==NULL) exit(1);
int x=Node1,array_Node1_num=0;
array_Node1[0]=x;
while(x!=root){
x=TreeArray[x];
array_Node1_num++;
array_Node1[array_Node1_num]=x;
}
x=Node2;
int array_Node2_num=0;
array_Node2[0]=x;
while(x!=root){
x=TreeArray[x];
array_Node2_num++;
array_Node2[array_Node2_num]=x;
}
QuickSort (array_Node2,0,array_Node2_num);
int result=0;
for(inti=0;i<=array_Node1_num;i++){
result=FindSource(array_Node2,array_Node1[i],0,array_Node2_num);
if(result!=-1) break;
}
delete[]array_Node1;
delete[]array_Node2;
return result;
}
inline int CommonTree::Size(){
return size;
}
inline void CommonTree::getroot(int i){
root=i;
}
void CommonTree::Print()
const{
for(inti=1;i<size;i++) cout<<this->TreeArray[i]<<"";
cout<<endl;
cout<<root<<endl;
}
int main(){
ifstreamin("input.txt");
if( in.fail()){
cout<<"inputerror!"<<endl;
exit(1);
}
ofstreamout("output.txt");
int NodeNum;
in>>NodeNum;
int *AncestorTree=newint[NodeNum+1];
if(AncestorTree==NULL) exit(1);
memset(AncestorTree,0,sizeof(int)*(NodeNum+1));
int father=1;
for(intj=0;j<NodeNum;j++){
int lop;
in>>lop;
for(inti=0;i<lop;i++){
int temp;
in>>temp;
AncestorTree[temp]=father;
}
father++;
}
for(j=1;j<=NodeNum;j++){
if (AncestorTree[j]==0){
AncestorTree[j]=j;
break;
}
}
int find_num;
in>>find_num;
int *result=newint[3*find_num];
if(result==NULL) exit(1);
for(inti=0;i<2*find_num;i++) in>>result[i];
CommonTreemain_tree(10);
main_tree.getdata(AncestorTree,NodeNum+1);
main_tree.getroot(j);
int displace=0;
for(i=0;i<find_num;i++){
result[2*find_num+i]=main_tree.find_same_ancestor(result[displace],result[displace+1],NodeNum);
displace+=2;
}
displace=0;
for(i=0;i<find_num;i++){
out<<result[displace]<<""<<result[displace+1]<<""<<result[2*find_num+i];
displace+=2;
out<<endl;
}
delete[]result;
return 0;
}
C++代码实现：
#include<iostream>
#include<stdio.h>
#include<memory.h>
using namespace std;
#definemax_size 1010
int d[max_size],p[max_size][10];
int head[max_size];
int cnt;
structEdge{
int v;
int pre;
}eg[max_size];
//建树的函数
void add(int x,int y){
eg[cnt].v=y;
eg[cnt].pre=head[x];
head[x]=cnt++;
}
//dfs()初始整颗数，算出d[1-n],p[1-n][j];
void dfs(intk){
if (head[k]==0) return;
int m,x,i,j;
for(i=head[k];i!=0;i=eg[i].pre){
x=eg[i].v;
p[x][0]=k;
m=k;
d[x]=d[k]+1;
for(j=0;p[m][j]!=0;j++){
p[x][j+1]=p[m][j];//利用公式p[x][j]=p[p[x][j-1]][j-1],这里的m就是p[x][j-1];
m=p[m][j];
}
dfs(x);
}
}
int find_lca(int x,int y){
int m,k;
if (x==y) return x;
if(d[x]<d[y]){m=x;x=y;y=m;}
m=d[x]-d[y];
k=0;
while(m){//将x的深度调到和y的深度一样
if(m&1) x=p[x][k];
m>>=1;
k++;
}
if (x==y)return x;
k=0;//向上调节，找最近公共祖先，算法的核心，相当于一个二分查找。
while(x!=y){
if (p[x][k]!=p[y][k]||p[x][k]==p[y][k]&&k==0){//如果p[x][k]还不相等，说明节点p[x][k]还在所求点的下面，所以继续向上调节;如果相等了，并且就是他们父节点，则那个节点一定就是所求点。
x=p[x][k];
y=p[y][k];
k++;
}
else k--;//如果p[x][k]=p[y][k],可以说明p[x][k]一定是x和y的共祖先，但不一定是最近的,所以向下找看还有没有更近的公共祖先
}
return x;
}
int main(){
int i,n,m,x,y;
while(cin>>n>>m){
memset(head,0,sizeof(head));
memset(p,0,sizeof(p));
memset(d,0,sizeof(d));
cnt=1;
for(i=2;i<=n;i++){
scanf("%d",&x);
add(x,i);
}
dfs(1);
for(i=0;i<m;i++){
scanf("%d%d",&x,&y);
printf("%d/n",find_lca(x,y));
}
}
return 0;
}
