最近公共祖先lca

最新推荐文章于 2025-07-01 19:45:16 发布
最新推荐文章于 2025-07-01 19:45:16 发布
阅读量230 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_41183791/article/details/94333094

LCA-最近公共祖先

两个点在树上距离最近的公共祖先节点

lca有主要的两种算法

1.tarjan:离线算法,复杂度O(n+q)

2.倍增|RMQ:在线算法

1.在线算法:倍增法

倍增O(nlogn)查询

怎么求lca?

1.先将深度大的移动到小的一样深

2.然后同时尽往上跳,但没就是没有跳过lca点,最后会调到lca的两个子节点上

代码:

1.建树并预处理每个点的深度,每个点的第2^i个祖先的

2.求lca,从大到小枚举,让深度大的点一直往上跳,但一种>=(深度小的)

   判断是否移动到同一点,如果同一点,直接返回

3.两个点在同一深度,这时就方便一起往上跳,但是就是不能跳到同一点,最后会跳到lca的两个子节点上

建树&&预处理:

void dfs(int x,int fa)//件树,预处理每个节点的深度与第2^i个祖先
{
    grd[x][0]=fa;
    down[x]=down[fa]+1;
    for(int i=1;i<=20;i++)
        grd[x][i]=grd[grd[x][i-1]][i-1];//预处理x的第2^i个祖先
    for(int i=head[x];i;i=next1[i])
    {
        int v=to[i];
        if(v!=fa)
            dfs(v,x);
    }
}

lca部分代码:

因为预处理出的是第2^i个祖先,所以满足单调性,可以从大到小直接枚举

int lca(int x,int y)
{
    if(down[x]<down[y])
        swap(x,y);
    for(int i=20;i>=0;i--)//x一直往上跳,但x的深度一直>=y的深度
    {
        if(down[x]-(1<<i)>=y)
            x=grd[x][i];
    }
    if(x==y)//y是x的祖先
        return x;
    for(int i=20;i>=0;i--)//一起往上跳,但是就是不能跳到同一点,最后会跳到lca的两个子节点上
    {                     //i很大当然是同一祖先,直接从大到小枚举
        if(grd[x][i]!=grd[y][i])
            x=grd[x][i],y=grd[y][i];
    }
    return grd[x][0];
}

模板题:https://www.luogu.org/problem/P3379

洛谷p3389,求lca点

#include<bits/stdc++.h>
#define MAXN 1000005
using namespace std;
int to[MAXN<<1],next1[MAXN<<1],head[MAXN<<1];
int tot=0;
int down[MAXN];
int grd[MAXN][33];

void add(int u,int v)
{
    to[++tot]=v;
    next1[tot]=head[u];
    head[u]=tot;
}

void dfs(int x,int fa)//件树,预处理每个节点的深度与第2^i个祖先
{
    grd[x][0]=fa;
    down[x]=down[fa]+1;
    for(int i=1;i<=20;i++)
        grd[x][i]=grd[grd[x][i-1]][i-1];//预处理x的第2^i个祖先
    for(int i=head[x];i;i=next1[i])
    {
        int v=to[i];
        if(v!=fa)
            dfs(v,x);
    }
}

int lca(int x,int y)
{
    if(down[x]<down[y])
        swap(x,y);
    for(int i=20;i>=0;i--)//x一直往上跳,但x的深度一直>=y的深度
    {
        if(down[x]-(1<<i)>=y)
            x=grd[x][i];
    }
    if(x==y)//y是x的祖先
        return x;
    for(int i=20;i>=0;i--)//i很大当然是同一祖先,直接从大到小枚举
    {
        if(grd[x][i]!=grd[y][i])
            x=grd[x][i],y=grd[y][i];
    }
    return grd[x][0];
}

int main()
{
    int n,m,root,a,b;
    scanf("%d%d%d",&n,&m,&root);
    for(int i=1;i<=n-1;i++)
    {
        scanf("%d%d",&a,&b);
        add(a,b);
        add(b,a);
    }
    dfs(root,0);
    while(m--)
    {
        scanf("%d%d",&a,&b);
        printf("%d\n",lca(a,b));
    }
    return 0;
}

感谢:https://blog.youkuaiyun.com/qq_42790311/article/details/81486742

求距离:

lca_tarjan算法:

#include<bits/stdc++.h>
#define pb push_back
#define MAXN 100005
#define ll long long
using namespace std;

int to[MAXN*2],next1[MAXN*2],val[2*MAXN],head[MAXN*2];

int f[MAXN];
int dis[MAXN];
int vis[MAXN];
int lca[MAXN];
int ans[MAXN];

struct node
{
    int v,id;
};

vector<node> que[MAXN];

int tot,n;

void init()
{
    tot=0;
    for(int i=1;i<=n;++i)
    {
        head[i]=-1,f[i]=i,vis[i]=0;
        que[i].clear();
    }
}

void add(int x,int y,int z)
{
    to[++tot]=y;
    val[tot]=z;
    next1[tot]=head[x];
    head[x]=tot;
}

void add_que(int a,int b,int id)
{
    que[a].pb({b,id});
}

int get(int x)
{
    if(f[x]!=x)
        f[x]=get(f[x]);
    return f[x];
}

void tarjan(int x)
{
    vis[x]=1;
    for(int i=head[x];i!=-1;i=next1[i])
    {
        int v=to[i];
        if(vis[v])
            continue;
        dis[v]=dis[x]+val[i];
        tarjan(v);
        f[v]=x;
    }
    int sz=que[x].size();
    for(int i=0;i<sz;i++)
    {
        int v=que[x][i].v,id=que[x][i].id;
        if(vis[v]==2)
        {
            int lcav=get(v);
            ans[id]=min(ans[id],dis[x]+dis[v]-2*dis[lcav]);
        }
    }
    vis[x]=2;
}

int main()
{
    int t,m,a,b,c;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        init();
        for(int i=1;i<n;++i)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(a>b)
                swap(a,b);
            add(a,b,c);
        }
        for(int i=1;i<=m;++i)
        {
            scanf("%d%d",&a,&b);
            if(a>b)
                swap(a,b);
            if(a==b)
            {
                ans[i]=0;
            }
            else
            {
                add_que(a,b,i);
                ans[i]=1<<30;
            }
        }
        tarjan(1);
        for(int i=1;i<=m;++i)
            printf("%d\n",ans[i]);
    }
}

lca_rmq:

#include <bits/stdc++.h>

using namespace std;
const int MAXN=200005;
int n,m,tot,time1;
int to[MAXN],val[MAXN],next1[MAXN],head[MAXN];
int deep[MAXN];
int in[MAXN],out[MAXN];
int ST[MAXN*2][20];

void init()
{
    time1=tot=0;
    memset(head,-1,sizeof(head));
}

void add(int u,int v,int c)
{
    to[++tot]=v;
    val[tot]=c;
    next1[tot]=head[u];
    head[u]=tot;
}

void dfs(int x,int pre)
{
    in[x]=++time1;
    ST[time1][0]=x;
    for (int i=head[x];i!=-1;i=next1[i])
    {
        if (to[i]!=pre)
        {
            deep[to[i]]=deep[x]+val[i];
            dfs(to[i],x);
            ST[++time1][0]=x;
        }
    }
    out[x]=time1;
}

void Get_ST(int n)
{
    for (int i=1;i<=n;i++)
    {
        for (int j=1;j<20;j++)
        {
            ST[i][j]=ST[i][j-1];
            int v=i-(1<<(j-1));
            if (v>0&&deep[ST[v][j-1]]<deep[ST[i][j]])
                ST[i][j]=ST[v][j-1];
        }
    }
}

int RMQ(int L,int R)
{
    int val=floor(log(R-L+1)/log(2));
    int x=ST[L+(1<<val)-1][val],y=ST[R][val];
    return deep[x]<deep[y]?x:y;
}

int main()
{
    int t,a,b,c;
    scanf("%d",&t);
    while(t--)
    {
        init();
        scanf("%d%d",&n,&m);
        for (int i=1;i<n;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            add(a,b,c);
            add(b,a,c);
        }
        dfs(1,0);
        deep[0]=1e9;
        Get_ST(time1);
        while (m--)
        {
            scanf("%d%d",&a,&b);
            if (in[a]>in[b])
                swap(a,b);
            int LCA=RMQ(in[a],in[b]);
            printf("%d\n",deep[a]+deep[b]-deep[LCA]*2);
        }
    }
    return 0;
}

树上第k小

https://vjudge.net/problem/SPOJ-COT

题意:

求树上两点间路径第k小

解析:

数组上建主席树是root[i]在root[i-1]的基础上建链

树上建主席树是root[i]在root[fa[i]]的基础上建立链

树上两点间的路径有且仅有一条,且必过lca点,我们需要求lca

如果是求(a,b)的距离,呢么d(x,y)=d(1,x)+d(1,y)-2*d(1,lca);

但是这里不行,不能减去两个lca,x和y都算过包含1次lca,最后也要包含一次lca,所以最后减去的是fa(lca).要保留一个lca点

ac:

#include<bits/stdc++.h>
#define MAX 100005
#define MAXN 3000005
using namespace std;

int a[MAXN],b[MAXN],root[MAXN];
int L[MAXN],R[MAXN];
int sum[MAXN];
int tot=0,num=0,cnt=0;
int to[MAX<<2],nxt[MAX<<2],head[MAX<<2];
int down[MAX<<2];
int grd[100005][23];

void add(int u,int v)
{
    to[++cnt]=v;
    nxt[cnt]=head[u];
    head[u]=cnt;
}

int build(int l,int r)
{
    int now=+tot;
    sum[now]=0;
    if(l!=r)
    {
        int mid=(l+r)>>1;
        L[now]=build(l,mid);
        R[now]=build(mid+1,r);
    }
    return now;
}

int update(int pre,int l,int r,int k)
{
    int now=++tot;
    sum[now]=sum[pre]+1;
    L[now]=L[pre],R[now]=R[pre];
    if(l!=r)
    {
        int mid=(l+r)>>1;
        if(k<=mid)
            L[now]=update(L[pre],l,mid,k);
        else
            R[now]=update(R[pre],mid+1,r,k);
    }
    return now;
}

int query(int pre,int now,int lca,int flca,int l,int r,int k)
{
    if(l==r) return l;
    int mid=(l+r)>>1;
    int lcnt=sum[L[now]]+sum[L[pre]]-sum[L[lca]]-sum[L[flca]];
    if(k<=lcnt)
        return query(L[pre],L[now],L[lca],L[flca],l,mid,k);
    else
        return query(R[pre],R[now],R[lca],R[flca],mid+1,r,k-lcnt);
}

void dfs(int x,int fa)
{
    down[x]=down[fa]+1;
    grd[x][0]=fa;
    for(int i=1;i<=20;i++)//预处理倍增祖先
        grd[x][i]=grd[grd[x][i-1]][i-1];
    root[x]=update(root[fa],1,num,a[x]);//边dfs,边建链
    for(int i=head[x];i;i=nxt[i])
    {
        int v=to[i];
        if(down[v]==0)
            dfs(v,x);
    }
}

int LCA(int x,int y)//求lca
{
    if(down[x]<down[y])
        swap(x,y);
    for(int i=20;i>=0;i--)
        if(down[x]-(1<<i)>=down[y])
            x=grd[x][i];
    if(x==y)
        return y;
    for(int i=20;i>=0;i--)
        if(grd[x][i]!=grd[y][i])
            x=grd[x][i],y=grd[y][i];
    return grd[x][0];
}

void init()
{
    cnt=tot=num=0;
    memset(down,0,sizeof(down));
    memset(head,0,sizeof(head));
    memset(grd,0,sizeof(grd));
}

int main()
{
    int n,m,u,v,k;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init();
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]),b[i]=a[i];
        sort(b+1,b+n+1);
        num=unique(b+1,b+n+1)-b-1;
        for(int i=1;i<=n;i++)
            a[i]=lower_bound(b+1,b+1+num,a[i])-b;
        for(int i=1;i<=n-1;i++)
            scanf("%d%d",&u,&v),add(u,v),add(v,u);
        root[0]=build(1,num);
        down[0]=0;
        dfs(1,0);
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&u,&v,&k);
            int lca=LCA(u,v);
            printf("%d\n",b[query(root[u],root[v],root[lca],root[grd[lca][0]],1,num,k)]);//ans=u+v-lca-flca,(保留一个lca点)
        }
    }
    return 0;
}

 

 

Tao_oc
关注
模板 - LCA最近公共祖先（倍增法、Tarjan、树上差分、LCA优化的次小生成树）
繁凡さん的博客
07-23 816
注意LCA可以是自己 一、LCA的在线倍增算法 /*给定一棵包含 n个节点的有根无向树，有 m个询问，每个询问 给出了一对节点的编号 x和 y，询问 x与 y的祖孙关系。 注意要先算t，这里使用bfs防止爆栈，使用手写循环队列效率更高 */ const int N = 50007, M = 500007 ,INF = 0x3f3f3f3f; int t; int n, m; int ver[M], nex[M], edge[M], head[N],tot; int deep[N]; bool vis.
LCA算法
m0_59024001的博客
06-05 2934
LCA (Least Common Ancestor) 就是 最近公共祖先，就是在一个树上找到两个点最近的公共祖先 模板题 暴力 暴力的想法极其简单，比如我们可以 DFS 预处理出每个点的深度，然后通过暴力使它们的深度相等，然后每次都让它们向上走一个节点 倍增求LCA 这个想法慢在哪呢？慢在一个一个往上跳的地方，我们其实可以一段一段的往上跳，这就是倍增 LCA 最核心的地方，但是怎么计算每个点跳完一段之后的位置呢？我们可以预处理。那怎么设计每一段的长度保证每个点都可以通过一段一段的跳都能到达任意一点呢？很
求LCA的四种方法（暴力，倍增，RMQ+ST，Tarjan）
春弦的博客
02-27 6656
P3379 【模板】最近公共祖先（LCA） #include<bits/stdc++.h> using namespace std; struct Edge { int to,next; }edge[500005*2];//无向图，两倍开 int head[500005],grand[500005][21],depth[500005],lg[500001]; int cnt,n,m,s; inline int read() { int x=0,f=1;char ch=getch.
最近公共祖先LCA算法
最新发布
lwltql的博客
07-01 981
我是菜鸟ACMer（qwq），之前学图论板块的LCA算法做的一些笔记，适合小白，分享出来希望能帮助大家！
浅谈 LCA
weixin_30699465的博客
10-08 189
LCA问题 一.概述： 　　在图论与计算科学中，两个节点v与w在有向无环图(directed acyclic graph , DAG)或树中的最近公共祖先(Lowest common anccestor , LCA) 是这两个节点v 与 w的深度最深的祖先。我们定义，该深度最深的节点为v与w的最近公共最先，即LCA 。 例如，在下图中 LCA ( A , B...
c++最近公共祖先LCA
zhaoniuniu0309的博客，刚刚开始写博文的新手，有不对的地方请谅解。
07-22 1881
今天来介绍一个c++中的算法：最近公共祖先LCA。最近公共祖先是什么呢？就是给出在树上的两个节点，求出它们的最近公共祖先，也可以理解成深度最深的公共祖先。这个算法用处很大，比如我们可以用它来求任意两个节点的距离。具体后面会讲。i++){//i从1开始！= edge[now][i]){//注意！！now的儿子不能再回到now的父亲了h;i++, h >>= 1){//例如h = (1011)2，那么第一次要跳，并且跳2^1也就是2^0级。
【模版】最近公共祖先LCA(链剖)
01-07
最近公共祖先LCA(链剖) 给定一棵 以 sss 为根节点，共有 nnn 个点的树。 有 mmm 次查询 每次查询 u,vu ,vu,v 的最近公共祖先。 算法流程 111.根据连边的信息建图（邻接表）。代码就不贴了，注意建立双向边。 222....
最近公共祖先LCA(C++版).docx
05-20
最近公共祖先（Lowest Common Ancestor，LCA） 最近公共祖先（Lowest Common Ancestor，LCA）是指在一棵树上，两个节点的最近公共祖先节点。也就是说，两个点在这棵树上的距离最近的公共祖先节点。LCA 是一个基本...
LCA (最近公共祖先) Tarjan & 倍增
01-03
LCA Tarjan： 实现原理 理解：离线算法，建好树后再查询，一次DFS 吧所有查询解决完。 时间复杂度：O(n+q)； n个点 q次询问 补一下：链式向前星，并查集 ，Tarjan 代码 #include #include #include #include #...
习题加餐5. 最近公共祖先LCA查询
tang7mj的博客
03-25 924
树的深度优先搜索（DFS）基础DFS应用：通过DFS遍历树来计算节点深度、父节点、子树大小等基本属性，这是许多树相关算法的基础。递归思维：理解和应用递归思维来处理树结构，是解决树相关问题的关键。
LCA总结
why932346109的博客
03-27 1754
概述篇 LCA (Least Common Ancestors) ，即最近公共祖先，是指这样的一个问题：在一棵有根树中，找出某两个节点 u 和 v 最近的公共祖先。 LCA 可分为在线算法与离线算法 在线算法：指程序可以以序列化的方式一个一个处理输入，也就是说在一开始并不需要知道所有的输入。 离线算法：指一开始就需要知道问题的所有输入数据，而在解决一个问题后立即输出结果。 算法篇 ...
算法学习系列（六十二）：LCA（最近公共祖先）：倍增法、Tarjan算法
weixin_60033897的博客
05-15 1571
关于这个 $LCA$ 问题蓝桥杯这两年考的是也是越来越多了，尤其是去年直接出了个裸题（模板题），也是没想到的，再加上今年省赛 $java$ 组也出了一道与之相关的题，所以今年国赛感觉出的几率也是有的。学下来发现其实也没那么难，又是自己想神秘了，思路和代码总的来说都不是很难，难的是想法，这道题你能否能想到用 $LCA$ 做才是关键，所以本章内容还是采用讲题的策略来进行讲解，就其实都是非常经典的问题，几乎都是模板题，但是我觉得蓝桥杯应该不会出特别难的了，因为本身这个算法就很难，还是要多写写熟即可，继续加油吧！
【算法详解】LCA（最近公共祖先）
魃魈魁鬾魑魅魍魉的博客
02-17 777
定义： Lca（最近公共祖先） 指在一棵有根树中任意222个节点u,vu,vu,v最近的公共祖先。 如下图： 如右图，结点4，64，64，6的公共祖先有1、21、21、2，但最近的公共祖先是222，即Lca(4,6)=2Lca(4,6) = 2Lca(4,6)=2。 如何求得u,vu,vu,v的最近公共祖先呢？ 算法一：暴力 现在有一个最朴素的算法，暴力。 111.u，v中深度大的往上走，直到...
LCA详解
热门推荐
刘伟的博客
10-18 2万+
LCA问题(least Comment Ancestors,最近公共祖先问题),是指给定一棵有根树T,给出若干个查询LCA(u,v)(通常查询数量较大)， 每次求树T中两个顶点u和v的最近公共祖先，即找到一个节点，同时是u和v的祖先，并且深度尽可能的大(尽可能远离树根). LCA问题的解法有很多，有一般解法，基于tarjan的解法，跳表解法以及RMQ和LCA互相转化的解法。下面我们依次
【图论】—— 最近公共祖先（LCA）
forever_bryant的博客
06-16 2281
【图论】—— 最近公共祖先（LCA）
LCA学习笔记
stldecember的博客
08-05 322
LCA一共学习了三种方法，分别是 1.倍增 2.RMQ 3.树链剖分 首先是倍增，先是预处理，倍增需要处理出f[i][x] 表示x点向上走2的i次方所到的点，先处理所有f[0][x]，f[0][x] = father[x]，因为x点向上走2的0次方(也就是1)就是它的父亲，然后再推到f[i][x] = (f[i - 1][f[i - 1][x]])表示先从x点向上走2的i - 1次方，然后再向上走...
LCA 学习笔记
OI1314的博客
04-10 224
据我所知，实现LCA有三种方法：基于二分搜索、基于RMQ、树链剖分 基于二分搜索其实就是对父子节点做一个2^k表，也就是倍增的思想，但是这个二分搜索的搜索方式有点与众不同 int lca(int u,int v) { if(depth[u]>depth[v]) swap(u,v); for(int k=0;k<max_log_v;k++) { if((depth[v]-depth[u])>>k&1) {
最近公共祖先LCA查询 蓝桥杯
02-26
### 关于最近公共祖先（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、付费专栏及课程。

余额充值