题355.lca问题-acwing-Q1636--最低公共祖先

最新推荐文章于 2024-06-13 11:24:02 发布
最新推荐文章于 2024-06-13 11:24:02 发布
阅读量87 收藏
点赞数
分类专栏： 算法相关 文章标签： 图论 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51352378/article/details/125727084
版权

文章目录

题355.lca问题-acwing-Q1636–最低公共祖先

一、题目

在这里插入图片描述
在这里插入图片描述

二、题解

本题关键在于先建树，然后由于这里是给的节点数据不是编号所以得做一手离散化处理，之后再套lca板子即可。代码如下：

//createTree建BST+tarjan:AC
#include <bits/stdc++.h>

using namespace std;

typedef pair<int,int> pii;

const int Inf=0x3f3f3f3f;
const int maxn=1e4+1,maxm=2*maxn,maxk=11;

typedef struct Tnode *Position;
typedef Position BinT;
struct Tnode
{
    int data;
    BinT l,r;
};

int N,M;
int pre[maxn],in[maxn];
int sign[maxn];
unordered_map<int,int> id;
int h[maxn],e[maxm],ne[maxm],idx;
vector<pii> qry[maxn],q;
int d[maxn],fa[maxn][maxk];
int p[maxn],flag[maxn],res[1100];

void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

BinT createTree(int start,int over)
{
    int pos=-1;
    for(int i=0;i<N;i++)
    {
        if(sign[i]) continue;//该节点已经建立过了直接continue起到加速的作用
        for(int j=start;j<over;j++)
        {
            if(in[j]==pre[i])
            {
                sign[i]=1;
                pos=j;
                break;
            }
        }
        if(pos!=-1) break;
    }
    BinT T=new Tnode();
    T->data=in[pos];
    if(pos>start)
    {
        T->l=createTree(start,pos);
        add(id[T->data],id[T->l->data]),add(id[T->l->data],id[T->data]);
    }
    else T->l=NULL;
    if(pos+1<over)
    {
        T->r=createTree(pos+1,over);
        add(id[T->data],id[T->r->data]),add(id[T->r->data],id[T->data]);
    }
    else T->r=NULL;
    return T;
}

int findRoot(int v)
{
    if(p[v]==v) return p[v];
    else return p[v]=findRoot(p[v]);
}

void tarjan(int u)
{
    flag[u]=1;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!flag[j])
        {
            tarjan(j);
            p[j]=u;
        }
    }
    for(auto qq:qry[u])
    {
        int y=qq.first,id=qq.second;
        if(flag[y]==2)
        {
            int root=findRoot(y);
            res[id]=root;
        }
    }
    flag[u]=2;
}

int main()
{
    scanf("%d%d",&M,&N);
    memset(h,-1,sizeof h);
    for(int i=0;i<N;i++)
    {
        scanf("%d",&pre[i]);
        in[i]=pre[i];
    }
    sort(in,in+N);//想到BST中序遍历序列就是从小到大排的递增序列，所以想到与已知pre和in序列还原二叉树，所以可以用createTree来加快建树而不用insertTnode
    for(int i=0;i<N;i++) id[in[i]]=i+1;//离散化
    BinT T=createTree(0,N);
    for(int i=0;i<M;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        q.push_back({u,v});
        if(id.count(u)&&id.count(v)&&u!=v)
        {
            qry[id[u]].push_back({id[v],i}),qry[id[v]].push_back({id[u],i});
        }
    }
    for(int i=1;i<=N;i++) p[i]=i;
    tarjan(id[T->data]);
    for(int i=0;i<q.size();i++)
    {
        int u=q[i].first,v=q[i].second;
        if(id.count(u)==0&&id.count(v)==0) printf("ERROR: %d and %d are not found.\n",u,v);
        else if(id.count(u)==0) printf("ERROR: %d is not found.\n",u);
        else if(id.count(v)==0) printf("ERROR: %d is not found.\n",v);
        else if(u==v) printf("%d is an ancestor of %d.\n",u,v);
        else
        {
            int pid=res[i];
            if(pid==id[u]) printf("%d is an ancestor of %d.\n",u,v);
            else if(pid==id[v]) printf("%d is an ancestor of %d.\n",v,u);
            else
            {
                printf("LCA of %d and %d is %d.\n",u,v,in[pid-1]);
            }
        }
    }
}


/*
//insertTnode建BST+倍增lca：超时
#include <bits/stdc++.h>

using namespace std;

const int Inf=0x3f3f3f3f;
const int maxn=1e4+1,maxm=2e4+2,maxk=11;

typedef struct Tnode *Position;
typedef Position BinT;
struct Tnode
{
    int data;
    BinT l,r;
};

int N,M;
int num[maxn];
unordered_map<int,int> id;
int h[maxn],e[maxm],ne[maxm],idx;
int d[maxn],fa[maxn][maxk];

void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

BinT insertTnode(int data,BinT T)
{
    if(!T)
    {
        T=new Tnode();
        T->data=data;
        T->l=NULL;
        T->r=NULL;
    }
    else
    {
        if(data<T->data)
        {
            T->l=insertTnode(data,T->l);
        }
        else
        {
            T->r=insertTnode(data,T->r);
        }
    }
    return T;
}

void levelOrderTraversal(BinT T)
{
    queue<BinT> q;
    q.push(T);
    while(!q.empty())
    {
        BinT TempT=q.front();
        q.pop();
        //cout<<TempT->data<<endl;
        if(TempT->l)
        {
            //cout<<id[TempT->l->data]<<" "<<id[TempT->data]<<endl;
            add(id[TempT->l->data],id[TempT->data]),add(id[TempT->data],id[TempT->l->data]);
            q.push(TempT->l);
        }
        if(TempT->r)
        {
            //cout<<id[TempT->r->data]<<" "<<id[TempT->data]<<endl;
            add(id[TempT->r->data],id[TempT->data]),add(id[TempT->data],id[TempT->r->data]);
            q.push(TempT->r);
        }
    }
}

void preOrderTraversal(BinT T)
{
    if(!T)
    {
        return;
    }
    cout<<T->data<<endl;
    if(T->l)
    {
        add(id[T->l->data],id[T->data]);
        preOrderTraversal(T->l);
    }
    if(T->r)
    {
        add(id[T->r->data],id[T->data]);
        preOrderTraversal(T->r);
    }
}

void bfs(int root)
{
    memset(d,Inf,sizeof d);
    queue<int> q;
    q.push(root);
    d[0]=0,d[root]=1;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]>d[t]+1)
            {
                d[j]=d[t]+1;
                q.push(j);
                fa[j][0]=t;
                for(int k=1;k<=maxk-1;k++)
                {
                    fa[j][k]=fa[fa[j][k-1]][k-1];
                }
            }
        }
    }
}

int lca(int a,int b)
{
    if(d[a]<d[b]) swap(a,b);
    for(int k=maxk-1;k>=0;k--)
    {
        if(d[fa[a][k]]>=d[b])
        {
            a=fa[a][k];
        }
    }
    if(a==b)
    {
        return a;
    }
    for(int k=maxk-1;k>=0;k--)
    {
        if(fa[a][k]!=fa[b][k])
        {
            a=fa[a][k];
            b=fa[b][k];
        }
    }
    return fa[a][0];
}

int main()
{
    BinT T=NULL;
    scanf("%d%d",&M,&N);
    for(int i=0;i<N;i++)
    {
        scanf("%d",&num[i]);
        id[num[i]]=i+1;
        T=insertTnode(num[i],T);
    }
    memset(h,-1,sizeof h);
    levelOrderTraversal(T);
    bfs(id[T->data]);
    for(int i=0;i<M;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        if(id.count(u)==0&&id.count(v)==0) printf("ERROR: %d and %d are not found.\n",u,v);
        else if(id.count(u)==0) printf("ERROR: %d is not found.\n",u);
        else if(id.count(v)==0) printf("ERROR: %d is not found.\n",v);
        else
        {
            int pid=lca(id[u],id[v]);
            if(pid==id[u]) printf("%d is an ancestor of %d.\n",u,v);
            else if(pid==id[v]) printf("%d is an ancestor of %d.\n",v,u);
            else
            {
                printf("LCA of %d and %d is %d.\n",u,v,num[pid-1]);
            }
        }
    }
}
*/

//insertTnode建BST+tarjan：超时
#include <bits/stdc++.h>

using namespace std;

typedef pair<int,int> pii;

const int Inf=0x3f3f3f3f;
const int maxn=1e4+1,maxm=2*maxn,maxk=11;

typedef struct Tnode *Position;
typedef Position BinT;
struct Tnode
{
    int data;
    BinT l,r;
};

int N,M;
int num[maxn];
unordered_map<int,int> id;
int h[maxn],e[maxm],ne[maxm],idx;
vector<pii> qry[maxn],q;
int d[maxn],fa[maxn][maxk];
int p[maxn],flag[maxn],res[1100];

void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

BinT insertTnode(int data,BinT T,int fa)
{
    if(!T)
    {
        T=new Tnode();
        T->data=data;
        add(id[T->data],fa),add(fa,id[T->data]);
        T->l=NULL;
        T->r=NULL;
    }
    else
    {
        if(data<T->data)
        {
            T->l=insertTnode(data,T->l,id[T->data]);
        }
        else
        {
            T->r=insertTnode(data,T->r,id[T->data]);
        }
    }
    return T;
}

int findRoot(int v)
{
    if(p[v]==v)
    {
        return p[v];
    }
    else
    {
        return p[v]=findRoot(p[v]);
    }
}

void tarjan(int u)
{
    flag[u]=1;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!flag[j])
        {
            tarjan(j);
            p[j]=u;
        }
    }
    for(auto qq:qry[u])
    {
        int y=qq.first,id=qq.second;
        if(flag[y]==2)
        {
            int root=findRoot(y);
            res[id]=root;
        }
    }
    flag[u]=2;
}

int main()
{
    BinT T=NULL;
    scanf("%d%d",&M,&N);
    memset(h,-1,sizeof h);
    for(int i=0;i<N;i++)
    {
        scanf("%d",&num[i]);
        id[num[i]]=i+1;
        T=insertTnode(num[i],T,0);
    }
    for(int i=0;i<M;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        q.push_back({u,v});
        if(id.count(u)&&id.count(v)&&u!=v)
        {
            qry[id[u]].push_back({id[v],i}),qry[id[v]].push_back({id[u],i});
        }
    }
    for(int i=1;i<=N;i++)
    {
        p[i]=i;
    }
    tarjan(id[T->data]);
    for(int i=0;i<q.size();i++)
    {
        int u=q[i].first,v=q[i].second;
        if(id.count(u)==0&&id.count(v)==0) printf("ERROR: %d and %d are not found.\n",u,v);
        else if(id.count(u)==0) printf("ERROR: %d is not found.\n",u);
        else if(id.count(v)==0) printf("ERROR: %d is not found.\n",v);
        else if(u==v) printf("%d is an ancestor of %d.\n",u,v);
        else
        {
            int pid=res[i];
            //cout<<pid<<endl;
            if(pid==id[u]) printf("%d is an ancestor of %d.\n",u,v);
            else if(pid==id[v]) printf("%d is an ancestor of %d.\n",v,u);
            else
            {
                printf("LCA of %d and %d is %d.\n",u,v,num[pid-1]);
            }
        }
    }
}
Adongua
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lca_com.zui.filemanager-77090100.apk
05-22
lca_com.zui.filemanager-77090100.apk
第4章 倍增求LCA-2019-12-05.pdf
12-05
第4章 倍增求LCA-2019-12-05 第4章 倍增求LCA-2019-12-05 第4章 倍增求LCA-2019-12-05
最近公共祖先(LCA)
weixin_42638946的博客
03-30 2006
最近公共祖先(LCA) 1. 最近公共祖先原理 原理 LCA问题：在一棵有根树中，一个节点的祖先节点是指它本身或者它父节点的祖先。给定两个节点，两个点共同的祖先中距离两者最近的节点就是这两个节点的最近公共祖先。需要注意的是最近公共祖先可能是这两个节点中的某一个。 LCA问题的解法有很多种，下面介绍四种，其中第二种、第三种最常用 1. 向上标记法 做法：求两个节点p、q的最近公共祖先原理，可以任选一个点，比如点p，沿着点p向上走，将走过的节点标记为true，代表已经走过，走到根节点后停止；然后让q
【ACWing】1644. 二叉树中的最低公共祖先
数学、算法爱好者的博客
05-14 459
题目地址： https://www.acwing.com/problem/content/description/1646/ 树中两个结点UUU和VVV的最低公共祖先（LCA）是指同时具有UUU和VVV作为后代的最深结点。给定二叉树中的任何两个结点，请你找到它们的LCA。 输入格式： 第一行包含两个整数MMM和NNN，分别表示询问结点对数以及二叉树中的结点数量。接下来两行，每行包含NNN个不同的整数，分别表示二叉树的中序和前序遍历。保证二叉树可由给定遍历序列唯一确定。接下来MMM行，每行包含两个整数UUU和
树上倍增法求最近公共祖先
m0_62021646的博客
04-07 331
最近公共祖先 概念定义 对于节点x,y而言,如果说z节点既是x的祖先节点,也是y的祖先节点. 那么我们认为z节点是(x,y)的公共祖先节点. 公共祖先节点有很多,那么深度最大的节点,被称之为最近公共祖先.记为LCA(x,y) 也可以认为LCA(x,y)节点,是所有公共祖先节点中,离着x,y这两个点的距离最近. 以这张图片为例 Lca(1,2)=1Lca(2,3)=1Lca(4,5)=2Lca(4,6)=1Lca(5,3)=1 Lca(1,2)=1\\ Lca(2,3)=1\\ Lca(4,5)=2\\ L
算法刷题总结
qq_45818845的博客
03-25 1915
算法刷题总结 动态规划 提高课dp题解集合 提高课题单+题解(69/220) - AcWing 背包问题模板 题目链接 题意描述 题目总结 c++题解 python3题解 Java题解 自己的代码 [01背包问题](2. 01背包问题 - AcWing题库) 背包容量mmm​，物品数nnn,每个物品只能选一次， 第一层循环枚举所有物品，第二层循环倒着枚举体积 完全背包问题 背包容量mmm，物品数nnn,每个物品可以无限选 第一层循环枚举所有物品，由于不限制每个物品的数量第二层循环
【PAT】05 树
weixin_42638946的博客
08-26 148
第五章 树 AcWing 1476. 数叶子结点 问题描述 问题链接：AcWing 1476. 数叶子结点、原题链接 分析 使用邻接表存储树。然后可以使用BFS或者DFS遍历整棵树，在遍历的过程中记录每层的叶节点个数即可。 代码 C++ #include <iostream> #include <cstring> using namespace std; const int N = 110; int n, m; int h[N], e[N], ne
个人C++随笔
qq_56586293的博客
03-26 221
个人关于算法的随笔
[蓝桥杯 2023 省 A] 颜色平衡树：从零开始理解树上莫队 一颗颜色平衡树引发的惨案
Ramon_cnyali的博客
03-26 2127
十四是一名7年没碰过信息学竞赛的蒟蒻，有一天他看见了一颗颜色平衡树，这是他脑内发生的变化
【9/155倒计时11day】PAT（甲级）2018年秋季考试
viVi_beea的博客
09-01 89
PAT（甲级）2018年秋季考试 嘤嘤 可以说是更差了，加油吧555 第一题就看不懂不理解，心态有点不好，最后半小时放弃了 7-1 Werewolf - Simple Version 基础算法+数据结构——AcWing 1641. 狼人杀-简单版 7-2 Dangerous Goods Packaging 哈希表——AcWing 1642. 危险品装箱 7-3 Travelling Salesman Problem 图论——AcWing 1643. 旅行商问题 7-4 LCA in a Binary Tr
算法笔记(个人用)(不定期更新)
cuber-lotus的博客
03-23 2387
文章目录前言说明Note文档编辑相关语言特性相关 (C/C++)输出数组最后一个元素后面无空格二分查找函数rand() 范围算法相关排序区间求和题单基础数学素数素数判断素数筛朴素筛选 (埃式筛)朴素筛选优化线性筛 (欧拉筛)闰年判断蔡勒（Zeller）公式GCD10转R进制卡特兰数完美数分解因数欧几里得-欧拉定理数根[1~n] 中完全平方数的个数计算Π pia二分查找顺序序列找唯一值逼近类二分容斥原理位运算整形存储大小intlong long`__builtin_函数`取模自动取模工具类除法取模判断奇偶统计
LCA.tar.zip_二叉树的最近公共祖先问题
09-20
设计一个算法，对于给定的树中2 结点返回它们的最近公共祖先。 对于给定的树，和树中结点对，编程计算结点对的最近公共祖先。
lca_com.lenovo.leos.appstore-120430-1704680771829.apk
01-08
lca_com.lenovo.leos.appstore-120430-1704680771829.apk
lca_zhiyouji.apk-1-1716628444298.bin
05-25
lca_zhiyouji.apk-1-1716628444298.bin
【图论应用】使用多路图（multigraph）对上海地铁站点图建模，并解决最短路径问题
takedachia的博客
06-10 892
【图论应用】使用多路图（multigraph）对上海地铁站点图建模，并解决最短路径问题
算法笔记 图论和优先级队列的笔记
qq_46644680的博客
06-12 482
DFS stack O(h) 不具有最短性BFS queue O(2^h) 最短路迪杰斯特拉算法A0Auuvuvvvv。
多源最短路径算法 -- 弗洛伊德（Floyd）算法
最新发布
qq_67342067的博客
06-13 1040
总的来说，Floyd算法是一种计算图中所有顶点对之间最短路径的动态规划算法，它能够处理包含负权边的图，但不允许存在负权回路。适用于小型到中等规模稠密图的算法，尤其是在需要全局最短路径信息时。对于大型稀疏图或者单源最短路径问题，其他算法如Dijkstra算法可能更加合适。
图论第6天
weixin_41902984的博客
06-04 688
提高效率!!!两道题+看并查集。
makefile -lca
08-18
在Makefile中，`-lca`是一个编译选项，用于指定需要链接的库文件。具体来说，`-l`选项用于指定要链接的库，而`-c`选项用于编译源文件而不进行链接。 例如，假设你有一个名为`main.c`的源文件，并且你想链接一个名为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值