最近公共祖先问题（LCA）

北向眼

已于 2022-08-06 22:56:09 修改

阅读量269

点赞数 1

分类专栏：图论文章标签：深度优先图论算法

于 2022-08-06 18:58:27 首次发布

本文链接：https://blog.csdn.net/qq_51704853/article/details/126196719

版权

图论专栏收录该内容

9 篇文章 0 订阅

订阅专栏

题目链接：P3379 【模板】最近公共祖先（LCA） - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

暴力思路1：

若给定两个点，从一个点更新到它的根节点，将其遍历过的点的状态设为true，另一个点往根节点走，第一个碰到x更新过的点即为他们的最近公共祖先

dfs()写的是从根结点往下走，先到达的优先度更高，因为存的双向边，所以会存在重复情况要判段是否已经设为另一个点的父节点了

ps:题目中若直接说明在输入中给出父子关系可以直接用p数组存

实现代码：

#include<bits/stdc++.h>
using namespace std;
const int N=5e5+10;
int n,m,s,p[N];//结点个数，询问个数，根节点，父节点数组
vector<int> g[N];
bool vis[N];

void dfs(int u){
    //遍历u的所有邻接点
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(v==p[u]) continue;//如果v已经存为了u的父节点跳过
        p[v]=u;//否则u就是v的父节点
        dfs(v);//跳到下一个点；
    }
}
int lca(int x,int y){
    memset(vis,0,sizeof vis);
    while(x){
        vis[x]=true;
        x=p[x];
    }
    while(!vis[y]) y=p[y];//当y走到x标记过的结点，输出当前位置
    return y;
}
int main(){
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    cin>>n>>m>>s;
    for(int i=1;i<n;i++){
        int a,b;
        cin>>a>>b;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    dfs(s);//s为根结点从s开始
    while(m--){
        int a,b;
        cin>>a>>b;
        cout<<lca(a,b)<<endl;
    }
    return 0;
}

暴力思路2：

这个暴力解法就有利于拓展到倍增算法了，思路就是以x深度更高为例，让x走到与y相同的深度，走到了之后，x和y同时网上走一步，直到两个数相等时即为最近公共祖先

相比前一个算法，不需要多开一个状态数组，但是要多开一个深度数组，时间复杂度均为On但是这个比刚刚的还是要快一些的

实现代码

#include<bits/stdc++.h>
using namespace std;
const int N=5e5+10;
int n,m,s,p[N],dep[N];//结点个数，询问个数，根节点，父节点数组，深度数组
vector<int> g[N];
bool vis[N];
void dfs(int u){
    //遍历u的所有邻接点
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(v==p[u]) continue;//如果v已经存为了u的父节点跳过
        p[v]=u;//否则u就是v的父节点
        dep[v]=dep[u]+1;
        dfs(v);//跳到下一个点；
    }
}
int lca(int x,int y){
    if(dep[x]<dep[y]) swap(x,y);//保持x深度比y大
    while(dep[x]>dep[y]) x=p[x];//让x走到与y相同的深度
    while(x!=y){
        x=p[x];
        y=p[y];
    }
    //直到两个点相同即为lca
    return x;
}
int main(){
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    cin>>n>>m>>s;
    for(int i=1;i<n;i++){
        int a,b;
        cin>>a>>b;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    dfs(s);//s为根结点从s开始
    while(m--){
        int a,b;
        cin>>a>>b;
        cout<<lca(a,b)<<endl;
    }
    return 0;
}

以上就是两个暴力算法的思路，下面讲解一下倍增算法

倍增LCA

思路和暴力算法2类似，但是暴力算法2往上跳是一个一格往上跳，倍增算法就不同了

先来介绍一下变量申请

const int N=5e5+10; //最大个数
vector<int> g[N];//储存边
int n,m,s;//结点个数，询问个数，根节点
int dep[N],fa[N][20];//深度数组，父节点数组

再来讲一下st表怎么打

我们可以先把每个结点跳2的倍数个结点到的位置打出来一张表，存进fa[N][20]中，fa数组存放的是一个结点往上跳n次方到达的结点数，为什么开的20，这个视题目数据范围分析，样例中结点个数最多为5e5+10，而我们知道2的20次方是100万，所以这里开到19就够了

我们把一个结点往上跳2的i次方写成两次，每次跳2的i-1次方

dfs函数，每次传入当前结点和父节点

void dfs(int u,int father){//当前结点和父节点
    dep[u]=dep[father]+1;//更新距离
    fa[u][0]=father;//当前结点往上跳2的0次方为父节点
    for(int i=1;i<=19;i++){//跳19次
        fa[u][i]=fa[fa[u][i-1]][i-1];
    }
    //遍历当前结点的边中，当前结点的子节点
    for(int v: g[u]){
        if(v!=father) dfs(v,u);
    }
}

对于遍历这一块可以看下上面暴力写法中写的，当前结点所有的边中只有一个父节点，其余均为子节点，再加上从根节点往下遍历，结点具有优先顺序，所以这里传入的为所有的相邻的点就够了

lca函数（这里是重点咯）

直接全写代码注释中了，看的更加清晰

int lca(int u,int v){
    if(dep[u]<dep[v]) swap(u,v);//保证左边的深度最大
    for(int i=19;i>=0;i--){
        if(dep[fa[u][i]]>=dep[v]) u=fa[u][i];
    }//让u和v在同一深度上
   //这里用2进制跳跃，就不用和前面一个个跳跃麻烦，如果往上跳2的i次方深度还比v大就跳上去
   //最终能保证一定可以跳到和v相同的深度，因为数都可以用二进制表示
    if(u==v) return v;
   //如果直接当前点就是，那么直接返回，这里返回u也可以，因为两个已经是公共祖先了
   //备注一下，为什么要判段呢，因为下面的判段最少只能跳到他的父节点，如果本身就是不会判段
    for(int i=19;i>=0;i--){
        if(fa[u][i]!=fa[v][i]){
            u=fa[u][i],v=fa[v][i];
        }
    //这里是重点，当前结点要跳到最近公共祖先的下面一个结点，保证两个一直不相等
    //想一想，如果相等了，很可能跳不是最近的，所以我们一直跳不相等的，让最后一部跳一个父节点
    }
    return fa[u][0];
}

最后一部再解释一下：两个点在相同深度了，他们的最近公共祖先一定在他们往上走相同距离的路上。所以这里从19次方往上跳，如果不同就说明还可以往上跳，相同就说明跳过了。

如果跳到了结果呢？那也是跳过了，最后往上还会走一步，走的最后一部才是答案，这里要求的是不通的，有点类似于二分的想法

完整实现代码：

#include<bits/stdc++.h>
using namespace std;
const int N=5e5+10;
vector<int> g[N];
int n,m,s;
int dep[N],fa[N][20];

void dfs(int u,int father){
    dep[u]=dep[father]+1;
    fa[u][0]=father;
    for(int i=1;i<=19;i++){
        fa[u][i]=fa[fa[u][i-1]][i-1];
    }
    for(int v: g[u]){
        if(v!=father) dfs(v,u);
    }
}


int lca(int u,int v){
    if(dep[u]<dep[v]) swap(u,v);
    for(int i=19;i>=0;i--){
        if(dep[fa[u][i]]>=dep[v]) u=fa[u][i];
    }
    if(u==v) return v;
    for(int i=19;i>=0;i--){
        if(fa[u][i]!=fa[v][i]){
            u=fa[u][i],v=fa[v][i];
        }
    }
    return fa[u][0];
}
int main(){
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    int a,b;
    cin>>n>>m>>s;
    for(int i=1;i<n;i++){
        cin>>a>>b;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    dfs(s,0);//打表，更新好每个点往上走2的i次方的距离
    for(int i=1;i<=m;i++){
        cin>>a>>b;
        cout<<lca(a,b)<<endl;
    }
    return 0;
}

end~