LCA小结

最新推荐文章于 2021-09-23 14:16:05 发布
最新推荐文章于 2021-09-23 14:16:05 发布
阅读量478 收藏
点赞数
分类专栏： LCA算法 学习小结 文章标签： 小结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013167299/article/details/47453479
版权
  1. LCA
  2. 在线算法 RMQ之ST加DFS
  3. 离线算法Tarjan加DFS
    以poj1330为例 题意：T组测试案例，m个节点，m-1条变，最后一个询问；问u，v的最近公共祖先；

学习资料：http://blog.csdn.net/shahdza/article/details/7689338
http://www.cnblogs.com/kuangbin/archive/2012/09/21/2697395.html

数组含义，摘抄于资料

注意LCAT(u, v)是在对T进行dfs过程当中在访问u和v之间离根结点最近的点。因此我们可以考虑树的欧拉环游过程u和v之间所有的结点，并找到它们之间处于最低层的结点。为了达到这个目的，我们可以建立三个数组:

E[1, 2*N-1] - 对T进行欧拉环游过程中所有访问到的结点;E[i]是在环游过程中第i个访问的结点
L[1,2*N-1] - 欧拉环游中访问到的结点所处的层数;L[i]是E[i]所在的层数
H[1, N] ，H[i] - 是E中结点i第一次出现的下标(任何出现i的地方都行，当然选第一个不会错)

假定H[u]<H[v](否则你要交换u和v)。可以很容易的看到u和v第一次出现的结点是E[H[u]..H[v]]。现在，我们需要找到这些结点中的最低层。为了达到这个目的，我们可以使用RMQ。因此 LCAT(u, v) = E[RMQL(H[u],H[v])] (记住RMQ返回的是索引)，

在线算法：DFS+RMQ的ST算法

#include<iostream>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#include<set>
#include<stack>
#define cl(a,b) memset(a,b,sizeof(a));
#define LL long long
#define P pair<int,int>
#define X first
#define Y second
#define pb push_back
using namespace std;
const int maxn=10010;
const int inf=9999999;
const int mod=100007;
int L[maxn<<1];///编号1-n，注意编号
struct ST{///RMQ的ST算法,返回最小元素的下标
    int mm[maxn<<1];//最高位1的位置mm[0]=-1,mm[1]=0,mm[2]=2;
    int dp[maxn<<1][20];
    void init(int n){
        mm[0]=-1;
        for(int i=1;i<=n;i++){
            dp[i][0]=i;
            mm[i]=(i&(i-1))==0?mm[i-1]+1:mm[i-1];
        }
        for(int j=1;j<=mm[n];j++){
            for(int i=1;i+(1<<j)-1<=n;i++){
                dp[i][j]=L[dp[i][j-1]]<L[dp[i+(1<<(j-1))][j-1]]?dp[i][j-1]:dp[i+(1<<(j-1))][j-1];
            }
        }
    }
    int query(int i,int j){
        if(i>j)swap(i,j);
        int k=mm[j-i+1];
        return L[dp[i][k]]<L[dp[j-(1<<k)+1][k]]?dp[i][k]:dp[j-(1<<k)+1][k];
    }
};
struct node{//边的结构，邻接表
    int to,next;
};
struct LCA{
    int n;
    int head[maxn<<1];
    int tol;
    node edge[maxn<<1];//边的相关数组

    int E[maxn<<1];//欧拉环游数组，i出现的顺序
    int H[maxn];//i第一次出现在E数组中的位置

    ST st;

    void init(int n){
        this->n=n;
        tol=0;
        memset(head,-1,sizeof(head));
    }
    void addedge(int u,int v){//加边
        edge[tol].to=v;
        edge[tol].next=head[u];
        head[u]=tol++;
        edge[tol].to=u;
        edge[tol].next=head[v];
        head[v]=tol++;
    }

    bool vis[maxn];//DFS标志数组
    int cnt;//访问的编号
    void dfs(int x,int level){
        vis[x]=true;
        E[++cnt]=x;
        L[cnt]=level;
        H[x]=cnt;
        for(int i=head[x];i!=-1;i=edge[i].next){
            int v=edge[i].to;
            if(vis[v])continue;
            dfs(v,level+1);
            E[++cnt]=x;
            L[cnt]=level;
        }
    }
    int query(int a,int b){
        return E[st.query(H[a],H[b])];
    }
    void solve(int root){
        cnt=0;
        memset(vis,false,sizeof(vis));
        dfs(root,0);
        st.init(n*2-1);//数组的长度，要注意
    }
}lca;
bool flag[maxn];
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        int n;
        scanf("%d",&n);
        memset(flag,false,sizeof(flag));
        lca.init(n);
        for(int i=1;i<n;i++){
            int u,v;
            scanf("%d%d",&u,&v);
            lca.addedge(u,v);
            flag[v]=true;
        }
        int root;
        for(int i=1;i<=n;i++)if(!flag[i]){
            root=i;break;
        }
        lca.solve(root);
        int l,r;
        scanf("%d%d",&l,&r);
        printf("%d\n",lca.query(l,r));
    }
    return 0;
}

离线算法：Tarjan算法，DFS+并查集 时间 O(n+q)线性复杂度，n是元素个数，q是询问次数

//伪代码
//parent为并查集，FIND为并查集的查找操作
//QUERY为询问结点对集合
//TREE为有根树
 Tarjan(u)//从根节点开始
      for each (u, v) in TREE    
          Tarjan(v)
          parent[v] = u
      visit[u] = true
      for each (u, v) in QUERY
          if visit[v]
              ans(u, v) = FIND(v)

离线算法的学习资料：http://noalgo.info/476.html

算法从根节点root开始搜索，每次递归搜索所有的子树，然后处理跟当前根节点相关的所有查询。
算法用集合表示一类节点，这些节点跟集合外的点的LCA都一样，并把这个LCA设为这个集合的祖先。当搜索到节点x时，创建一个由x本身组成的集合，这个集合的祖先为x自己。然后递归搜索x的所有儿子节点。当一个子节点搜索完毕时，把子节点的集合与x节点的集合合并，并把合并后的集合的祖先设为x。因为这棵子树内的查询已经处理完，x的其他子树节点跟这棵子树节点的LCA都是一样的，都为当前根节点x。所有子树处理完毕之后，处理当前根节点x相关的查询。遍历x的所有查询，如果查询的另一个节点v已经访问过了，那么x和v的LCA即为v所在集合的祖先。
其中关于集合的操作都是使用并查集高效完成。
算法的复杂度为，O(n)搜索所有节点，搜索每个节点时会遍历这个节点相关的所有查询。如果总的查询个数为m，则总的复杂度为O(n+m)。

POJ1330
基于伪代码实现的代码

#include<iostream>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#include<set>
#include<stack>
#define cl(a,b) memset(a,b,sizeof(a));
#define LL long long
#define P pair<int,int>
#define X first
#define Y second
#define pb push_back
using namespace std;
const int maxn=10010;
const int inf=9999999;
const int mod=100007;

bool flag[maxn];//找根节点的数组
struct que{//查询结构体
    int q,index;
    que(){}
    que(int a,int b):q(a),index(b){}
};
vector<que> query[maxn];//存储查询
vector<int> tree[maxn];//存树
int ans[maxn];//存答案

struct Tarjan{//tarjan算法
    int  f[maxn];//并查集
    bool vis[maxn];//dfs标记数组
    void init(int n){//初始化操作
        for(int i=0;i<=n;i++){
            f[i]=i;
            vis[i]=false;
            flag[i]=false;
            tree[i].clear();
            query[i].clear();
        }
    }
    int Find(int x){//并查集查找函数，这是路径压缩的
        return f[x]==x?x:f[x]=Find(f[x]);
    }
    void dfs(int u){//dfs遍历,进行查询
        int n=tree[u].size();
        for(int i=0;i<n;i++){
            int v=tree[u][i];
            dfs(v);
            f[v]=u;
        }
        vis[u]=true;//遍历完节点u的所有子节点，就可以解答出与u有关的询问了
        n=query[u].size();
        for(int i=0;i<n;i++){
            int v=query[u][i].q;
            if(vis[v]){
                ans[query[u][i].index]=Find(v);
            }
        }
    }
    void solve(int root){
        dfs(root);
    }
}tar;
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        int n;
        scanf("%d",&n);

        tar.init(n);
        for(int i=1;i<n;i++){
            int u,v;
            scanf("%d%d",&u,&v);
            tree[u].pb(v);
            flag[v]=true;
        }

        int Q=1;
        for(int i=0;i<Q;i++){
            int u,v;
            scanf("%d%d",&u,&v);
            query[u].pb(que(v,i));
            query[v].pb(que(u,i));///注意查询交换
        }

        for(int i=1;i<=n;i++)if(!flag[i]){
            tar.solve(i);break;
        }

        for(int i=0;i<Q;i++){
            printf("%d\n",ans[i]);
        }
    }
    return 0;
}

再写一个，和资料里讲解的一样的，二者不同在于下面多了个ancestor数组，见注释的**部分

#include<iostream>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#include<set>
#include<stack>
#define cl(a,b) memset(a,b,sizeof(a));
#define LL long long
#define P pair<int,int>
#define X first
#define Y second
#define pb push_back
using namespace std;
const int maxn=10010;
const int inf=9999999;
const int mod=100007;

bool flag[maxn];
struct que{
    int q,index;
    que(){}
    que(int a,int b):q(a),index(b){}
};
vector<que> query[maxn];
vector<int> tree[maxn];
int ans[maxn];

struct Tarjan{
    int  f[maxn];//并查集
    bool vis[maxn];//dfs标记数组
    int  ancestor[maxn];//祖先
    void init(int n){
        for(int i=0;i<=n;i++){
            f[i]=i;
            vis[i]=false;
            ancestor[i]=i;
            flag[i]=false;
            tree[i].clear();
            query[i].clear();
        }
    }
    int Find(int x){
        return f[x]==x?x:f[x]=Find(f[x]);
    }
    void Union(int x,int y){
        x=Find(x),y=Find(y);
        if(x!=y)f[y]=x;
    }
    void dfs(int u){
        int n=tree[u].size();
        for(int i=0;i<n;i++){
            int v=tree[u][i];
            dfs(v);
            Union(u,v);//*********
            ancestor[Find(u)]=u;//*********
        }
        vis[u]=true;
        n=query[u].size();
        for(int i=0;i<n;i++){
            int v=query[u][i].q;
            if(vis[v]){
                ans[query[u][i].index]=ancestor[Find(v)];//*********
            }
        }
    }
    void solve(int root){
        dfs(root);
    }
}tar;
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        int n;
        scanf("%d",&n);

        tar.init(n);
        for(int i=1;i<n;i++){
            int u,v;
            scanf("%d%d",&u,&v);
            tree[u].pb(v);
            flag[v]=true;
        }

        int Q=1;
        for(int i=0;i<Q;i++){
            int u,v;
            scanf("%d%d",&u,&v);
            query[u].pb(que(v,i));
            query[v].pb(que(u,i));///注意查询交换
        }

        for(int i=1;i<=n;i++)if(!flag[i]){
            tar.solve(i);break;
        }

        for(int i=0;i<Q;i++){
            printf("%d\n",ans[i]);
        }
    }
    return 0;
}
_pkm_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【模板】LCA（欧拉序+RMQ）
夕弦
08-04 3041
平常在信息学竞赛中求LCA一般有三种办法： 用倍增法求解，预处理复杂度是 O(nlogn)O(nlog⁡n)O(n\log n) ,每次询问的复杂度是 O(logn)O(log⁡n)O(\log n), 属于在线解法。 利用欧拉序转化为RMQ问题，用 ST表 求解RMQ问题，预处理复杂度 O(n+nlogn)O(n+nlog⁡n)O(n + n \log n) ，每次询问的复杂度为 O(1)O...
关于LCA的补充
China__int128的博客
04-04 395
结合之前的 LCA blog. 我们又发现如果使用 tarjan 算法，时间复杂度为 O(nq)O(nq)O(nq)，如果询问次数 qqq 较大，再结合一些小小的常熟，可能会 TLE。 于是我们有了新的思路——欧拉序结合 RMQ。 什么是欧拉序？ 还是这张图 该图的欧拉序即为： abacdcecaabacdcecaabacdceca 然后我们可以发现，如果求 bbb 与 eee 的 LCA 就是欧拉序中 bbb 至 eee 中层数最小的所对应的字母，而区间最小用什么，当然是 RMQ 啊！ 所以我们只需要跑
hdu2586 LCA模板
Time flies
12-06 4617
hdu2586 先预处理 然后是   在线询问 （也就是一边读入一边查询） #pragma comment(linker, "/STACK:1024000000,1024000000") #include #include #include using namespace std; #define maxn 400010 int n; struct Nod
LCA--ST表+欧拉序
zjyang12345的博客
04-30 1101
预备知识： 存图的几种方式 链接 欧拉序与dfs序区别 一.ST表+欧拉序 ①原理： 欧拉序（前序遍历得到的序列，叫dfs序，但数字可以重复出现，一进一出，叫欧拉序），会发现根结点总在中间，而根结点是该段序列深度最小的点 因此两个点的LCA，就是在该序列上两个点第一次出现的区间内深度最小的那个点 即转化为区间RMQ问题，可以用ST表。当然你可以再写一棵线段树（如果有修改操作） ...
欧拉序求解LCA
既然弱小，就只顾变强就是了
03-31 2180
奇怪的知识又增加了呢！ 今天，我们来讲一下欧拉序的一个神奇的用处——求解LCA，这个神奇的方法求LCA有什么神奇的好处呢？它的预处理操作是的，但是查询操作是O(1)的。 好了，直入主题，首先，怎样求解欧拉序呢？ 这幅图的欧拉序为：A - B - D - B - E - G - E - B - A - C - F - H - F - C - A 很显然的，我们能发现，任意...
【笔记】dfs序，欧拉序，LCA的RMQ解法
秋叶红于二月花
09-26 3600
名词解释 LCA（Lowest Common Ancestors），即最近公共祖先，是指在有根树中，找出某两个结点u和v最近的公共祖先。 RMQ（Range Minimum/Maximum Query），即区间最值查询，是指在数列中求一段区间的最大或最小值。 ST表（Sprase Table），稀疏表，可以预处理复杂度O(nlogn)，查询复杂度O(1)地解决RMQ问题，不支持在线修改. 参见：R...
lca问题
h_666666的博客
06-22 353
leetcode有一个简单版的lca 但是这个我不是很理解，，，root指的是已经知道了根节点？ 题目链接 https://leetcode-cn.com/problems/0owest-common-ancestor-of-a-binary-tree/ 代码： /** * Definition for a binary tree node. * public class TreeNode {...
LCA RMQ 最小公共祖先 区间最小值
08-07
这些算法的复杂度都可以达到 O(1) 或 O(logN)，其中 N 是树的结点数。这些算法可以应用于各种实际问题中，例如在生物学计算中，LCA 问题可以用来查找两个物种的最近公共祖先。 RMQ 问题也可以使用多种方法来解决，...
硬件加法器原理与设计小结.pdf
03-01
LCA的实现原理包括分析RCA的关键路径，即找出造成延迟最长的部分，然后通过额外的硬件逻辑来提前计算进位，因此大幅减少了加法器处理数据所需的总时间。 进位旁路加法器（Carry Bypass Adder，简称CBA）是另一种...
bzoj2144 跳跳棋 二分+lca
老臣
08-15 728
这道题刚开始看以为是DP，，，我真是智障了。该DP的看成搜索，该二分的看成DP。。这状态有点危险。。 题意:现在有三个人a,b,c，每一个人可以跳过他左/右边的人，比如说一个人在x，一个在y，那么x可以跳到y+(y-x)（y>x），左边同理。。但是两个人之间不能有另一个人。 现在有三个目标位置和起始位置，让你计算最少的步数让三个人到达目标位置，并不要求人的顺序（即无论哪一个人都可以去任意的终点）
树链剖分小结及题目
每一次AC都是一种感动
08-04 3705
我们经常会遇到这样一类题目：给出一棵树，询问树上u,v两点路径间的最值，合值，更新u，v路径上的点权或边权，或者区间更新etc，此时如果单纯的用线段树或者树状数组去搞，很明显问题不能够得到完美解决，此时就需要更高级的数据结构去对树进行重新构造，也就是通常说的树链剖分。 一．树链剖分 树链剖分，顾名思义，也就是对树的每一条链进行剖分，将一棵树拆分成若干条链，对其进行重新编号，在进行了重新编
对LCA、树上倍增、树链剖分（重链剖分&长链剖分）和LCT（Link-Cut Tree）的学习
路人黑的纸巾
10-18 9998
一篇从浅到深探究一些树上算法的博客
LCA:(欧拉序)How far away?
Bartholomew_的博客
10-26 3251
How far away?How far away 题意 思路 欧拉序LCA 欧拉序 RMQ 解释ST 表 代码 代码题意:就是给你一颗树,再给你m个询问,每一个询问包含了两个节点,问你 left -> right 的距离为多少? 是多组数据… 所以,我RE 了好多次!! 结果又是RMQ打萎了! 又是RMQ打萎了…思路(欧拉序+LCA)欧拉序:那么首先,我们要知道什么叫欧拉序 我的专业解释:
欧拉序求LCA
juruo_hejiarui的博客
09-23 715
0 例题引入 给定一个有 nnn 个节点的树，然后有 qqq 次询问，每次询问两个节点 u,vu, vu,v 的 LCA\rm{LCA}LCA 。 1≤n≤3×105,1≤q≤1071 \leq n \leq 3 \times 10^5, 1 \leq q \leq 10^71≤n≤3×105,1≤q≤107 1 讲解 可以发现，倍增和树剖都会 TLE\rm{TLE}TLE ，因为每次询问都是 O(log⁡2n)O(\log_2 n)O(log2​n) 。 1.1 欧拉序 1.1.1 构造方法 实际上是一个
【中科院1区】Matlab实现哈里斯鹰优化算法HHO-SAE实现故障诊断算法研究.rar
最新发布
09-03
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
A_Chrome_extension(mv3)_to_switch_between_differen_MapS
09-03
A_Chrome_extension(mv3)_to_switch_between_differen_MapSwitcher
C++的算法题合集.zip
09-03
c++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zipc++的算法题合集.zip
thulac：清华大学自然语言处理与社会人文计算实验室研制推出的一套中文词法分析工具包
09-03
thulac（Python实现）：清华大学自然语言处理与社会人文计算实验室研制推出的一套中文词法分析工具包 THULAC（THU Lexical Analyzer for Chinese）由清华大学自然语言处理与社会人文计算实验室研制推出的一套中文词法分析工具包，具有中文分词和词性标注功能。THULAC具有如下几个特点： 能力强。利用我们集成的目前世界上规模最大的人工分词和词性标注中文语料库（约含5800万字）训练而成，模型标注能力强大。 准确率高。该工具包在标准数据集Chinese Treebank（CTB5）上分词的F1值可达97.3％，词性标注的F1值可达到92.9％，与该数据集上最好方法效果相当。 速度较快。同时进行分词和词性标注速度为300KB/s，每秒可处理约15万字。只进行分词速度可达到1.3MB/s。
Elasticsearch的Restful风格API
09-03
Elasticsearch的Restful风格API
最小生成森林与RMQ、LCA算法解析
"RMQ&LCA问题的解决方法及其应用" 在信息学竞赛和算法研究中，RMQ（Range Minimum Query，区间最小值查询）和LCA（Lowest Common Ancestor，最近公共祖先）是两个重要的问题。它们分别涉及到在线性序列中查找区间内...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值