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

最新推荐文章于 2024-11-06 11:05:01 发布
最新推荐文章于 2024-11-06 11:05:01 发布
阅读量105 收藏
点赞数
分类专栏： 算法相关 文章标签： 图论 算法
版权声明：本文为博主原创文章，遵循 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]);
            }
        }
    }
}
【ACWing】1644. 二叉树中的最低公共祖先
数学、算法爱好者的博客
05-14 523
题目地址： https://www.acwing.com/problem/content/description/1646/ 树中两个结点UUU和VVV的最低公共祖先（LCA）是指同时具有UUU和VVV作为后代的最深结点。给定二叉树中的任何两个结点，请你找到它们的LCA。 输入格式： 第一行包含两个整数MMM和NNN，分别表示询问结点对数以及二叉树中的结点数量。接下来两行，每行包含NNN个不同的整数，分别表示二叉树的中序和前序遍历。保证二叉树可由给定遍历序列唯一确定。接下来MMM行，每行包含两个整数UUU和
最近公共祖先(LCA)
weixin_42638946的博客
03-30 3157
最近公共祖先(LCA) 1. 最近公共祖先原理 原理 LCA问题：在一棵有根树中，一个节点的祖先节点是指它本身或者它父节点的祖先。给定两个节点，两个点共同的祖先中距离两者最近的节点就是这两个节点的最近公共祖先。需要注意的是最近公共祖先可能是这两个节点中的某一个。 LCA问题的解法有很多种，下面介绍四种，其中第二种、第三种最常用 1. 向上标记法 做法：求两个节点p、q的最近公共祖先原理，可以任选一个点，比如点p，沿着点p向上走，将走过的节点标记为true，代表已经走过，走到根节点后停止；然后让q
树上倍增法求最近公共祖先
m0_62021646的博客
04-07 367
最近公共祖先 概念定义 对于节点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 2095
算法刷题总结 动态规划 提高课dp题解集合 提高课题单+题解(69/220) - AcWing 背包问题模板 题目链接 题意描述 题目总结 c++题解 python3题解 Java题解 自己的代码 [01背包问题](2. 01背包问题 - AcWing题库) 背包容量mmm​，物品数nnn,每个物品只能选一次， 第一层循环枚举所有物品，第二层循环倒着枚举体积 完全背包问题 背包容量mmm，物品数nnn,每个物品可以无限选 第一层循环枚举所有物品，由于不限制每个物品的数量第二层循环
数据结构1
Water_Sunzhipeng的博客
08-08 647
维护前缀和和区间修改1。从父节点走到子节点，寻找x若干个0，2.通过子节点找父节点找到所有包含x的子节点，怎么找，找到的是直接包含的区间，唯一的直接影响的区间，树p = x + lowbit(x)， 从下往上迭代的过程，直接前驱：查询前缀和点更新建树，因为tr[i]指的区间是[x-lowbit(x)+ 1,x]而不是前缀和，所以不应该跳到之前的位数上比如c[3]= a[3]而不是c[3] = a[3] + c[2];第0层。
【PAT】05 树
weixin_42638946的博客
08-26 184
第五章 树 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
算法の笔记
weixin_45419526的博客
08-15 799
包括基本算法、数据结构、图论、动态规划、数学知识、字符串
个人C++随笔
qq_56586293的博客
03-26 303
个人关于算法的随笔
ACM算法竞赛代码模板（长期更新）
光mon的博客
05-10 1287
代码模板
lca_jiaojiaoxueyuan-1.84.0-8457-tinman.apk-1-1717000443129.bin
05-30
lca_jiaojiaoxueyuan-1.84.0-8457-tinman.apk-1-1717000443129.bin
lca_com.lenovo.leos.appstore-120430-1704680771829.apk
01-08
lca_com.lenovo.leos.appstore-120430-1704680771829.apk
lca_com.lenovo.leos.appstore-120000-1683549879122.apk
05-08
lca_com.lenovo.leos.appstore-120000-1683549879122.apk
lca_com.zui.filemanager-77090210.apk
06-22
lca_com.zui.filemanager-77090210.apk
lca_com.zui.filemanager-77090100.apk
05-22
lca_com.zui.filemanager-77090100.apk
LeetCode 热题100之图论
qq_43060884的博客
11-03 1049
都很重要~
100种算法【Python版】第36篇——Graham Scan算法
AnFany
11-02 263
100种算法【Python版】第36篇——Graham Scan算法
算法基础-链表
August的专栏
11-05 195
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
100种算法【Python版】第51篇——希尔排序
最新发布
AnFany
11-06 171
100种算法【Python版】第51篇——希尔排序
深⼊理解指针2
ElePower9527的博客
11-01 680
指针访问数组内容时，有如下代码这⾥我们使⽤ &arr[0] 的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且 是数组⾸元素的地址，我们来做个测试。输出结果我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址。注意有两个例外• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩， 单位是字节。
COSEL LCA50S-3模块电源规格及特性介绍
LCA系列包括多个型号，如LCA10S-5、LCA10S-5-H、LCA10S-12等，最大输出功率从10瓦到12瓦不等，支持不同的直流电压输出，如5V、12V、15V和24V，电流能力也有所不同。 每个型号的主要特性包括： 1. 输入参数：电源...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值