LCA(倍增法）

最新推荐文章于 2025-04-27 22:06:07 发布
最新推荐文章于 2025-04-27 22:06:07 发布
阅读量1.3k 收藏 7
点赞数 3
CC 4.0 BY-SA版权
分类专栏： LCA acm 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43402296/article/details/105681230

LCA（最近公共祖先）：给你一棵树，然后给你两个点，让你找到这两个点的最近公共祖先，俩个点的公共祖先有很多，但是其中距离两个点的距离之和最小的那个祖先就是最近公共祖先。
刚学了树上倍增法求LCA
最近做了几个板子题，记录一下这种算法的基本，，，过程吧。
fa数组：倍增关键数组，fa[i][j]表示以i开始找2j步的祖先，例如fa[i][0]就表示i的20的祖先也就是i的父结点。
de数组：当前这个数的在树中的深度。
f数组：记录父节点，有的树没有给出根节点，需要用f数组找根节点，（记录入度数量也可以找到根节点）
head数组：前向星建图头数组
v数组：根结点到当前数的距离（权值）。

首先我们要预处理fa数组，用bfs遍历，更新 f a [ i ] [ j ] = f a [ f a [ i ] [ j − 1 ] ] [ j − 1 ] fa[i][j]=fa[fa[i][j-1]][j-1] fa[i][j]=fa[fa[i][j−1]][j−1]。同时记录深度，有要求距离的，也在预处理里面更新距离。
然后我们就可以用倍增法查找两个数a，b（de[a]>de[b]，默认a是要更深，不然就swap一下）的LCA了。
在求LCA的函数中，我们要先把两个数保持在同一深度，这个过程其实用到的是二进制拆分，把差值一步步缩小，最终让深度相等，然后两个一起往上找祖先，如果两个祖先不一样就同时更新，这样a,b还是在同一深度，最终可以更新到不能一步也不能更新的地步，那么就说明再往前走一步就他俩祖先就一样了，那么这个就是他俩的最近的公共祖先。
例题一：POJ-1330 Nearest Common Ancestors
入门板题

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<algorithm>
#include<queue>
#include<vector>
#include<math.h>
//#include<bits/stdc++.h>
using namespace std;
#define LL long long
const int N=1e4+50;
int fa[N][20];
int f[N];
int tot;
int head[N];
int de[N];
int L;
int n;
queue<int>q;
struct zxc
{
    int to,net;
}e[2*N];
void add(int u,int v)
{
    e[tot].to=v;
    e[tot].net=head[u];
    head[u]=tot++;
}
void init()
{
    memset(head,-1,sizeof(head));
    memset(f,0,sizeof(f));
    memset(fa,0,sizeof(fa));
    memset(de,0,sizeof(de));
    tot=1;
    while(!q.empty())
    {
        q.pop();
    }
}
void bfs(int x)
{
    de[x]=1;
    q.push(x);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u];i!=-1;i=e[i].net)
        {
            int v=e[i].to;
            if(de[v])
            {
                continue;
            }
            de[v]=de[u]+1;
            fa[v][0]=u;
            for(int i=1;i<=L;i++)
            {
                fa[v][i]=fa[fa[v][i-1]][i-1];
            }
            q.push(v);
        }
    }
}
int lca(int a,int b)
{
    if(de[a]<de[b])
    {
        swap(a,b);
    }
    for(int i=L;i>=0;i--)
    {
        if(de[fa[a][i]]>=de[b])
        {
            a=fa[a][i];
        }
    }
    if(a==b)
    {
        return a;
    }
    for(int i=L;i>=0;i--)
    {
        if(fa[a][i]!=fa[b][i])
        {
            a=fa[a][i];
            b=fa[b][i];
        }
    }
    return fa[a][0];
}
int main()
{
    int t;
    int x,y;
    scanf("%d",&t);
    while(t--)
    {
        init();
        scanf("%d",&n);
        L=int(log(n+0.0)/log(2.0))+1;
        for(int i=1;i<n;i++)
        {
            scanf("%d%d",&x,&y);
            f[y]++;
            add(x,y);
        }
        int rot;
        for(int i=1;i<=n;i++)
        {
            if(f[i]==0)
            {
                rot=i;
                break;
            }
        }
        bfs(rot);
        scanf("%d%d",&x,&y);
        printf("%d\n",lca(x,y));
    }
    return 0;
}

例题二：POJ-1470 Closest Common Ancestors

//#include<bits/stdc++.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<math.h>
#include<map>
using namespace std;
#define LL long long
const double PI=acos(-1.0);
const double eps=1e-8;
const int N=1e5+10;
int fa[1105][12];
//int v[1105];
int de[1105];
int f[1000];
queue<int>q;
struct zxc
{
    int to,net;
} e[10005];
int ans[1000];
int head[1005];
int tot;
int n,m,d;
double u;
char s1[5],s2[5];
void add(int u,int v)
{
    e[tot]= {v,head[u]};
    head[u]=tot++;
//    e[tot]={u,w,head[v]};
//    head[v]=tot++;
}
void bfs(int x)
{
    de[x]=1;
    //v[1]=0;
    q.push(x);
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        for(int i=head[x]; i!=-1; i=e[i].net)
        {
            int y=e[i].to;
            if(de[y])
                continue;
            de[y]=de[x]+1;
            //v[y]=v[x]+e[i].w;
            fa[y][0]=x;
            for(int i=1; i<=u; i++)
            {
                fa[y][i]=fa[fa[y][i-1]][i-1];
            }
            q.push(y);
        }
    }

}
int lca(int a,int b)
{
    if(de[a]<de[b])
    {
        swap(a,b);
    }
    for(int i=u; i>=0; i--)
    {
        if(de[fa[a][i]]>=de[b])
        {
            a=fa[a][i];
        }
    }
    if(a==b)
    {
        return a;
    }
    for(int i=u; i>=0; i--)
    {
        if(fa[a][i]!=fa[b][i])
        {
            a=fa[a][i];
            b=fa[b][i];
        }
    }
    return fa[a][0];
}
int main()
{
    while(~scanf("%d",&n))
    {
        memset(head,-1,sizeof(head));
        tot=1;
        memset(fa,0,sizeof(fa));
        // memset(v,0,sizeof(v));
        memset(de,0,sizeof(de));
        memset(ans,0,sizeof(ans));
        memset(f,0,sizeof(f));

        int x,y,z,num;
        u=log(n+0.0)/log(2.0);
        for(int i=1; i<=n; i++)
        {
            scanf("%d:(%d)",&x,&num);
            for(int i=1; i<=num; i++)
            {
                scanf("%d",&y);

                f[y]=x;
                add(x,y);
            }

        }
        while(f[y])
        {
            y=f[y];
        }
        bfs(y);
        scanf("%d",&m);
        while(m--)
        {
            scanf("%1s%d%d%1s",s1,&x,&y,s2);
            ans[lca(x,y)]++;
        }
        for(int i=1; i<=n; i++)
        {
            if(ans[i]!=0)
            {
                printf("%d:%d\n",i,ans[i]);
            }
        }
    }
    return 0;
}

例题三：HDU-4547 CD操作
注意这道题树上从上往下是可以一步到达的。

#include<bits/stdc++.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<math.h>
#include<map>
using namespace std;
#define LL long long
const double PI=acos(-1.0);
const double eps=1e-8;
const int N=1e5+10;
int fa[N][20];
int f[N];
int de[N];
int tot;
int n,m;
int u;
char s1[45],s2[45];
map<string,int>q;
queue<int>w;
struct zxc
{
    int to,net;
} e[2*N];
int head[N];
void init()
{
    for(int i=0;i<=n;i++)
    {
        head[i]=-1;
        f[i]=0;
        de[i]=0;
    }
    memset(fa,0,sizeof(fa));
    tot=1;
}
void add(int u,int v)
{
    e[tot]= {v,head[u]};
    head[u]=tot++;
}
void bfs(int x)
{
    de[x]=1;
    w.push(x);
    while(!w.empty())
    {
        int z=w.front();
        w.pop();
        for(int i=head[z]; i!=-1; i=e[i].net)
        {
            int y=e[i].to;
            if(de[y])
            {
                continue;
            }
            de[y]=de[z]+1;
            fa[y][0]=z;
            for(int j=1; j<=u; j++)
            {
                fa[y][j]=fa[fa[y][j-1]][j-1];
            }
            w.push(y);
        }
    }
}
int lca(int x,int y)
{
    if(de[x]<de[y])
    {
        swap(x,y);
    }
    for(int i=u; i>=0; i--)
    {
        if(de[fa[x][i]]>=de[y])
        {
            x=fa[x][i];
        }
    }
    if(x==y)
    {
        return x;
    }
    for(int i=u; i>=0; i--)
    {
        if(fa[x][i]!=fa[y][i])
        {
            x=fa[x][i];
            y=fa[y][i];
        }
    }
    return fa[x][0];
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        q.clear();
        int sum=1;
        scanf("%d%d",&n,&m);
          init();
        u=int(log(n+0.0)/log(2.0))+1;
        for(int i=1; i<n; i++)
        {
            scanf("%s%s",s1,s2);
            if(!q[s1])
            {
                q[s1]=sum++;
            }
            if(!q[s2])
            {
                q[s2]=sum++;
            }
            f[q[s1]]=q[s2];
            add(q[s2],q[s1]);
        }
        int num=1;
        while(f[num])
        {
            num=f[num];
        }
        bfs(num);
        while(m--)
        {
            scanf("%s%s",s1,s2);
            int flog=1;
            int ans=lca(q[s1],q[s2]);
            if(ans==q[s2])
            {
                flog=0;
            }
            printf("%d\n",de[q[s1]]-de[ans]+flog);
        }
    }
    return 0;
}
【LCA 倍增法】【codevs 1036 商务旅行】
skysys的研究小屋
04-25 901
题目 题目描述 Description 某首都城市的商人要经常到各城镇去做生意，他们按自己的路线去做，目的是为了更好的节约时间。 假设有N个城镇，首都编号为1，商人从首都出发，其他各城镇之间都有道路连接，任意两个城镇之间如果有直连道路，在他们之间行驶需要花费单位时间。该国公路网络发达，从首都出发能到达任意一个城镇，并且公路网络不会存在环。 你的任务是帮助该商人计算一下他的最
倍增LCA(带修改)，codeforce#535F,codeforce#827D
Link_Ray的博客
01-28 667
F. MST Unification https://codeforces.com/contest/1108/problem/F 题意 n个点，m条边，每条边都有一个权值，每次操作可以使得一条边的权值减1，问最小需要几次操作，使得最小生成树唯一。 题解 对于最小生成树不唯一的情况就是，添加一条非树边后(u,v,w)后构成的环中的最小值（除非树边的最小值）等于非树边，这样就可以用非树边去替代这条边使...
LCA-倍增法（在线）O(nlogn)-O(logn)
weixin_30784501的博客
06-24 185
1.DFS预处理出所有节点的深度和父节点 inline void dfs(int u) { int i; for(i=head[u];i!=-1;i=next[i]) { if (!deep[to[i]]) { deep[to[i]] = deep[u]+1; ...
基于c++的LCA倍增法实现
最新发布
2402_87646581的博客
04-27 956
原理就不写了，自己找b站视频学习// 最大节点数// 最大对数深度// 树的邻接表表示// 每个节点的深度// parent[i][j]表示节点i的2^j级祖先// DFS预处理每个节点的深度和父节点信息// 直接父节点i < MAXLOG;// 初始化，从根节点开始预处理// 根节点的父节点设为-1// 查询u和v的LCA// 确保u是较深的节点。
LCA问题（倍增法）
热门推荐
Q_M_X_D_D_的博客
05-07 1万+
之前写过了LCA的两个在线算法之一：DFS+ST方法（DFS+ST）。本篇介绍另一种在线算法，用倍增思想来解决LCA问题。在学习倍增之前，先看一种倍增算法的退化版，有助于理解倍增法。 在找a和b的LCA时，先让a和b中深度较大的那一个，向上回溯到与另一个同样深度的位置上。例如下面这个图： 假设要找F和E的LCA，先让F向上回溯到他的父节点D的...
LCA算法之倍增
qq_44624316的博客
03-28 1341
LCA算法之倍增 这里写一篇关于LCA算法倍增的博客。 倍增是LCA暴力之后的优化~ 所以应该比较简单。但是我理解来理解去，理解了一下午？？你敢信?? LCA(Least Common Ancestors)最近公共祖先 什么是最近公共祖先？？ 就是深度最大的公共祖先 例如下面一棵树 结点3和结点5的最近公共祖先是1； 结点2和结点3的最近公共祖先是4； 结点1和结点4的最近公共祖先是4； 上面说...
LCA算法-倍增算法
EQUINOX1的博客
12-12 2320
如果你懂二进制，那么你就懂二进制(bushi)
Pascal LCA 倍增法详解及代码
10-08
本文介绍的是一种基于倍增法的在线算法，它能够以更高效的方式求解LCA。倍增法的思想是利用2的幂次快速跳跃，通过预先计算部分信息，使得在询问时可以快速找到最近公共祖先。具体实现中，我们定义函数f(u,k) = Fa(u,...
Pascal实现的LCA倍增法详解与代码优化
本文主要讲解了如何使用Pascal语言实现最近公共祖先（LCA，Least Common Ancestors）问题的高效算法，特别是通过倍增法（Binary Lifting）来优化解决策略。LCA问题是树形数据结构中的经典问题，需求是找出给定树中...
LCA倍增法 求树的最近公共祖先（模板）
brandong
06-10 2235
LCA倍增法 求树的最近公共祖先 查询树上任意两个节点之间的路径信息，实际上就是找这两个节点的LCA，因为唯一路径就是这两个节点分别到LCA会合，所以关键问题就是求LCA，需要的路径信息可在找LCA过程中维护。找LCA的思想类似于RMQ，定义fa[u][i]为节点u的第2^i个父节点，fa[u][0]就是u的父节点，fa[u][1]就为u的爷爷节点，那么就有如下递推式： fa[tmp][i]...
LCA四种写法其一：倍增
m0_62021646的博客
10-08 839
文章目录众所周知一、倍增区间倍增二、LCA2.读入数据总结 众所周知 LCA有四种写法 一、倍增 fa[n][logn]，fa[i][j]表示i节点的第2^j个父亲。 显然：fa[i][j]=fa[ fa[i][j-1] ][j-1] 即i的第2j个父亲是i的第2(j-1)个父亲的第2(j-1)个父亲。 于是，求i的第k个父亲的复杂度O(k)—>O(logk) 求i的第k个父亲： 1. for(int j=0; j<=log2(k); j++) 2. if((1<<j)&a.
倍增LCA
qq_59144780的博客
01-30 4849
朴素算法求LCA，即暴力求解，当树近乎为一条链时，找祖先时一级一级向上跳，时间复杂度接近O(n),所以可以考虑一次跳尽可能大的距离，即倍增算法；一次跳2^i（i=0,1,2....）级。 倍增法 一个节点的四级祖先就是这个节点的二级祖先的二级祖先； 设fa[j][i]为j节点的2^i级祖先；则fa[j][i]=fa[fa[j][i-1]][i-1]; 算法思想：求两节点的lca，先将深度深的结点用倍增法向上跳，直到两节点处于同一深度，此时有可能重合，则两点中任意一个结点即为lca；若没重合，则两节
LCA的倍增算法
bestjerry007的博客
01-16 414
LCA即最近公共祖先。 百度百科给的定义是，对于有根树T的两个结点u、v，最近公共祖先LCA(T,u,v)表示一个结点x，满足x是u和v的祖先且x的深度尽可能大。在这里，一个节点也可以是它自己的祖先。 上面说的深度是将根结点的深度视为最小。 加深一下理解，如果u和v的最近公共祖先是x，那从u到v一定要经过x。 同时也可以这样理解，以x为根的子树，是包含u和v的最小树，即从原树中取任意一节点为根的子...
LCA（倍增法）
weixin_44535721的博客
04-17 752
算法描述： 对于一棵树，求两个点的最近公共祖先 如下图：（以下数字代表对应编号的节点） 1 和 66 的 LCA 是 8 。 11 和 11 的 LCA 是 8 。 11 和 15 的 LCA 是 4 。 14 和 13 的 LCA 是 11 。 　　 倍增法的算法思想：先预处理求出该数的深度，用f[i][j]数组来表示i号节点的2的j次方的祖先是谁。如果u，v 节点的深度不一样就把他们跳到一...
LCA倍增
algzjh的博客
08-21 479
const int LOG = 20;//根据点数来取，取LOG >=logn就行了 20已经可以处理1e6以下的数据了int par[N][LOG],dep[N];void dfs(int u,int fa,int depth){ dep[u]=depth; if(u==1){ //对于根来说，往上跳无论几下都是他自己。我习惯把1定为根所以写 u == 1 for
LCA（倍增）
TheBladeDancer
08-08 198
学长讲的时候敲的LCA（倍增）代码 然后注释了一点点 #pragma GCC optimize(2) //O2优化 // 倍增LCA //#include<bits/stdc++.h> #include<iostream> #include<vector> #include<cstring> using namespace std; co...
lca倍增算法
zz_ylolita
08-17 3220
HDU2586 要注意只有简单边相连的图是一棵树，树有n-1条边
LCA——倍增
without的博客
05-22 635
最近公共祖先（LCA）基础算法——倍增 LCA（Least Common Ancestors），即最近公共祖先，是指在有根树中，找出某两个结点u和v最近的公共祖先。 ———来自百度百科 列如： 在这棵树中 1717 和 88 的LCA就是 33， 99 和 77 的LCA就是 77 。 明白了LCA后，就下来我们就要探讨探讨LCA怎么求了 qwq 暴力算法 以 17 和 18 为例，既然要求...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值