LCA入门

最新推荐文章于 2020-04-03 23:25:44 发布
最新推荐文章于 2020-04-03 23:25:44 发布
阅读量470 收藏 1
点赞数
分类专栏： LCA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CYBCLOUD/article/details/88044820
版权
这篇博客介绍了LCA（Lowest Common Ancestor）的基础知识，包括如何计算节点间的距离，并给出了两个具体的题目实例：HDU 2586和ZJU 3195。博主分享了使用倍增法和Tarjan算法解决LCA问题的思路，并提供了相关教程链接。对于Tarjan算法，博主遇到了WA（Wrong Answer）情况，正在寻求解决方案。
摘要由CSDN通过智能技术生成

关于LCA几个讲解:

https://blog.csdn.net/jeryjeryjery/article/details/52853017

1.How far away ？

http://acm.hdu.edu.cn/showproblem.php?pid=2586

题目大意：给出n个房屋，这些房屋之间的链接是树形链接，房屋和房屋之间有且只有一个路线；道路是双向的。

T组数据；

n个房子，m次查询；

n-1个路径  ：a，b之间的距离是l

 

倍增:

倍增法讲解：https://blog.csdn.net/lw277232240/article/details/72870644

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int MAX=1e6+5;
const int INF=0x3f3f3f3f;

struct node{
    int t,next;
    ll len;
    //Node(int T=0,int Next=-1,ll Len=0):t(T),next(Next),len(Len){}

}edge[MAX<<1];
int head[MAX],cnt;
void initedge(int n)
{
    memset(head,-1,sizeof(head));cnt=0;
}
void addedge(int u,int v,ll len=0)
{
    edge[cnt]=node{v,head[u],len};
//这样写不加 Node(int T=0,int Next=-1,ll Len=0):t(T),next(Next),len(Len){} 最好用G++提交
    head[u]=cnt++;
}

int T,n,m;

int deep[MAX];
int anc[202020][21];
int dis[202020];

void dfs(int u,int father)
{
    for(int i=1;i<=20;i++)
    {
        anc[u][i]=anc[ anc[u][i-1] ][i-1];//找u的2的i次方的父节点
    }
    for(int i=head[u];~i;i=edge[i].next)
    {
        int t=edge[i].t;
        if(t==father)continue;
//因为这里建立的是双向图！！！addedge(u,v,w); addedge(v,u,w);两张方向相反的图

        dis[t]=dis[u]+edge[i].len;
        deep[t]=deep[u]+1;
        anc[t][0]=u;
        dfs(t,u);
    }
}
///查询
int LCA(int u,int v)
{
    if(deep[u]<deep[v])swap(u,v); ///1.调整u深
    for(int i=20;i>=0;i--)    ///2.调整到统一深度
    {
        if(deep[anc[u][i]] >= deep[v])
            u=anc[u][i];
    }
    if(u==v)return u;

    for(int i=20;i>=0;i--) ///3.一起往上跳
    {
        if(anc[u][i] != anc[v][i])
        {
            u=anc[u][i];
            v=anc[v][i];
        }
    }
    return anc[u][0];
}
int main()
{
    for(scanf("%d",&T);T--;)
    {
        scanf("%d%d",&n,&m);
        initedge(n);
        for(int i=1;i<n;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w);
            addedge(v,u,w);
        }

        dis[1]=0;
        deep[1]=1;
        anc[1][0]=1;
        dfs(1,1);

        for(int i=0;i<m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            int k=LCA(u,v);

            int ans=dis[u]+dis[v]-2*dis[k];
            printf("%d\n",ans);
        }

    }
}

tarjan: 


#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#define ll long long
const int maxn=1e5+10;
using namespace std;
int rlen[maxn];
int vis[maxn];
int fa[maxn];
struct node
{
    int u,v,w,next;
}edge[maxn];
struct query
{
    int u,v,lca,next;
}edgeq[maxn*4];

int head[maxn],cnt;
int headq[maxn],cntq;

void addedge(int u,int v,int len)
{
    edge[cnt]=node{u,v,len,head[u]};
    head[u]=cnt++;
}

void addq(int u,int v){    //询问
    edgeq[cntq]=query{u,v,0,headq[u]};
    headq[u]=cntq++;
}

void  initedge()
{
    cnt=0;
    memset(head,-1,sizeof(head));
}
void initq()
{
    cntq=0;
    memset(headq,-1,sizeof(headq));
}


int Find(int u)
{
    if(u==fa[u])
        return u;
    return fa[u]=Find(fa[u]);
}
void Union(int x,int y)

{
    x=Find(x);
    y=Find(y);
    if(x!=y)
    fa[y]=x;
}

void dfs(int u)//注意理解递归的过程！
{
    vis[u]=1;
    fa[u]=u;
//通过递归更新子节点到根节点的距离和更新子节的祖节点的位置
    for(int i=head[u];~i;i=edge[i].next)
    {
        int t=edge[i].v;

        if(!vis[t])
        {
            rlen[t]=rlen[u]+edge[i].w;
            dfs(t);
            Union(u,t);//遍历完到最底层后，回溯时再更新父节点！！1
        }
    }
//每遍历完一个父节点的所有子节点，就与父节点相关的最近LCA的询问
    for(int i=headq[u];~i;i=edgeq[i].next)
    {
        int v=edgeq[i].v;
        if(vis[v])//重点！如果该子节点已经被访问过，那么父节点与该子节点的最近LCA一定就是子节点的祖节点
        {
            int lca=Find(v);
            edgeq[i].lca=lca;
        }
    }
}


int main()
{
    int cas,n,m,u,v,len;
    cin>>cas;
    while(cas--)
    {
        scanf("%d%d",&n,&m);
        initedge();
        initq();

        for(int i=0;i<n-1;i++){
            scanf("%d%d%d",&u,&v,&len);
            addedge(u,v,len);
            addedge(v,u,len);
        }

        ///输入询问 u v
        for(int i=0;i<m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            addq(u,v);
            addq(v,u);
        }
        memset(vis,0,sizeof(vis));
        rlen[1]=0;
        dfs(1); //LCA
        for(int i=0;i<m;i++)
        {
            //应为是双向图，所以要乘以2
            int ans=rlen[edgeq[2*i].u]+rlen[edgeq[2*i].v]-2*rlen[edgeq[2*i].lca];
            printf("%d\n",ans);
        }

    }
}

2.Design the city

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3195

题意：

给定N个点，下面N-1行u、v、d表示一条无向边和边权值，它们构成了一棵无向树。现在给出Q查询。

问在树上连通a、b、c三点的最短距离。


显然在树上连通a、b、c三点最短距离 为dist[a] + dist[b] + dist[c] - (dist[LCA(a, b)] + dist[LCA(a, c)] + dist[LCA(b, c)])。其中dist[]存储节点到根的最短距离。

答案也就是

(lca(a,b)+lca(b,c)+lca(a,c))/2
lca(a,b)=dist[a] + dist[b] -- 2*dist[lca(a, b)]
注意输出格式！！！！
 

倍增：

#include <stdio.h>
 
#include <string.h>
 
#include <iostream>
 
#include <algorithm>
 
#include <math.h>
 
#define ll long long
 
const int MAX=1e5+10;
 
using namespace std;
 
struct node{
    int t,next;
    ll len;
}edge[MAX<<1];
int head[MAX],cnt;
void initedge()
{
    memset(head,-1,sizeof(head));
    cnt=0;
}
void addedge(int u,int v,ll len=0)
{
    edge[cnt]=node{v,head[u],len};
    head[u]=cnt++;
}
 
int T,n,m;
 
int deep[MAX];
int anc[202020][21];
int dis[202020];
 
void dfs(int u,int father)
{
    for(int i=1;i<=20;i++)
    {
        anc[u][i]=anc[ anc[u][i-1] ][i-1];//找u的2的i次方的父节点
    }
    for(int i=head[u];~i;i=edge[i].next)
    {
        int t=edge[i].t;
        if(t==father)continue;
 
        dis[t]=dis[u]+edge[i].len;
        deep[t]=deep[u]+1;
        anc[t][0]=u;
        dfs(t,u);
    }
}
///查询
int LCA(int u,int v)
{
    if(deep[u]<deep[v])swap(u,v); ///1.调整u深
    for(int i=20;i>=0;i--)    ///2.调整到统一深度
    {
        if(deep[anc[u][i]] >= deep[v])
            u=anc[u][i];
    }
    if(u==v)return u;
 
    for(int i=20;i>=0;i--) ///3.一起往上跳
    {
        if(anc[u][i] != anc[v][i])
        {
            u=anc[u][i];
            v=anc[v][i];
        }
    }
    return anc[u][0];
}
int jisuan(int u,int v)
{
      int ans=(dis[u]+dis[v]-2*dis[LCA(u,v)]);
      return ans;
}
 
int main()
{
    int flag=0;//注意输出格式！！！
    while(~scanf("%d",&n))
    {
        //注意输出格式！！！
        if(flag)
              printf("\n");
        flag=1;
        
        initedge();
        for(int i=1;i<n;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w);
            addedge(v,u,w);
        }
        dis[1]=0;
        deep[1]=1;
        anc[1][0]=1;
        dfs(1,1);
        scanf("%d",&m);
        for(int i=0;i<m;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            int sum=jisuan(u,v)+jisuan(u,w)+jisuan(v,w);
            printf("%d\n",sum/2);
        }
    }
}

tarjan(WA了，但不知道错在哪了啊?）:

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#define ll long long
using namespace std;
const int nmaxn=50000+10;
const int qmaxn=70000+10;
ll rlen[qmaxn];
int vis[qmaxn];
int fa[qmaxn];
struct node
{
    int u,v;
    ll w;
    int next;
    node (int U=0,int V=0,ll W=0,int N=0):
        u(U),v(V),w(W),next(N){}
}edge[nmaxn<<1];// 注意数组开的大小！
struct query
{
    int u,v,lca,next;
 
}edgeq[qmaxn*6];// 注意数组开的大小！
 
int head[nmaxn],cnt;
int headq[qmaxn],cntq;
 
void addedge(int u,int v,ll len)
{
    edge[cnt]=node(u,v,len,head[u]);
    head[u]=cnt++;
}
 
void addq(int u,int v)
{
    edgeq[cntq]=query{u,v,-1,headq[u]};
    headq[u]=cntq++;
}
 
void  initedge()
{
    cnt=0;
    memset(head,-1,sizeof(head));
}
void initq()
{
    cntq=0;
    memset(headq,-1,sizeof(headq));
}
 
 
int Find(int u)
{
    if(u==fa[u])
        return u;
    return fa[u]=Find(fa[u]);
}
void Union(int x,int y)
 
{
    x=Find(x);
    y=Find(y);
    if(x!=y)
        fa[y]=x;
}
 
void dfs(int u)
{
    vis[u]=1;
    fa[u]=u;
    for(int i=head[u];~i;i=edge[i].next)
    {
        int t=edge[i].v;
 
        if(!vis[t])
        {
            rlen[t]=rlen[u]+edge[i].w;// 注意这里！
            dfs(t);
            Union(u,t);
        }
    }
 
    for(int i=headq[u];~i;i=edgeq[i].next)
    {
        int v=edgeq[i].v;
        if(vis[v])// 注意这里已标记过的
        {
            int lca=Find(v);
            edgeq[i].lca=lca;
        }
    }
}
 
 
ll jisuan(int x)
{
 
	return rlen[edgeq[x].u]+rlen[edgeq[x].v]-2*rlen[edgeq[x].lca];
 
}
 
int main()
{
    int flag,n,m,u,v,w;
    ll len;
    flag=0;
    while(~scanf("%d",&n))
    {
        if(flag)
            printf("\n");
        flag=1;
        initedge();
        initq();
        memset(vis,0,sizeof(vis));
        memset(fa,0,sizeof(fa));
        memset(rlen,0,sizeof(rlen));
 
        for(int i=0;i<n-1;i++)
        {
            scanf("%d%d%lld",&u,&v,&len);
            addedge(u,v,len);
            addedge(v,u,len);
        }
 
        scanf("%d",&m);
 
        for(int i=0;i<m;i++)
        {
 
            scanf("%d%d%d",&u,&v,&w);
            addq(u,v);
            //addq(v,u);
 
            addq(u,w);
            //addq(w,u);
 
            addq(v,w);
            //addq(w,v);
        }
        dfs(0); //LCA
        for(int i=0;i<m;i++)
        {
            int a=i*3,b=a+1,c=a+2;//注意这里与开的树大小的关系！
            ll ans=jisuan(a)+jisuan(b)+jisuan(c);
            printf("%lld\n",ans/2);
        }
 
    }
}

 

CYB-just-go
关注
专栏目录
LCA入门学习
Akahieveman的博客
08-03 535
关于LCA博主也正在学习中会持续更新博客。 另外如果有兴趣学习LCA的可以先行参考资料点击下面连接即可 Tarjan求LCA学习资料： LCA学习 下面附上STL的模板（仅限参考，具体与相关题改变）： #include #include #include #include using namespace std; typedef long long LL; #define INF 0
How far away ？ HDU - 2586(LCA入门题)
Dch19990825的博客
08-28 191
How far away ？ HDU - 2586(LCA入门题) 题目:传送门 思路见注释 代码 : /* 求树上无向图的两点简单路径距离距离 */ #include<bits/stdc++.h> #define mset(a,b) memset(a,b,sizeof(a)) using namespace std; typedef long long ll; typedef pai...
LCA 入门
bllsll
09-13 470
LCA：一个树，给你两个点，问这两个点的最近公共祖先方法一：dfs，直接先将一个点的祖先求出来，再看另外一个点祖先什么时候与之相遇（用一个标记数组），这样的话，每个询问都是n的时间复杂度 时间复杂度为o（q*n）#include <iostream> #include <cstring> #include <cstdio> #include <algorithm>using namespace s
LCA
zjy2015302395的博客
11-30 505
http://codeforces.com/contest/519/problem/E题意：给你一个无根树，q个询问，每次输入两个节点，问到两个节点距离相同的点有几个tip：设1为根，dfs记录每个点子树的节点数量，每个点的高度， 倍增，找到u，v的lca，根据三个点的高度可以知道在从u到v的链上到两个点距离相等的点的高度， if（lca不是这个中间点且长度是偶数，那么这个中间点的所有子树除了这
（详细）LCA板子以及入门题总结
李dayday
04-15 630
LCA算法总结 把lca题目记入下来！分享给你们 板子tarjan（离线） #define N 10005 #define M 1000005 // N 表示的树的节点 // M 表示的问题数 int cnt_e,cnt_q,head_e[N],head_q[N],vis[N],dis[N],t,ans[M],id[N],f[N]; // 边，问题数 struct node{ int ...
倍增算法入门 超详细解答+LCA+RMQ(ST表)+例题剖析
繁凡さん的博客
04-03 1万+
目录一、倍增算法二、倍增算法的应用：求LCA（最近公共祖先）附模板题三、倍增算法的应用：RMQ 问题（ST表）附模板题 一、倍增算法 要了解倍增之前，建议先看一下大佬的博客：【白话系列】倍增算法 看完以后相信你已经对倍增有了大致初步的了解，下面给出倍增的定义 （其实没什么用，好长一段话建议不看） 倍增 从字面的上意思看就是成倍的增长 ,这是指我们在进行递推时,如果状态空间很大,通常的线性递推无法满...
LCA training package
01-27
### LCA培训包知识点概述 #### 一、全生命周期评估(Life Cycle Assessment, LCA)基础知识 ##### 1.1 全生命周期思考介绍 - **背景介绍**：全生命周期评估是一种系统方法，用于评估产品或服务在其整个生命周期内的...
初学LCA---最近公共祖先 离线与在线
qq_36386435的博客
09-11 430
首先是最近公共祖先的概念(什么是最近公共祖先？)： 转载：https://www.cnblogs.com/JVxie/p/4854719.html 在一棵没有环的树上，每个节点肯定有其父亲节点和祖先节点，而最近公共祖先，就是两个节点在这棵树上深度最大的公共的祖先节点。 换句话说，就是两个点在这棵树上距离最近的公共祖先节点。 所以LCA主要是用来处理当两个点仅有唯一一条确定的最短路径时的路径...
ACM竞赛编程入门指南
7. **图论**：涉及强连通分量、拓扑排序、最短路径算法（Dijkstra、SPFA、Floyd）、次短路、最近公共祖先（LCA）、最小生成树（Kruskal、Prim）、最大流和最小割等问题。 8. **字符串处理**：后缀数组、KMP算法、AC...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值