LCA专题

最新推荐文章于 2022-07-15 22:16:27 发布
置顶 最新推荐文章于 2022-07-15 22:16:27 发布
阅读量502 收藏
点赞数
分类专栏： -----LCA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guhaiteng/article/details/70550685
版权

详细讲解博客：http://dongxicheng.org/structure/lca-rmq/（没有代码）

求LCA（最近公共祖先）的算法有好多，按在线和离线分为在线算法和离线算法。
离线算法有基于搜索的Tarjan算法比较好，而在线算法则是基于dp的ST算法比较好。当然树链剖分也能写
先是ST算法。
这个算法是基于RMQ（区间最大最小值编号）的，而求LCA就是把树通过深搜得到一个序列，然后转化为求区间的最小编号。

参考博客：
http://blog.csdn.net/liangzhaoyang1/article/details/52549822

来两道例题：
1.hdu2586
题意：
一个村庄有 n 个房子和 n-1 条双向路，每两个房子之间都有一条简单路径。
现在有m次询问，求两房子之间的距离。

思路：
可以用LCA来解，首先找到u, v 两点的lca，然后计算一下距离值就可以了。
计算方法是，记下根结点到任意一点的距离dis[i]，
这样ans = dis[u] + dis[v] - 2 * dis[lca(u, v)]了

代码：

#include <bits/stdc++.h>
using  namespace  std;

#define ff first
#define ss second
#define pb push_back
#define ll long long
#define mod 1000000007
#define ull unsigned long long
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define mst(ss,b) memset(ss,b,sizeof(ss));
#define dbg(x) cout << #x << "= " << x << endl;
typedef pair <int, int> pii;
const int inf = 0x3f3f3f3f;
const ll INF = (1LL<<63)-1;
const int N = 4e4+5;
const int M = 25;

int dp[N<<1][M]; // //这个数组记得开到2*N，因为遍历后序列长度为2*n-1

struct Edge{
    int to, next, w;
}edge[N<<1];
int tol, head[N];

void init(){
    tol = 0;
    memset(head, -1, sizeof(head));
}

void addedge(int u, int v, int w){
    edge[tol].to = v; edge[tol].w = w; edge[tol].next = head[u]; head[u] = tol++;
}

int ver[N<<1], R[N<<1], first[N], dis[N], cnt;
//ver:节点编号 R：深度 first：点编号位置 dis：距离 cnt:遍历后序列长度
void dfs(int u, int pre, int dep){
    ver[++cnt] = u; first[u] = cnt; R[cnt] = dep;
    for(int i=head[u]; i!=-1; i=edge[i].next){
        int v = edge[i].to;
        if(v == pre)continue;
        int w = edge[i].w;
        dis[v] = dis[u]+w;
        dfs(v, u, dep+1);
        ver[++cnt] = u;
        R[cnt] = dep;
    }
}

int rmq_init(int n){
    for(int i=1; i<=n; i++)dp[i][0] = i;
    for(int j=1; (1<<j)<=n; j++)
        for(int i=1; i+(1<<j)-1<=n; i++){
            int a = dp[i][j-1] , b = dp[i+(1<<(j-1))][j-1];
            dp[i][j] = R[a]<R[b]?a:b;
        }
}

//查询最小值,中间部分是交叉的
int rmq(int l,int r){
    int k=(int)(log(r-l+1.0)/log(2.0));
    int a = dp[l][k], b = dp[r-(1<<k)+1][k]; //返回其在ver数组中的下标
    return R[a]<R[b]?a:b;
}

int LCA(int u, int v){
    int x = first[u], y = first[v];
    if(x > y)swap(x, y);
    int ret = rmq(x, y);
    return ver[ret];
}

int in[N];
int  main(){
    int T;
    scanf("%d", &T);
    while(T--){
        init();
        mst(in, 0);
        int n, q;
        scanf("%d%d", &n, &q);
        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);
            in[v]++;
        }
        int root;
        for(int i=1; i<=n; i++)if(!in[i])root = i;
        dis[root] = 0; cnt = 0;
        dfs(root, -1, 1);
        rmq_init(2*n-1);
        while(q--){
            int u, v;
            scanf("%d%d", &u, &v);
            int lca = LCA(u, v);
            printf("%d\n", dis[u]+dis[v]-2*dis[lca]);
        }
    }
    return 0;
}

2.POJ1330 Nearest Common Ancestors

就是直接求最近公共祖先

代码：

#include <set>
#include <map>
#include <queue>
#include <vector>
#include <math.h>
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
using  namespace  std;

#define ff first
#define ss second
#define pb push_back
#define ll long long
#define mod 1000000007
#define ull unsigned long long
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define mst(ss,b) memset(ss,b,sizeof(ss));
#define dbg(x) cout << #x << "= " << x << endl;
typedef pair <int, int> pii;
const int inf = 0x3f3f3f3f;
const ll INF = (1LL<<63)-1;
const int N = 1e4+5;
const int M = 25;
int dp[N<<1][M]; // //这个数组记得开到2*N，因为遍历后序列长度为2*n-1

struct Edge{
    int to, next, w;
}edge[N<<1];
int tol, head[N];

void init(){
    tol = 0;
    memset(head, -1, sizeof(head));
}

void addedge(int u, int v, int w){
    edge[tol].to = v; edge[tol].w = w; edge[tol].next = head[u]; head[u] = tol++;
}

int ver[N<<1], R[N<<1], first[N], dis[N], cnt;
//ver:节点编号 R：深度 first：点编号位置 dis：距离 cnt:遍历后序列长度
void dfs(int u, int pre, int dep){
    ver[++cnt] = u; first[u] = cnt; R[cnt] = dep;
    for(int i=head[u]; i!=-1; i=edge[i].next){
        int v = edge[i].to;
        if(v == pre)continue;
        int w = edge[i].w;
        dis[v] = dis[u]+w;
        dfs(v, u, dep+1);
        ver[++cnt] = u;
        R[cnt] = dep;
    }
}

int rmq_init(int n){
    for(int i=1; i<=n; i++)dp[i][0] = i;
    for(int j=1; (1<<j)<=n; j++)
        for(int i=1; i+(1<<j)-1<=n; i++){
            int a = dp[i][j-1] , b = dp[i+(1<<(j-1))][j-1];
            dp[i][j] = R[a]<R[b]?a:b;
        }
}

//查询最小值,中间部分是交叉的
int rmq(int l,int r){
    int k=(int)(log(r-l+1.0)/log(2.0));
    int a = dp[l][k], b = dp[r-(1<<k)+1][k]; //返回其在ver数组中的下标
    return R[a]<R[b]?a:b;
}

int LCA(int u, int v){
    int x = first[u], y = first[v];
    if(x > y)swap(x, y);
    int ret = rmq(x, y);
    return ver[ret];
}

int in[N];

int  main(){
    int T;
    scanf("%d", &T);
    while(T--){
        init();
        mst(in, 0);
        int n;
        scanf("%d", &n);
        for(int i=1; i<n; i++){
            int u, v, w;
            scanf("%d%d", &u, &v);
            addedge(u, v, 1);
            addedge(v, u, 1);
            in[v]++;
        }
        int root;
        for(int i=1; i<=n; i++)if(!in[i])root = i;
        dis[root] = 0; cnt = 0;
        dfs(root, -1, 1);
        rmq_init(2*n-1);
        int u, v;
        scanf("%d%d", &u, &v);
        printf("%d\n", LCA(u, v));
    }
    return 0;
}

树链剖分的做法：
参考博客：
http://www.cnblogs.com/qilinart2/articles/5931595.html
http://www.cnblogs.com/fuyun-boy/p/6045709.html

代码：

#include <set>
#include <map>
#include <queue>
#include <vector>
#include <math.h>
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
using  namespace  std;

#define ff first
#define ss second
#define pb push_back
#define ll long long
#define mod 1000000007
#define ull unsigned long long
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define mst(ss,b) memset(ss,b,sizeof(ss));
#define dbg(x) cout << #x << "= " << x << endl;
typedef pair <int, int> pii;
const int inf = 0x3f3f3f3f;
const ll INF = (1LL<<63)-1;
const int N = 1e4+5;

int n, m, q;
struct Edge{
    int to, next;
}edge[N<<1];

int head[N], tol;
int top[N];//top[v]表示v所在的重链的顶端节点
int fa[N];//父亲节点
int dep[N];//深度
int sz[N];//sz[v]表示以v为根的子树的节点数
int p[N];//p[v]表示v与其父亲节点的连边在线段树中的位置
int fp[N];//和p数组相反  已知v在线段树中位置,其父亲节点是u
int son[N];//重儿子
int pos;

int a[N];

void init(){
    tol = 0;
    memset(head, -1, sizeof(head));
    pos = 0;  
    memset(son, -1, sizeof(son));
}

void addedge(int u, int  v){
    edge[tol].to = v;edge[tol].next = head[u]; head[u] = tol++;
}

void dfs1(int u, int pre, int d){//第一遍dfs求出fa,deep,sz,son
    dep[u] = d;
    fa[u] = pre;
    sz[u] = 1;
    for(int i=head[u]; i!=-1; i=edge[i].next){
        int v = edge[i].to;
        if(v != pre){
            dfs1(v, u, d+1);
            sz[u] += sz[v];
            if(son[u] == -1 || sz[v] > sz[son[u]])
                son[u] = v;
        }
    }
}

void getpos(int u, int sp){ //第二遍dfs求出top和p
    top[u] = sp;
    p[u] = ++pos;  //树状数组编号从1开始
    fp[p[u]] = u;
    if(son[u] == -1)return ;
    getpos(son[u], sp);
    for(int i=head[u]; i!=-1; i=edge[i].next){
        int v = edge[i].to;
        if(v != son[u] && v != fa[u])
            getpos(v, v); //轻儿子
    }
}

int LCA(int x, int y){
    //如果两个的链顶不相等，我们就把他们往一起靠
    //看那个点的链顶深度大改变那个点
    for( ; top[x]!=top[y] ; dep[top[x]]>dep[top[y]]?x=fa[top[x]]:y=fa[top[y]]);
    return dep[x]<dep[y]?x:y; //返回时要返回深度比较小的数
}

int in[N];

int  main(){
    int T;
    scanf("%d", &T);
    while(T--){
        init();
        mst(in, 0);
        int n;
        scanf("%d", &n);
        for(int i=1; i<n; i++){
            int u, v;
            scanf("%d%d", &u, &v);
            addedge(u, v);
            addedge(v, u);
            in[v]++;
        }
        int root;
        for(int i=1; i<=n; i++)if(!in[i])root = i;
        dfs1(root, -1, 0);
        getpos(root, root);
        int u, v;
        scanf("%d%d", &u, &v);
        printf("%d\n", LCA(u, v));
    }
    return 0;
}

3.洛谷 3379

树剖求LCA板子题

代码：

#include <set>
#include <map>
#include <queue>
#include <vector>
#include <math.h>
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
using  namespace  std;

#define ff first
#define ss second
#define pb push_back
#define ll long long
#define mod 1000000007
#define ull unsigned long long
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define mst(ss,b) memset(ss,b,sizeof(ss));
#define dbg(x) cout << #x << "= " << x << endl;
typedef pair <int, int> pii;
const int inf = 0x3f3f3f3f;
const ll INF = (1LL<<63)-1;
const int N = 5e5+5;

int n, m, q;
struct Edge{
    int to, next;
}edge[N<<1];

int head[N], tol;
int top[N];//top[v]表示v所在的重链的顶端节点
int fa[N];//父亲节点
int dep[N];//深度
int sz[N];//sz[v]表示以v为根的子树的节点数
int p[N];//p[v]表示v与其父亲节点的连边在线段树中的位置
int fp[N];//和p数组相反  已知v在线段树中位置,其父亲节点是u
int son[N];//重儿子
int pos;

int a[N];

void init(){
    tol = 0;
    memset(head, -1, sizeof(head));
    pos = 0;  
    memset(son, -1, sizeof(son));
}

void addedge(int u, int  v){
    edge[tol].to = v;edge[tol].next = head[u]; head[u] = tol++;
}

void dfs1(int u, int pre, int d){//第一遍dfs求出fa,deep,sz,son
    dep[u] = d;
    fa[u] = pre;
    sz[u] = 1;
    for(int i=head[u]; i!=-1; i=edge[i].next){
        int v = edge[i].to;
        if(v != pre){
            dfs1(v, u, d+1);
            sz[u] += sz[v];
            if(son[u] == -1 || sz[v] > sz[son[u]])
                son[u] = v;
        }
    }
}

void getpos(int u, int sp){ //第二遍dfs求出top和p
    top[u] = sp;
    p[u] = ++pos;  //树状数组编号从1开始
    fp[p[u]] = u;
    if(son[u] == -1)return ;
    getpos(son[u], sp);
    for(int i=head[u]; i!=-1; i=edge[i].next){
        int v = edge[i].to;
        if(v != son[u] && v != fa[u])
            getpos(v, v); //轻儿子
    }
}

int LCA(int x, int y){
    //如果两个的链顶不相等，我们就把他们往一起靠
    //看那个点的链顶深度大改变那个点
    for( ; top[x]!=top[y] ; dep[top[x]]>dep[top[y]]?x=fa[top[x]]:y=fa[top[y]]);
    return dep[x]<dep[y]?x:y; //返回时要返回深度比较小的数
}

int  main(){
    init();
    int n, m, s;
    scanf("%d%d%d", &n, &m, &s);
    for(int i=1; i<n; i++){
        int u, v;
        scanf("%d%d", &u, &v);
        addedge(u, v);
        addedge(v, u);
    }
    dfs1(s, -1, 0);
    getpos(s, s);
    while(m--){
        int x, y;
        scanf("%d%d", &x, &y);
        printf("%d\n", LCA(x, y));
    }
    return 0;
}
QiufengWang424
关注
专栏目录
【kuangbin带你飞】专题二十五 线段树 LCA 树链剖分
weixin_40588429的博客
07-16 113
B 顺序发现线段树无法维护，逆序之后每个输入对（pos，val）的pos + 1既是队列前面需要的空位，线段树维护还留下的空位 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <algorithm> #include <vector> using ...
RMQ和LCA
05-07 1073
RMQ和LCA 【内容简介】 　　讨论解决RMQ、LCA问题的算法、以及RMQ、LCA两类问题的相互转换。它们在字符串处理和生物学计算中有着广泛应用，在信息学奥赛中更是被广泛应用和扩展，所以熟练掌握RMQ和LCA问题就显得十分重要。 ※在内容开始，我们假设一个算法预处理时间为 f(n)，查询时间为g(n)。这个算法复杂度的标记为(或f(n)-g(n))。 【关键词】RMQ、LCA、ST
【LCA专题】各种LCA求法
bangzuan5029的博客
12-26 251
这篇博客，本蒟蒻会详解各种lca求法，朴素和倍增会后续增加上去 欧拉序列+RMQ 【O（n+m+nlogn+q）】 这种求法对于询问次数特别的多的情况比较好用，有一些出题人可能会特意卡这个，让你必须要用欧拉序列 原理： 把每个点搜索到的顺序记录下来，形成一个序列（就是欧拉序列），然后rmq深度，最后O（1）输出 看这个例子 很明显记录序号+rmq深度就好 它的核心在...
LCA专题训练
我们仍未知道那天所看见的花的名字。
11-30 578
CF1328E Tree Queries 题目链接 对节点高度进行排序，检查前后两个节点，如果高度相同，他们应该拥有相同的爸爸，如果高度不同，高的那个爬一步，然后低的那个爬到和高的一样的高度，看是否是同一个点。 #include<bits/stdc++.h> #pragma comment(linker, "/stack:200000000") #pragma GCC optimize("Ofast") #pragma GCC target("sse,sse2,sse3,ssse3,sse4,
LCA问题专题
R的博客
07-15 467
LCA的于各类题目中的应用
专题·LCA（最近公共祖先）【including 倍增法，Tarjan，树剖解法
樱狸✨愿携清风归来处
05-18 1466
初见安~这里是LCA专题：） LCA——最近公共祖先，即在一棵树上任意两点向根节点靠近的路上重合的深度最深的点。【自己的理解，可能不准确】 就比如下面这棵树： 节点4和6的最近公共祖先是点1，节点7和5的最近公共祖先是点2。 【后文三种解法题目均为：洛谷P3379 【模板】最近公共祖先】 LCA的用处不少，所以掌握求LCA的方法也是很重要的。如下【本人只会三种】有三种解法： 1.倍...
算法讲解119【扩展】树上问题专题2-树上倍增和LCA-下.pptx
最新发布
08-27
代码：https://download.csdn.net/download/m0_73085893/89681787
算法讲解118【扩展】树上问题专题1-树上倍增和LCA-上.pptx
08-27
代码：https://download.csdn.net/download/m0_73085893/89681787
专题资料（2021-2022年）jit教学手册15.doc
10-07
通过各种策略和工具，如5S、LCA（损失分析）、均衡化生产、一个流、防错法等，实现这些目标，提升生产系统的整体效率和效益。 总的来说，精益生产是一种系统性的管理哲学，它通过消除浪费、提高效率、增强灵活性和...
浅谈LCA（最近公共祖先）
cdy1206473601的博客
08-12 1038
简介 首先是最近公共祖先的概念(什么是最近公共祖先？)： 在一棵没有环的树上，每个节点肯定有其父亲节点和祖先节点，而最近公共祖先，就是两个节点在这棵树上深度最大的公共的祖先节点。 换句话说，就是两个点在这棵树上距离最近的公共祖先节点。 所以LCA主要是用来处理当两个点仅有唯一一条确定的最短路径时的路径。 讲解 我们今天介绍一种计算LCA的方法——Tarjan。 ...
LCA 总结
I good vegetable a!
08-26 805
【转载地址】点击打开链接 I LCA: 什么是LCA？ Lowest Common Ancestor, 指的是树上两点的最近公共祖先。 有了它, 我们可以高效地求解树上两点间的距离、最大权值边等信息。 LCA的时间复杂度: 暴力 O(n+m+qn)倍增法 O(n+m+nlogn+qlogn)欧拉序列与RMQ O(n+m+nlogn+q)Tarjan离线算法 O(n+m+q)树链剖分 O
图-邻接矩阵（二维数组）存储结构下的 深度优先遍历与广度优先遍历，求树的两个节点的最近公共祖先(LCA）
m0_37357063的博客
04-28 1621
/* 题目描述 有下面一个图 图的各个顶点之间只有唯一的道路相连，而且任顶点都是可以互达的， 解答要求 时间限制：1000ms, 内存限制：64MB 输入 每个样例输入： 第一行两个正整数N，Q，图有N个顶点，有Q个询问。其中1 <= N,Q <= 100 第二行到第N行，每行三个整数u,v,z，表示顶点u到顶点v的距离为z，表示顶点u与顶点v相连，边的权值为z。其中 1 &l...
poj 1986 LCA 求树上任意两节点距离
Cugb->Baoge
08-12 1934
传送门 题意：就是一棵树，求节点距离。 思路：如果t是u，v的最近公共祖先，那么d[u,v]=d[u,root]+d[v,root]-2*d[t,root]，就根据这个来搞之。 每到一个点然后遍历所有询问。。。果断超了，之后便用vector来存询问，也超时，然后find函数压缩了下路径就过了。。。。。。。 #include #include #include #include using
LCA（最近公共祖先）--tarjan离线算法 hdu 2586
weixin_30872671的博客
05-16 154
HDU 2586 How far away ？ Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 11320Accepted Submission(s): 4119 Problem Description There ...
Distance Queries（LCA）
Simone chou...
05-06 130
Distance Queries Time Limit: 2000MS   Memory Limit: 30000K Total Submissions: 8642   Accepted: 3036 Case Time Limit: 1000MS Description Farmer John's cows refused to run in ...
POJ 1986 DIstance Query LCA水题
weixin_30325071的博客
08-18 109
给出一棵树，对于每一个询问，给出2个节点，输出2个节点的距离。 输入中有字母，那个是没有用的，不用管。 思路： 0.选择编号为1的节点作为树的root （注意：有些题的边是单向的，这时候我们要根据节点的入度来确定root， 　　　　双向的话一般可以随意选择一个节点作为root） 1.dfs1，求出dep和pa[i][0] 2.初始化数组pa 3.节点（u，v）的权值为w...
LCA 求 树中两个点的距离
weixin_30567225的博客
03-26 132
PS：在树中:dis(u,v)=dis(root,v)+dis(root,u)-2*dis(root,lca(u,v)); 这个性质可以写很多题。 vector<int>mp[N];int dp[N][LN];int dep[N];void dfs(int u,int fa,int t) //dfs(root){dp[u][0]=fa;dep[u]=t;for (int ...
hdu5296 Annoying problem (LCA+SET)
w20810的专栏
07-26 1091
题目：http://acm.hdu.edu.cn/showproblem.php?pid=5296 题意：给定N个点和N-1条边以及边的权值,再给定一个set,向set里面添加/删除节点求让set里面的节点连通的最小费用。 分析：看大神博客知道的。这题主要求点到链的距离。先解决点到点的距离,假如dis[x]表示x到root的距离,那么点u和v的距离就是dis[u]+dis[v]-dis[lca
XML关键词搜索的高效XLCA算法
"XML关键字搜索中一个高效的寻找XLCA的算法" 在XML数据处理领域，XML关键字搜索是一种用户友好的信息发现技术，尤其适用于无模式（schema-free）的XML文档。然而，用户仅通过关键词搜索来精确传递语义信息可能会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值