最近公共祖先（LCA）

最新推荐文章于 2024-05-30 16:17:47 发布
最新推荐文章于 2024-05-30 16:17:47 发布
阅读量907 收藏 26
点赞数 8
分类专栏： 图论 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74120503/article/details/136178470
版权

lca是在树上的概念，从根节点到某个点的最短路径上所有的点，都可以视为该点的祖先。而最近公共祖先就是对于两个点来说，距离最近的公共祖先，有两种情况，一种是这个祖先是其中一个点，另一种情况是这个祖先并非两点之中的任何一个点。

有三种算法可以求lca:

1.标记法，找出一个目标点的最短路，记录路径，然后从目标点往根节点遍历，标记最短路径，再从另一个点这么做一遍，当另一个点往前遍历的时候，最早遇到的被标记过的点就是所求。
一次查询O(n)

2.倍增法，这个方法比较巧妙，也是三种做法中最容易实现的。原理就是利用二进制优化，维护一个数组f[i][k]表示从i开始往上跳2^k个点后会落到哪个点。这个数组看似统计麻烦，但实际上可以用递推来实现：f[i][k]=f[f[i][k-1]][k-1]；另外还有预处理每个点所在的层数，对于两个点，先将它们调整到同一层，然后再一起往上找，找到最小的f[i][k]!=f[j][k],然后再往上一步就是答案。
预处理：O(nlogn)
查询：O(logn)

3.Tarjan，这个用于离线处理（先全部读入，最后统一输出）lca问题，实际上是对标记法的一个优化。将图中所有的点分为3类：

0.没有被遍历过的点 
1.遍历过还没有回溯过的点
2.遍历过且已经回溯过的点

对于正在遍历的点，如果要求它与已经回溯过的点之间的公共祖先，如图c与a，那么就是b；c与d，那么就是e，也即已回溯点所在子树的根节点，不用担心每次都找到根节点，如果是正在遍历的路径上的点如点e，由于还没有回溯，所以它的根节点就是它自己，所在在找d与c的时候就不会出差错。所以我们只要在回溯的时候再修改每个点的父节点即可实现。
时间复杂度O(n+m)(n是点数，m是询问数)

我们结合例题来具体分析一下。

1172. 祖孙询问（活动 - AcWing）

 思路：这题很直白，求出两点的公共祖先，然后判断是否是两点中的任何一个。

#include<bits/stdc++.h>
using namespace std;
const int N=40010,M=80010;
int n,m,q;
int h[N],e[M],ne[M],idx;
int dep[N];
int fa[N][20];
void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void dfs(int u,int f)
{
    dep[u]=dep[f]+1;//0层置空
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==f) continue;
        fa[j][0]=u;
        for(int k=1;k<=15;k++) fa[j][k]=fa[fa[j][k-1]][k-1];
        dfs(j,u);
    }
}
int lca(int x,int y)
{
    if(dep[x]<dep[y]) swap(x,y);
    for(int i=15;i>=0;i--)
    {
        if(dep[fa[x][i]]>=dep[y]) x=fa[x][i];
    }
    if(x==y) return x;
    for(int i=15;i>=0;i--)
    {
        if(fa[x][i]!=fa[y][i]) 
            x=fa[x][i],y=fa[y][i];
    }
    return fa[x][0];
}
int id[N];
int main()
{
    scanf("%d",&m);
    int r;
    memset(h,-1,sizeof h);
    for(int i=1;i<=m;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        if(b!=-1) add(a,b),add(b,a);
        else r=a;
    }
    dfs(r,r);
    scanf("%d",&q);
    while(q--)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        int p=lca(x,y);
        if(p==x) printf("1\n"); 
        else if(p==y)printf("2\n"); 
        else printf("0\n"); 
    }
}

1171. 距离(活动 - AcWing)

这个题如果用倍增法，那么时间复杂度就O(nlogn+mlogn)，虽然能写，但是这种询问比点还多的情况，我们可以用Tarjan算法来写。

#include<bits/stdc++.h>
using namespace std;
const int N=10010,M=20010;
int n,m;
int h[N],e[M],ne[M],w[M],idx;
int p[N],st[N],ans[M],d[N];
vector<pair<int,int>>q[N];


void add(int a,int b,int c)
{
    w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void dfs(int u,int f)
{
    for(int i=h[u];~i;i=ne[i])
    {
        int j=e[i];
        if(j==f) continue;
        d[j]=d[u]+w[i];
        dfs(j,u);
    }
}
int find(int x)
{
    if(x!=p[x]) p[x]=find(p[x]);
    return p[x];
}
void Tarjan(int u)
{
    st[u]=1;
    for(int i=h[u];~i;i=ne[i])
    {
        int j=e[i];
        if(!st[j]) 
        {
            Tarjan(j);
            p[j]=u;
        }
    }
    for(auto it:q[u])
    {
        int y=it.first,id=it.second;
        if(st[y]==2)
        {
            int anc=find(y);
            ans[id]=d[u]+d[y]-2*d[anc];
        }    
    }
    st[u]=2;
}
int main()
{
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    for(int i=0;i<n-1;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c),add(b,a,c);
    }
    
    for(int i=0;i<m;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        if(a!=b)
        {
            q[a].push_back({b,i});
            q[b].push_back({a,i});
        }
    }
    for(int i=1;i<=n;i++) p[i]=i;
    dfs(1,-1);
    Tarjan(1);
    for(int i=0;i<m;i++) printf("%d\n",ans[i]);
    return 0;
}

ps:ans数组要开到和询问一样大，一定要注意这一点。

356. 次小生成树（356. 次小生成树 - AcWing题库）

思路：求次小生成树问题，我们之前的做法是预处理树上任意两点之间的路径的边权最大值和最小值，然后枚举每条非树边 ，计算用这条边进行替换后的结果是多少，统计一个最小值。这个算法要对每个点进行一次dfs，时间复杂度还是有点高，这里我们可以用lca算法进行优化。具体步骤如下：

先kluskal求出最小生成树，然后根据最小生成树建一张无向图，然后用倍增法写lca，在lca预处理的时候，将d1[i][k]、d2[i][k]（i上跳2^k的过程中的所经过的边的最大值和次大值）预处理出来，对所有的非树边执行lca查询，在lca查询的时候，将两个到最近公共祖先的过程中经过的所有最大值和次大值存下来，然后找出总的最大和次大，进行计算，返回结果。

这里用到的性质就是，树上两点之间的最短距离就是两者到lca的路径长度之和，所以我们可以通过lca的倍增算法来优化查找两者路径上边权最大和次大的长度。

#include<bits/stdc++.h>
using namespace std;
const int N=100010,M=300010,inf=0x3f3f3f3f;
int n,m;
struct edge{
    int a,b,c;
    bool flag;
    bool operator<(const edge &x) const{
        return c<x.c;
    }
}ed[M];
int p[N];
int h[N],e[M],ne[M],w[M],idx;
int dep[N],fa[N][20],d1[N][20],d2[N][20];
int q[N];
void add(int a,int b,int c)
{
    w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
long long kluskal()
{
    for(int i=1;i<=n;i++) p[i]=i;
    sort(ed+1,ed+1+m);
    memset(h,-1,sizeof h);
    long long res=0;
    for(int i=1;i<=m;i++)
    {
        int a=ed[i].a,b=ed[i].b,c=ed[i].c;
        int pa=find(a),pb=find(b);
        if(pa!=pb)
        {
            add(a,b,c),add(b,a,c);
            p[pa]=pb;
            res+=c;
            ed[i].flag=1;
        }
    }
    return res;
}

void dfs(int u,int f)
{
    dep[u]=dep[f]+1;
    for(int i=h[u];~i;i=ne[i])
    {
        int j=e[i];
        if(j==f) continue;
        fa[j][0]=u;
        d1[j][0]=w[i],d2[j][0]=-inf;
        for(int k=1;k<=16;k++)
        {
            int anc=fa[j][k-1];
            fa[j][k]=fa[anc][k-1];
            int td[]={d1[j][k-1],d2[j][k-1],d1[anc][k-1],d2[anc][k-1]};
            d1[j][k]=d2[j][k]=-inf;
            for(int u=0;u<4;u++)
            {
                if(td[u]>d1[j][k]) d2[j][k]=d1[j][k],d1[j][k]=td[u];
                else if(td[u]!=d1[j][k]&&td[u]>d2[j][k]) d2[j][k]=td[u];
            }
        }
        dfs(j,u);
    }
}

int dist[2*N];
int lca(int a,int b,int c)
{
    int cnt=0;
    if(dep[a]<dep[b]) swap(a,b);
    for(int i=16;i>=0;i--)
    {
        if(dep[fa[a][i]]>=dep[b])
        {    
            dist[cnt++]=d1[a][i];
            dist[cnt++]=d2[a][i];
            a=fa[a][i];
        }
    }
    if(a!=b)
    {
        for(int i=16;i>=0;i--)
        {
            if(fa[a][i]!=fa[b][i])
            {
                dist[cnt++]=d1[a][i];
                dist[cnt++]=d2[a][i];
                dist[cnt++]=d1[b][i];
                dist[cnt++]=d2[b][i];
                a=fa[a][i],b=fa[b][i];
            }
        }
        dist[cnt++]=d1[a][0];
        dist[cnt++]=d1[b][0];
    }
    int td1=-inf,td2=-inf;
    for(int i=0;i<cnt;i++)
    {
        int d=dist[i];
        if(d>td1) td2=td1,td1=d;
        else if(d!=td1&&d>td2) td2=d;
    }
    if(c>td1) return c-td1;
    else if(c>td2) return c-td2;
    else return inf;
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        ed[i]={a,b,c};
    }
    long long sum=kluskal();
    dfs(1,1);
    long long mi=1e18;
    for(int i=1;i<=m;i++)
    {
        if(!ed[i].flag)
        {
            mi=min(mi,sum+lca(ed[i].a,ed[i].b,ed[i].c));
        }
    }
    cout<<mi;
}

352. 闇の連鎖(352. 闇の連鎖 - AcWing题库)

 思路：这道题的主要边构成了一棵树，

如图的非树边a，如果第一次砍的是树上的红色路径，那么很显然第二次只能砍a；如果不是，第二次就可以 

如果再加一条绿色的非树边，那么显然如果砍了两条路径重合的边，那么需要把两条路径都砍断才能分，如果砍了各自的路径，那么只用再砍对应的一条即可，如果砍了非路径的边，那么两条任砍其一即可。所以我们只需要直到每一条主要路径砍完还需要砍多少条非树边即可实现。

这里我们对于一条非树边，它们的最短路径上所有的边的值都要加1，这里可以利用差分实现，即，两点的d各加1，lca的d减2.

统计的时候就dfs即可，先一直往下搜，然后返回一个值表示以当前节点为根的子树的中砍边的情况。相当于把边上的权值赋给点，或者再仔细一点就是将每个点的入边上的值赋给这个点，每个点只有一个入边，在根节点处刚好全部抵消没有任何影响。（标记点搜点更容易）

#include<bits/stdc++.h>
using namespace std;
const int N=100010,M=200010;
int n,m;
int ans;
int dep[N];
int h[N],e[M],ne[M],idx;
int fa[N][20];
int d[N];
void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void dfs1(int u,int f)
{
    dep[u]=dep[f]+1;
    for(int i=h[u];~i;i=ne[i])
    {
        int j=e[i];
        if(j==f) continue;
        fa[j][0]=u;
        for(int k=1;k<=16;k++)
        {
            int anc=fa[j][k-1];
            fa[j][k]=fa[anc][k-1];
        }
        dfs1(j,u);
    }
}
int lca(int a,int b)
{
    if(dep[a]<dep[b])swap(a,b);
    for(int i=16;i>=0;i--)
        if(dep[fa[a][i]]>=dep[b])
            a=fa[a][i];
    
    if(a==b) return a;
    
    for(int i=16;i>=0;i--)
        if(fa[a][i]!=fa[b][i])
            a=fa[a][i],b=fa[b][i];

    return fa[a][0];
}
int dfs(int u,int f)
{
    int res=d[u];
    for(int i=h[u];~i;i=ne[i])
    {
        int j=e[i];
        if(j==f) continue;
        int s=dfs(j,u);
        if(s==0) ans += m;
        else if(s==1) ans+=1;
        res += s;     
    }
    return res;
}
int main()
{
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    for(int i=1;i<n;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b),add(b,a);
    }
    dfs1(1,1);
    for(int i=0;i<m;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        int p=lca(a,b);
        d[a]++,d[b]++,d[p]-=2;
    }
    dfs(1,1);
    cout<<ans;
}
as_sun
关注
  • 8
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最近公共祖先
lucaiscxy的博客
03-06 231
接下来处理不是的情况，比如输入是7和4，上图的话应该祖先是2 ，，那么我们想想，如果遍历2的时候，假如2的左子树存在[7,4]中的一个的同时，右子树也存在一个[7,4]的值（题目说了不会有重复数字），说明2绝壁就是公共祖先，那么2是不是最近的祖先？示例 2: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出: 5 解释: 节点 5 和节点 4 的最近公共祖先是节点 5。给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
【模版】最近公共祖先LCA(链剖)
01-07
最近公共祖先LCA(链剖) 给定一棵 以 sss 为根节点，共有 nnn 个点的树。 有 mmm 次查询 每次查询 u,vu ,vu,v 的最近公共祖先。 算法流程 111.根据连边的信息建图（邻接表）。代码就不贴了，注意建立双向边。 222....
作业二叉树求最近公共祖先
11-08
C语言所写源代码有注释，哈工大数据结构实验课自己所作，仅供参考
面试题68 – II. 二叉树的最近公共祖先
01-06
面试题68 – II. 二叉树的最近公共祖先 【简单题】【递归】 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）” 例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4] 输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出：3 解释：节点 5 和节点 1 的最近公共祖先是节点 3 输入：root
最近公共祖先(LCA)详解
m0_74732859的博客
04-24 504
1.前言 公共祖先问题是指在一个树结构中，找到两个节点的最近公共祖先（Lowest Common Ancestor, LCA）。公共祖先指的是两个节点的某个祖先节点，而最近公共祖先则指的是离这两个节点最近的共同的祖先节点
LCA.tar.zip_二叉树的最近公共祖先问题
09-20
设计一个算法，对于给定的树中2 结点返回它们的最近公共祖先。 对于给定的树，和树中结点对，编程计算结点对的最近公共祖先。
二叉树最近最近公共祖先
05-15
Java语言，通过栈的方法建立二叉树，递归求最近共同祖先结点
图论--最近公共祖先LCA
信息学奥赛学案
07-08 1901
求最近公共祖先LCA的三种方法
c++最近公共祖先LCA
zhaoniuniu0309的博客，刚刚开始写博文的新手，有不对的地方请谅解。
07-22 1112
今天来介绍一个c++中的算法：最近公共祖先LCA。最近公共祖先是什么呢？就是给出在树上的两个节点，求出它们的最近公共祖先，也可以理解成深度最深的公共祖先。这个算法用处很大，比如我们可以用它来求任意两个节点的距离。具体后面会讲。i++){//i从1开始！= edge[now][i]){//注意！！now的儿子不能再回到now的父亲了h;i++, h >>= 1){//例如h = (1011)2，那么第一次要跳，并且跳2^1也就是2^0级。
最近公共祖先LCA倍增算法
weixin_46503238的博客
09-25 525
LCA定义 LCA(Least Common Ancestors):最近公共祖先即两个结点最近的公共祖先 由上图可以看到 5号结点和7号结点的LCA为3号结点,9号结点和7号结点的LCA为7号结点。 一般算法 首先可以将两个结点统一到相同深度,然后一起向上一步一步走,直到他们踩到相同点,则该点为他们的LCA 。 (树的深度:与根节点的距离则为树的深度,根节点的深度为0或者1,根据个人喜好设置) 复杂度分析 因为每次向上走一步,最多n个结点深度最大也就为n,所以最多也就走n步,复杂度为O(n)
最近公共祖先 LCA
kzhshsh的博客
08-08 107
LCA 算法分享
最近公共祖先LCA(C++版).docx
05-20
。。。
LCA (最近公共祖先) Tarjan & 倍增
01-03
LCA Tarjan： 实现原理 理解：离线算法，建好树后再查询，一次DFS 吧所有查询解决完。 时间复杂度：O(n+q)； n个点 q次询问 补一下：链式向前星，并查集 ，Tarjan 代码 #include #include #include #include #...
最近公共祖先（LCA）板子代码
08-14
最近公共祖先（LCA）板子代码
最近公共祖先问题四种常见解法
ZhuTT的博客
03-12 3936
最近公共祖先问题 LCA定义 LCA指树中两个节点最近的一个公共祖先节点。 利用LCA可以求出树上任意两点之间的距离，假设树上所有节点到根节点的距离都存在dist数组里，则两个节点之间的距离为：dist[u]+dist[v]-2*dist[lca] dist[0] = 0; dist[1] = dist[2] = 1; dist[3] = dist[4] = dist[5] = dist[6] = 2; dist[7] = dist[8] = dist[9] = 3; 加入求解节点7和节点4之间的距离，
最近公共祖先问题（LCA）
心升明月的博客
09-12 382
LCA一、最近公共祖先定义二、倍增法（在线求lca）1.朴素法2.倍增法代码模板：场景1场景2场景3场景4 一、最近公共祖先定义 在一棵树上，对于节点x,yx,yx,y而言,如果说zzz节点既是xxx的祖先节点，也是yyy的祖先节点，那么我们认为zzz节点是(x,y)(x,y)(x,y)的公共祖先节点。 公共祖先节点有很多，那么深度最大的节点，被称之为最近公共祖先，记为lca(x,y)lca(x,y)lca(x,y)。 二、倍增法（在线求lca） 1.朴素法 将其中一个节点xxx向根节点移动，中途经过的点做
【图论】 最近公共祖先LCA
Texcavator的博客
07-21 185
什么是最近公共祖先？在一棵树中（也就是有向无环图中），从根结点遍历到每个结点，路径上所经过的所有结点都叫做该结点的祖先结点两个结点的祖先结点中重复的部分叫做公共祖先公共祖先中层数最大的一个点叫做最近公共祖先（LCA）
Leecode---347：输出前k个高频元素（使用unordered_map）
最新发布
qq_41920323的博客
05-30 315
unordered_map实现输出前k个高频元素
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 550
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
tarjan求最近公共祖先
08-14
Tarjan算法是一种用于求解最近公共祖（Least Common Ancestors，LCA）问题的离线算法。算法的核心思想是利用深度优先搜索（DFS）和并查集（Union Find）来解决问题。 首先，我们从根节点开始遍历每一个节点，并将节点分为三类，用st[]数组表示。0代表还未被遍历，1代表正在遍历这个点，2代表已经遍历完这个点并且回溯回来了。这样的划分有助于确定节点的最近公共祖先。 在Tarjan算法中，我们一边遍历一边回应查询。每当遍历到一个节点时，我们查找与该节点相关的所有查询。如果查询中的节点已经被遍历完（即st[]值为2），我们可以利用已经计算好的信息来计算它们的最近公共祖先。最近公共祖先的距离可以通过两个节点到根节点的距离之和减去最近公共祖先节点到根节点的距离来计算。 在Tarjan算法中，我们可以通过深度优先搜索来计算dist[]数组，该数组表示每个节点到根节点的距离。我们可以利用父节点到根节点的距离加上边的权值来计算每个节点到根节点的距离。 最后，我们可以通过并查集来操作st[]数组。当遍历完一个节点的所有子树后，将子树中的节点放入该节点所在的集合。这样，每个子树的节点的最近公共祖先都是该节点。 综上所述，Tarjan算法利用DFS和并查集来求解最近公共祖先问题。它的时间复杂度为O(n+m)，其中n是节点数，m是查询次数。通过该算法，我们可以高效地解决最近公共祖先的问题。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [最近公共祖先之tarjan](https://blog.csdn.net/qq_63092029/article/details/127737575)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 33.333333333333336%"] - *2* [【模版】Tarjan离线算法求最近公共祖先(LCA)](https://blog.csdn.net/weixin_43359312/article/details/100823178)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 33.333333333333336%"] - *3* [Tarjan算法求解最近公共祖先问题](https://blog.csdn.net/Yeluorag/article/details/48223375)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 33.333333333333336%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值