【最近公共祖先lca】知识点讲解+算法模板

最近公共祖先(LCA)

LCA问题：在有根树中,找出某两个结点 u 和 v 最近的公共祖先 
算法：倍增法（大的不行试小的，小的不行试更小的） 
算法思想：分治。 
算法流程当已知两个点在树中的深度时,先让较深的结点向上走，直到两个结点深度一样；二分找出离他们最近的公共祖先。我们记一个结点的父结点为它的2^0=1倍祖先，它的父结点的父结点为它的2^1=2倍祖先，以此类推。接下来开始描述倍增算法的具体流程。 
1.：在树上预处理每个结点的深度和0倍祖先，也就是每个结点的父结点。用 d 数组来表示每个结点的深度， p[v][h] 表示结点v的h倍祖先的结点编号。 d 数组中的元素初始为 -1。初始化完成后,p[a][0]保存的是a的第 2^0=1 倍祖先结点,即它的父结点。时间复杂度O(V) 
2.：倍增计算各个点的2^j祖先是谁，其中，1倍祖先就是父亲，2倍祖先是父亲的父亲，以此类推。该点2^j祖先也就是该点2^j-1祖先的2^j-1祖先。在这一步中，2^level 表示的是祖先的倍数。很显然i，2^j的 倍祖先就是i的2^j-1祖先的2^j-1祖先。时间复杂度为O(VlogV)。 
3.第三步（查询）：首先，深度大的点往上爬，直到与深度小的点在同一层。若此时两结点相同直接返回此结点，即最近公共祖先 LCA。这意味着其中一个结点是另一个结点的祖先结点。 

否则，利用倍增思想，同时让x和y二分地向上找，直到找到深度相等且最小的x和y的祖先x’，y’满足x’!=y’ 。此时他们的父结点p[x’][0]即为x和y的最近公共祖先 LCA。 

用我的语言大致说一下算法流程：

1.链式前向星存储结构

2.dfs函数结合链式前向星来把每个点的深度值（d[i]）和首个父节点（fa[i][0]）赋好值。递归思想。

3.lca函数是算法的关键，先让更深的那个x通过“倍增法”（就是用二进制的思维，以1,2,4,8等2的阶层步长接近答案，比一步一步向上要快很多）从大到小来向上跳（只要当前d[x]加上（1<<j）不高于y则可以跳），根据二进制的性质（可以组成你想要的任何数字），最后一定有：d[x]=d[y] ，二者达到同一层。若x==y那么最大公共祖先即y。否则，再用“倍增法”让x和y从大到小同时向上跳，（条件：二者跳上去到达的点不相同！对于这个条件可以巧妙满足①解决跳上去的点不存在的问题（初始化由5定义），这样二者到达的点会相同的。②解决最后要求“最近”的问题。）。

理解见图viahttp://www.cnblogs.com/yyf0309/p/5972701.html）

那么最后找到二者的父节点，返回fa[x][0]，即是最近公共祖先。

4.涉及输入：用一个isleave数组来辅助，对于每次输入都让其终点的该值为1,因为有向图嘛，所以根节点不会当成终点被指向，所以遍历一遍找到isleave值不为1的那个就是根节点，设根节点的深度d[root]=1，然后对根节点进行dfs函数。

5.有个关键的初始化：fa[i][level]=fa[fa[i][level-1]][level-1]，就是说因为这里我们有个默认定义是“fa[i][level]是第i个结点的第2^level个父节点”，那么也就是第i个结点的第2^(level-1)个父节点的2^(level-1)个父节点。（因为2^(level-1)+2^(level-1)=2^level）

所以这里为了方便，直接用两层循环，外层是level从1到最大层数（二叉树），内层是对每个节点i。由此对于fa[i][level]进行初始化。

6.最后，直接调用lca(x,y)就可以返回得到x和y的最近公共祖先。

算法模板：

#include <iostream>
#include <cstring>
#include <cstdio> 
using namespace std;
const int MAX_N=100000;
const int MAX_M=1000000;
int isleave[100050];
struct edge{
    int v,next;
}E[MAX_M];
int p[MAX_N],eid;
void init(){
    memset(p,-1,sizeof(p));
    memset(isleave,0,sizeof(isleave));
    eid=0;
}
void insert(int u,int v){
    E[eid].v=v;
    E[eid].next=p[u];
    p[u]=eid++;
}
int d[MAX_N],fa[MAX_N][20];
void dfs(int u){
    for(int i=p[u];i!=-1;i=E[i].next){
        if(d[E[i].v]==-1){
            d[E[i].v]=d[u]+1;
            fa[E[i].v][0]=u;
            dfs(E[i].v);
        }
    }

}

int lca(int x,int y){
    int i,j;
    if(d[x]<d[y]){
        swap(x,y);
    }
    for(i=0;(1<<i)<=d[x];i++);
    i--;
    for(j=i;j>=0;j--){
        if(d[x]-(1<<j)>=d[y]){
            x=fa[x][j];
        }
    }
    if(x==y){
        return x;
    }
    for( j=i;j>=0;j--)
    {
        if(fa[x][j]!=fa[y][j]){
            x=fa[x][j];
            y=fa[y][j];
        }
    }
    return fa[x][0];
}
int main() {
    int n;
    init();
    cin>>n;
    for(int i=0;i<n-1;i++)
    {
        int u,v;
        cin>>u>>v;
        insert(u,v);
        insert(v,u);
        isleave[v]=1;
    }
    memset(d,-1,sizeof(d));
    int root;
    for(int i=1;i<=n;i++)
        {
        if(isleave[i]==0){
            root=i;
            break;
        }
    }
    d[root]=1;
    dfs(root);
    for(int level=1;(1<<level)<=n;level++){
        for(int i=1;i<=n;i++){
            fa[i][level]=fa[fa[i][level-1]][level-1];
        }
    }
    int q;
    cin>>q;
    while(q--){
        int a,b;
        cin>>a>>b;
        cout<<lca(a,b)<<endl;
    }
    return 0;
}

当然，这个方法适用于要查询多次，可以简化时间复杂度。（不过呢也是一种“在线算法”）。

而如果只是查询一次，不用考虑那么多时间复杂度，那完全就可以暴力找相同啊！代码：

class LCA {
public:
    int getLCA(int a, int b) {
        // write code here
        if (a == b)
            return a;
        return a>b? getLCA(a/2, b): getLCA(a, b/2);  //每除以二，就是找它的父节点。
    }
};