<lca 模板> 小机房的树

本文介绍了一种解决树上两点间最小边权和问题的方法,利用LCA(最近公共祖先)和前缀和技巧进行高效查询。通过两次DFS预处理,实现了快速查找任意两点间的路径最小边权总和。

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

go to the problem

简单来说就是给你一个n个点的树,每一条边都有边权。询问有m次,每次给出两个点,求他们之间的最小边权和。
很容易想到用求树上前缀和和lca,先把两个点跳到高度相同的地方,再一直往上跳,直到两个点重合。因为一个点一个点的跳太慢了,所以我们倍增的跳来求lca。

这里有两个模板 。。。_(:з」∠)_

模板1
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

int n,m,u,v,c,cnt;
int sum[50010],deep[50010],fa[50010][30],first[50010],next[100020];
struct maple{
    int f,t,d;
}Rode[100020];

void build(int f,int t,int d) //注意双向建边
{
    Rode[++cnt]=(maple){f,t,d};
    next[cnt]=first[f];
    first[f]=cnt;
}
void dfs(int f,int t,int d) // dfs处理出树
{
    deep[t]=deep[f]+1;
    fa[t][0]=f;
    sum[t]=d;
    for(int i=first[t];i;i=next[i])
       if(Rode[i].t!=f)
          dfs(t,Rode[i].t,d+Rode[i].d); 
}
void Done()  // 预处理倍增跳的fa
{
    for(int i=1;i<=log2(n);++i) 
       for(int j=0;j<=n;++j)
          fa[j][i]=fa[fa[j][i-1]][i-1]; // j往上跳2^i等同于fa[j][i-1]往上跳i-1步,这里与st表有细微区别 
}
int lca(int x,int y)
{
    if(deep[x]<deep[y]) swap(x,y); //确保x的深度大
    for(int i=log2(n);i>=0;--i) // 把x跳到与y深度相同的地方
    {
        if(deep[fa[x][i]]>=deep[y])
           x=fa[x][i];
    }
    if(x==y) return x;
    for(int i=log2(n);i>=0;--i)  //一起往上跳
       if(fa[x][i]!=fa[y][i])
         x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<n;++i)
    {
        scanf("%d%d%d",&u,&v,&c);
        build(u,v,c);
        build(v,u,c);
    }
    dfs(0,0,0);
    Done();
    scanf("%d",&m);
    while(m--)
    {
        scanf("%d%d",&u,&v);
        printf("%d\n",sum[u]+sum[v]-2*sum[lca(u,v)]);
    }
    return 0;
}
模板2
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;

int n,u,v,c,m;
int first[150010],next[150010],fa[150010][30],deep[150010],cnt;
int de[60000];
struct maple{
    int f,t,d;
}rode[150010];

void done(int f,int t,int v)
{
    fa[t][0]=f;
    deep[t]=deep[f]+1;
    de[t]=de[f]+v;
    for(int i=1;fa[t][i-1];++i)
       fa[t][i]=fa[fa[t][i-1]][i-1];
    for(int i=first[t];i!=-1;i=next[i])
      if(rode[i].t!=f)
         done(t,rode[i].t,rode[i].d);
}
void build(int f,int t,int d)
{
    rode[++cnt]=(maple){f,t,d };
    next[cnt]=first[f];
    first[f]=cnt;   
}
int lca(int x,int y)
{
    if(deep[x]<deep[y]) swap(x,y);
    if(deep[x]>deep[y])
    {
        int l=deep[x]-deep[y];
        for(int i=0;i<=20;++i)
            if(l>>i&1) 
              x=fa[x][i];
    }          
    if(x==y) return x;
    for(int i=log2(n);i>=0;--i)
        if(fa[x][i]!=fa[y][i]) 
           x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}

int main()
{
    memset(next,-1,sizeof(next));
    memset(first,-1,sizeof(first));
    scanf("%d",&n);
    for(int i=1;i<n;++i)
    {
        scanf("%d%d%d",&u,&v,&c);
        build(u,v,c);
        build(v,u,c);
    }
    done(0,0,0);
    scanf("%d",&m);
    while(m--)
    {
        scanf("%d%d",&u,&v);
        printf("%d\n",de[u]+de[v]-2*de[lca(u,v)]);
    }
    return 0;
}
<think>好的,我现在需要帮助用户找到关于LCA(最近公共祖先)算法的模板代码和实现示例。首先,我得回忆一下LCA的常见解决方法。常见的算法有暴力法、倍增法、Tarjan算法和链剖分等。其中,倍增法是比较常用且效率较高的,适合作为模板代码。 用户提到需要模板代码,所以应该优先考虑提供倍增法的实现。倍增法的核心是预处理每个节点的祖先表,然后通过二进制跳跃来快速找到LCA。我需要确保代码结构清晰,注释详细,方便用户理解。 接下来,我需要参考用户提供的引用内容。用户引用了关于Dijkstra算法的时间复杂度、宏定义、SPFA算法以及状态转移方程的内容。虽然这些引用可能与LCA没有直接关系,但引用[4]提到了状态转移方程fa[x][i] = fa[fa[x][i - 1]][i - 1],这正是倍增法中预处理祖先数组的关键步骤。这说明用户可能已经对倍增法的思路有所了解,或者在其他算法中见过类似的结构,这可以帮助他们理解LCA的实现。 因此,我应该重点解释倍增法的步骤,包括预处理和查询两个部分。预处理部分需要为每个节点建立不同层级的祖先信息,而查询部分则需要将两个节点调整到同一深度,然后共同向上跳跃寻找公共祖先。 在代码实现方面,需要定义父数组fa,深度数组depth,以及预处理时的循环结构。比如,用户引用中的宏定义REP可能用于循环,但考虑到用户可能更习惯标准写法,使用普通的for循环更合适。同时,确保代码中的变量命名清晰,比如fa表示父节点,depth表示节点深度。 另外,用户可能关心时间复杂度和适用场景。根据引用[3],Dijkstra在稠密图上是O(n²),而堆优化后是O(mlogn)。同样,倍增法的时间复杂度是预处理O(nlogn)和每次查询O(logn),适合多次查询的情况,这也是需要指出的。 还要注意代码的正确性,比如在预处理时,需要从根节点开始进行DFS或BFS来初始化每个节点的直接父节点和深度,然后在预处理fa数组时,逐层计算。查询时,处理两个节点到同一深度后,利用二进制跳跃寻找LCA。 最后,生成相关问题需要考虑用户可能的后续疑问,比如如何选择不同算法、优化方法、应用场景等。根据用户提供的示例问题,应该围绕实现细节、复杂度分析、比较其他方法等方面展开。 总结步骤: 1. 介绍LCA问题及常用方法,重点说明倍增法。 2. 提供模板代码,详细注释关键部分,尤其是预处理和查询函数。 3. 解释代码中的关键步骤,如状态转移方程、深度调整、二进制跳跃。 4. 分析时间复杂度和适用情况,引用相关的引用内容辅助说明。 5. 生成相关问题,引导用户深入理解。</think>### LCA(最近公共祖先)算法模板与实现 LCA问题通常通过**倍增法**高效解决,其核心是预处理每个节点的$2^k$级祖先信息,实现$O(\log n)$时间复杂度的查询。以下是基于倍增法的模板代码: ```cpp #include <iostream> #include <vector> #include <cmath> using namespace std; const int MAXN = 1e5 + 5; const int LOG = 20; // 根据最大节点数调整,log2(MAXN) vector<int> tree[MAXN]; // 邻接表存储 int depth[MAXN]; // 节点深度 int fa[MAXN][LOG]; // fa[i][j]表示节点i的2^j级祖先 // 预处理:DFS初始化depth和直接父节点 void dfs(int u, int parent) { fa[u][0] = parent; // 直接父节点 depth[u] = depth[parent] + 1; for (int v : tree[u]) { if (v != parent) { dfs(v, u); } } } // 预处理fa数组(倍增核心) void preprocess(int root, int n) { depth[root] = 0; dfs(root, 0); // 初始化直接父节点 // 状态转移:fa[x][i] = fa[fa[x][i-1]][i-1] for (int j = 1; j < LOG; j++) { for (int i = 1; i <= n; i++) { fa[i][j] = fa[fa[i][j-1]][j-1]; } } } // LCA查询函数 int lca(int u, int v) { // 确保u是更深的节点 if (depth[u] < depth[v]) swap(u, v); // 将u提升到与v同一深度 for (int k = LOG-1; k >= 0; k--) { if (depth[fa[u][k]] >= depth[v]) { u = fa[u][k]; } } if (u == v) return u; // 刚好是祖先的情况 // 共同向上跳跃寻找LCA for (int k = LOG-1; k >= 0; k--) { if (fa[u][k] != fa[v][k]) { u = fa[u][k]; v = fa[v][k]; } } return fa[u][0]; } ``` #### 关键点说明 1. **预处理复杂度**:DFS遍历$O(n)$,倍增数组构建$O(n \log n)$[^4] 2. **查询复杂度**:每次$O(\log n)$,适合多次查询场景 3. **核心操作**:通过二进制跳跃(如$2^0, 2^1, 2^2...$级祖先)快速调整节点深度 #### 应用场景 - 结构中的路径查询(如求两点间最短路径长度) - 网络路由算法中的拓扑分析 - 结合状数组处理动态问题
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值