码迷,mamicode.com
首页 > 其他好文 > 详细

【原创】最近公共祖先

时间:2019-06-08 14:39:12      阅读:93      评论:0      收藏:0      [点我收藏+]

标签:appdata   jin   原创   wcc   循环   ++   同步   cti   otc   

【概念与定义】

给定一颗有根树,若节点z既是节点x的祖先,也是节点y的祖先,则称z是x,y的公共祖先。在x,y的所有公共祖先中,深度最大的那个叫最近公共祖先,记为LCA(x,y)。
例如:
技术图片
在这棵树中 17 和 8 的LCA就是 3, 9 和 7 的LCA就是 7 。
 

【算法实现】

  • 暴力

如果我们要求x和y的LCA,那我们就设置两个个指针分别指向他们两个,把这两个指针一个一个节点地往上挪动,直到它们交汇于一点,这一点就是LCA。
这个算法面对大规模数据妥妥的没救,于是我们可以用倍增将其优化到O((nlogn)级别(n为节点数)。
 
  • 向上标记法

对于x和y,我们知道它们到树根的路径只有唯一的一条,那么我们不妨先标记要查询的某一节点到树根的路径上的所有点,再对另一节点执行向树根的搜索(具体方法跟标记第一个点一样),直到找到第一个之前已经标记的那个节点,这个节点就是我们要求的LCA了。具体实现方法,我们可以使用DFS遍历整棵树。
 
  • 树上倍增

树上乱搞算法的一种,用途十分广泛,也可以用来求解LCA问题,是暴力的优化。对于m个询问,复杂度可以达到O((n+m)logn)。
思路跟暴力完全一致,只是用倍增优化了一下,将一个一个节点挪换成 2^0、2^1、2^2···2^k 步的形式向上挪动调整,直到它们挪动到同一个节点。
 
具体算法实现有点麻烦,详细讲一下。
首先是初始化,我们可以预处理出节点之间的继承关系。
由于要使用到每个节点的深度我们可以开一个数组d[]来记录。
 
设f[x][k]为x节点的2^k辈节点,如果该节点不存在,那么f[x][k]=0,否则对于任意的k∈[1,logn],都有f[x][k]=f[f[x][k-1]][k-1]。这相当于做一个动态规划,即不断更新每个节点的父节点。
 
然后是LCA算法的步骤。
我们知道,如果不事先将x和y的指针挪动到同一深度,倍增就比较麻烦。于是我们先把它们用倍增优化挪到同一深度,然后再同步挪动,直到它们处于同一点。
 
于是我们分几个步骤求解:
  1. 若x的深度小于y的,交换他们的值。
  2. 将x上调到与y同一深度。若此时x=y,则直接返回LCA=x,已经找到。
  3. 将x和y同步上调,直到它们交汇前最后一步(因为直接查询f[]数组比在树中找x要方便许多)。把它们依次尝试挪动 2^logn···2^2、2^1 步,保持它们在同一深度。每走一步,若f[x][k]!=f[y][k],就令x=f[x][k],y=f[y][k],即向上调整。
  4. LCA就是执行完第三步的的f[x][0]。
 
代码如下:
//树上倍增LCA 70pnts 复杂度O((n+m)logn) 
#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstring>
#include<ctime>
#include<cstdlib>
#include<algorithm>
#include<queue>
#include<set>
#include<map>
#define N 500010
using namespace std;
struct tree{
    int next,ver;
}g[N<<2];
queue<int> q;
int head[N<<2],tot,t,n,m,s;//t树的深度 
int d[N<<2],f[N<<1][30];//d[]某结点处树的深度,f[x][i]第x个结点向根节点走2^i步的结点 
void add(int x,int y)
{
    g[++tot].ver=y;
    g[tot].next=head[x],head[x]=tot;
}
void reset(int x)
{
    memset(d,0,sizeof(d));
    q.push(x);
    d[x]=1;
    while(q.size())
    {
        int index=q.front();q.pop();//index是相对当前遍历节点的父节点 
        for(int i=head[index];i;i=g[i].next)
        {
            int y=g[i].ver;
            if(d[y]) continue;//如果已经处理过了就进入下一轮循环 
            d[y]=d[index]+1;//深度增加 
            f[y][0]=index;//你爸是我 
            for(int j=1;j<=t;j++)
                f[y][j]=f[f[y][j-1]][j-1];
            q.push(y);
        }
    }
}
int lca(int x,int y)
{
    if(d[x]<d[y]) swap(x,y);//使得x比y深度大 
    for(int i=t;i>=0;i--)
        if(d[f[x][i]]>=d[y]) x=f[x][i];//使得x与y深度相等 
    if(x==y) return x;
    for(int i=t;i>=0;i--)
        if(f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i];
    return f[x][0];//此时x和y并未更新为它们的LCA,而是刚好在它下面一个结点,于是我们返回这个结点的爸爸 
}
int main()
{
    scanf("%d%d%d",&n,&m,&s);
    t=(int)(log(n)/log(2))+1;
    for(int i=1;i<=n-1;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        add(x,y);add(y,x);
    }
    reset(s);
    for(int i=1;i<=m;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        cout<<lca(x,y)<<endl;
    }
    return 0;
}

 

 

  • Tarjan

总之,是一个很重要的算法。
Tarjan算法是向上标记法的并查集优化版本,体现了“并查集维护节点之间的关系”的重要特性。它是一个离线算法,复杂度为O(n+m)。
 
在DFS时,我们对如下3种节点进行标记:
  1. 回溯完毕的节点,标记为1
  2. 递归完毕而未回溯的节点,标记为2
  3. 没被递归的节点,标记为0
 
如同向上标记法的思路,我们知道遍历完的节点都被标记为第一种状态,那么当我们递归到某两个要查询的节点x和y时,如果其中一个已经回溯完毕,比如x,那么我们这时的LCA就是y向根节点走遇到的第一个标记为1的节点。而这个过程,恰恰可以用并查集优化。当一个结点获得1的标记时,就把它所在的集合跟它的父节点集合合并,这样遍历完一条支链后x的集合的代表元就是树根,遍历完下一条支链时,代表元就会是两支链的最近交点!
 
所以这样我们可以用并查集记录下某两次遍历产生的交点,而这个节点就是这两次遍历经过的某些x和y的LCA。
 
代码如下(话说我写的这个代码的标记编号好像跟上面讲的是反的==):
//Tarjan O(n+m)
#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstring>
#include<ctime>
#include<cstdlib>
#include<algorithm>
#include<queue>
#include<set>
#include<map>
#define N 500010
using namespace std;
struct tree{
    int next,ver;
}g[N<<2];
queue<int> q;
int head[N<<2],tot,t,n,m,s;//t树的深度 
int fa[N<<1],v[N],lca[N],ans[N];//d[]某结点处树的深度,f[x][i]第x个结点向根节点走2^i步的结点 
vector<int> query[N],query_id[N];
void add(int x,int y)
{
    g[++tot].ver=y;
    g[tot].next=head[x],head[x]=tot;
}
void add_query(int x,int y,int id)
{
    query[x].push_back(y),query_id[x].push_back(id);
    query[y].push_back(x),query_id[y].push_back(id);
}

int get(int x)
{
    if(fa[x]==x) return x;
    return fa[x]=get(fa[x]);
}
void tarjan(int x)
{
    v[x]=1;//标记这个结点被递归到 
    for(int i=head[x];i;i=g[i].next){//dfs整颗树 
        int y=g[i].ver;
        if(v[y]) continue;
        tarjan(y);
        fa[y]=x;//将这个结点和它的父节点合并 
    }
    for(int i=0;i<query[x].size();i++){//检查关于当前所在结点的询问 
        int y=query[x][i],id=query_id[x][i];//取出询问 
        if(v[y]==2){//如果该结点已经回溯 
            int lca=get(y);//当前x与y的LCA 
            ans[id]=lca;
        }
    }
    v[x]=2;//回溯,标记为2 
}
int main()
{
    scanf("%d%d%d",&n,&m,&s);
    t=(int)(log(n)/log(2))+1;//树的深度 
    for(int i=1;i<=n;i++){//初始化 
        head[i]=0,fa[i]=i,v[i]=0;
        query[i].clear(),query_id[i].clear();
    }
    for(int i=1;i<=n-1;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        add(x,y);add(y,x);
    }
    for(int i=1;i<=m;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        if(x==y) ans[i]=x;
        else{
            add_query(x,y,i);//输入询问 
        }
    }
    tarjan(s);
    for(int i=1;i<=m;i++) printf("%d\n",ans[i]);
    return 0;
}

 



 

【原创】最近公共祖先

标签:appdata   jin   原创   wcc   循环   ++   同步   cti   otc   

原文地址:https://www.cnblogs.com/DarkValkyrie/p/10990500.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!