树上倍增实现lca

LCA实现方法


1.dfs搜索树形成欧拉序列用st算法维护区间最值


2.tarjan离线求lca


3.树上倍增实现lca(方法如下)





模板代码

#include<bits/stdc++.h>
#define maxn 100
#define max2 20
using namespace std;
struct<span style="white-space:pre">	</span>node
{
    int to,next;
} poi[maxn*2];
int head[maxn],fa[maxn][max2],f[maxn],d[maxn];
int cnt;
int init_build(int n)
{
    cnt=0;
    for (int i=1; i<=n; i++)
        head[i]=0;
}
int ins(int u,int v)
{
    poi[++cnt].to=v;
    poi[cnt].next=head[u];
    head[u]=cnt;
}
int init_dfs(int n)
{
    memset(f,1,sizeof(f));
    int m=int (log(n*1.0)/log(2.0));
    for (int i=0; i<=m; i++)
        fa[1][i]=1;
}
int dfs(int u,int depth)
{
    f[u]=0;
    d[u]=depth;
    int p=head[u];
    while (p!=0)
    {
        if (f[poi[p].to])
        {
            fa[poi[p].to][0]=u;
            f[poi[p].to]=0;
            dfs(poi[p].to,depth+1);
        }
        p=poi[p].next;
    }
    return 0;
}
int redouble_dp(int n)
{
    int m=int (log(n*1.0)/log(2.0));
    for (int j=1; j<=m; j++)
        for (int i=2; i<=n; i++)
            fa[i][j]=fa[fa[i][j-1]][j-1];
    return 0;
}
int lca(int x,int y,int n)
{
    if (d[x]<d[y]) swap(x,y);
    int m=int (log(n*1.0)/log(2.0));
    if (d[x]!=d[y])
    {
        for (int j=m; j>=0; j--)
        {
            if (d[x]-((1<<j))<0)
                continue;
            if (d[fa[x][j]]>=d[y])
                x=fa[x][j];
            if (d[x]==d[y])
                break;
        }
        for (int j=m; j>=0; j--)
        {
            if (x==y)
                break;
            if (d[x]-((1<<j))<0)
                continue;
            if (fa[x][j]!=fa[y][j])
            {
                x=fa[x][j];
                y=fa[y][j];
            }
        }
        if ((fa[x][0]!=fa[y][0])&&(x!=y))
            return 0;
        if (x==y)
            return x;
        else return fa[x][0];
    }
}
int main()
{
    int n;
    cin>>n;
    init_build(n);
    for (int i=0; i<n-1; i++)
    {
        int x,y;
        cin>>x>>y;
        ins(x,y);
        ins(y,x);
    }
    init_dfs(n);
    dfs(1,0);
    redouble_dp(n);
    int m;
    cin>>m;
    for (int i=0; i<m; i++)
    {
        int x,y;
        cin>>x>>y;
        cout<<x<<"->"<<y<<":"<<lca(x,y,n)<<endl;
    }
    return 0;
}



### LCA 最近公共祖先问题在树结构中使用倍增法的解题方法 #### 倍增算法简介 倍增算法是一种高效的技术,在路径查询、区间问题以及树的祖先查询等方面有着广泛应用。这种算法特别适合用于解决涉及多个层次关系的问题,比如最近公共祖先(LCA)问题[^1]。 #### LCA 定义及其重要性 在有根树中,对于两个节点 \(u\) 和 \(v\),LCA 是所有公共祖先中最深的那个节点。这个概念不仅限于普通的父子关系,还包括节点本身作为自己祖先的情况。因此,在任何给定的一对节点间都存在唯一的LCA[^2]。 #### 使用倍增法求解LCA的具体过程 为了提高查找效率,通常会对树进行预处理。具体来说,就是利用二进制表示来记录每个节点向上跳转\(2^k\)步后的父节点位置。这样做的好处是可以快速定位到目标节点之间的共同祖先,从而大大减少了实际计算量。以下是基于此思想的一种常见实现方式: ```cpp const int MAXN = 1e5 + 7; int fa[MAXN][20]; // 存储第i个结点往上走2^j步到达的父亲编号 int dep[MAXN]; // 结点深度数组 void dfs(int u,int father){ fa[u][0]=father; // 初始化fa[i][0],即直接父亲 dep[u]=dep[father]+1; for (auto &v : adj[u]) { if(v==father) continue; dfs(v,u); } } // 预处理f表 for(int j=1;(1<<j)<n;j++) for(int i=1;i<=n;i++) if(fa[i][j-1]!=-1) fa[i][j]=fa[fa[i][j-1]][j-1]; pair<int,int> getlca(int a,int b){ while(a!=b){ if(dep[a]<dep[b]) swap(a,b); int k=log2(dep[a]-dep[b]); a=fa[a][k]; } return {a,dep[a]}; } ``` 上述代码片段展示了如何构建倍增表格`fa[][]`并通过深度优先搜索初始化各个节点的信息。之后通过简单的循环操作即可完成任意两点之间LCA的查询工作[^4]。 #### 应用场景扩展 除了基本的LCA查询外,倍增法还可以与其他高级数据结构相结合,如并查集和树链剖分等,进一步优化复杂度较高的题目解答方案。此外,在动态规划领域也经常能看到它的身影,尤其是在那些涉及到子树范围内属性汇总或者状态转移方向确定等问题上[^3]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值