节点的最近公共祖先(LCA倍增法)

本文介绍了一种解决树上节点最近公共祖先问题的高效算法。通过预处理深度和父亲节点,利用二进制提升技巧,实现了快速查找任意两节点的最近公共祖先。算法适用于大规模树形结构,如社交网络、文件系统层级等。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

问题描述

树是一种很常见的数据结构。现在蒜头君面临一个问题,在一个有 n 个节点的树上,节点编号分别是1…n。蒜头想知道一些节点之间的最近公共祖先是那些节点。
输入格式
第一行输入一个整数 n(2≤n≤10,000),表示树上有 n 个节点。
接下来的 n−1 行,每行输入俩个整数 a,b(1≤a,b≤n)代表节点 a,b 之间有一条 a 到 b 边,a 是 b 的父亲。
接下来输入一个整数 q,代表蒜头君的 q 次提问。(1≤q≤1,000)
接下来的 q 行,每行输入俩个整数 c,d(1≤c,d≤n)代表询问 c,d 俩个节点的最近公共祖先。
输出格式
对于每次询问,输出公共祖先的节点编号,占一行。
样例输入
5
1 2
2 3
1 4
2 5
2
3 4
3 5
样例输出
1
2

ac代码

#include <iostream>
#include <cstring>
#include <cstring>
#include <cstdio>
using namespace std;

const int MAXN=1e4+1;//最大的点数
struct edge{
    int v,next;//边的终点,同起点的上一条边的序号
    edge(){}
    edge(int _v,int _next):v(_v),next(_next){}//构造函数
}e[MAXN];
int p[MAXN],vst[MAXN],d[MAXN],fa[MAXN][20];//存储边的序号的头指针,标记数组,存储深度,fa[i][j]为i往上走(2^j)层的序号
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;//儿子等于父亲节点深度+1
            fa[e[i].v][0]=u;//记录父亲节点
            dfs(e[i].v);//递归更新深度和父亲
        }
    }
}
int lca(int x,int y){
    if(d[x]<d[y]){//始终让x节点为深一点的节点
        swap(x,y);
    }
    int i,j;
    for(i=0;(1<<i)<=d[x];++i);//找出(2^i<=n),找出i的最大值,保证不会超出树
    --i;
    //深的节点先往上走,走到和y节点同一层
    for(j=i;j>=0;--j){//先走大步
        if(d[x]-(1<<j)>=d[y]){//若往上走了(2^j)个数,任然深度比较大,
            x=fa[x][j];//就走之后的点为起点继续走
        }
    }
    if(x==y)return x;//若走到同一层时,两者相等,则y就是原先节点的父节点
    for(j=i;j>=0;--j){
//        if(x!=y){//自己第一个次是这样写的,(有bug),
//            x=fa[x][j];
//            y=fa[y][j];
//        }
        if(fa[x][j]!=fa[y][j]){//这样走下去,会走到深度最小的不等于两者不相同的点
            x=fa[x][j];
            y=fa[y][j];
        }
    }
    return fa[x][0];//此时x和y的父节点就是最近公共祖先
}

int main()
{
    int n;
    scanf("%d",&n);
    memset(vst,0,sizeof(vst));
    memset(p,-1,sizeof(p));
    for(int i=0;i<n-1;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        e[i]=edge(v,p[u]);
        p[u]=i;
        vst[v]=1;
    }
    int root;
    for(int i=1;i<=n;++i){
        if(!vst[i]){
            root=i;
            break;
        }
    }
    memset(d,-1,sizeof(d));
    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;
    scanf("%d",&q);
    while(q--){
        int c,d;
        scanf("%d%d",&c,&d);
        printf("%d\n",lca(c,d));
    }
}

### 关于最近公共祖先LCA)问题的解法 #### 定义与背景 最近公共祖先(Lowest Common Ancestor, LCA),是指在一棵树中找到两个节点的最低共同父节点。这个问题在处理树形结构的数据时非常常见,在蓝桥杯竞赛以及其他编程比赛中也经常作为考察点之一。 #### 基础方法:暴力遍历 最简单的方法是从根节点开始向下逐层比较给定的两个目标节点的位置关系,直到遇到第一个能同时到达这两个节点的分支点为止。这种方法虽然直观易懂,但在大型或深层级数较多的情况下效率较低[^1]。 #### 改进方案:倍增算法 一种更高效的解决方案是采用倍增算法来求解LCA问题。此方法预先通过动态规划的方式记录下每个节点向上跳转\(2^i\)步后的祖先位置,从而可以在O(logN)时间内完成查询操作。具体步骤如下: - **预处理阶段**:对于每一个节点u及其高度h(u)算并存储其所有可能的\(2^k\)-th父母节点parent[u][k]。 ```cpp void dfs(int u,int fa){ parent[u][0]=fa; depth[u]=depth[fa]+1; for (int i=1;(1<<i)<=depth[u];++i) parent[u][i]=parent[parent[u][i-1]][i-1]; // ...其他逻辑... } ``` - **查询阶段**:当需要寻找两节点u和v之间的LCA时,先调整两者至相同深度再逐步上移直至相遇。 ```cpp int lca_query(int u,int v){ if(depth[u]<depth[v]) swap(u,v); while(depth[u]>depth[v]){ int k=log2(depth[u]-depth[v]); u=parent[u][k]; } if(u==v)return u; for(int k=max_level;k>=0;--k){ if(parent[u][k]!=parent[v][k]){ u=parent[u][k]; v=parent[v][k]; } } return parent[u][0]; } ``` 这种基于倍增的思想不仅适用于普通的无权有向树,也可以扩展到加权边的情况,并且能够很好地满足比赛中的时间复杂度要求[^2]。 #### 应用于蓝桥杯竞赛 考虑到蓝桥杯对参赛者的基础知识掌握程度有一定要求,建议深入理解上述两种基本策略的基础上,多做练习题巩固知识点。特别是针对不同类型的输入规模优化自己的解答方式,提高程序运行速度和准确性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值