tarjan lca

GeneralLiu

一种离线求最近公共祖先方法

 

“离线

 即在有好多询问情况下

 记录所有询问

 一起处理，一起回答

 相对的

 在线

 即在有好多询问情况下

 每询问一次

 处理一次，回答一次

”

涉及并查集

 

这个博客，tarjan 写的很详细

 

步骤

 

1 从根开始 tarjan （或者说dfs）

2 每dfs到一个点

  将它加入一个独立的集合 // fa[u]=u; fa[]为并查集数组，表示祖先

  枚举它的儿子 //for : son

  进行儿子的dfs // dfs(son)

3 枚举和它相关的询问 // for : the questions which is relates to the node

   如果 相关的 询问已经 被 dfs 了

　那么 这个询问 的答案 就是 询问点的 祖先

 

代码

#include<iostream>
#include<cstdio>
using namespace std;
int f[500010],qhead[500010],head[500010],n,m,s,vis[500010];

//记录树边 和 询问 （链式前向星）
struct Edge{
    int next,to;
}e[1000010];
struct qs{
    int next,to,ans;
}q[1000010];

void add(int x,int y,int k){
    e[k]=(Edge){head[x],y};
    head[x]=k;
}
void add1(int x,int y,int k){
    q[k]=(qs){qhead[x],y,0};
    qhead[x]=k;
}

int find(int k){//路径压缩
    if(f[k]==k)return k;
    return f[k]=find(f[k]);
}

void join(int a,int b){
    int fa=find(a),fb=find(b);
    if(fa!=fb)f[fa]=fb;
}

//tarjan 
void dfs(int k){
    vis[k]=1;
    for(int i=head[k];i;i=e[i].next){//步骤2
        if(!vis[e[i].to]){
            dfs(e[i].to);
            join(e[i].to,k);
            
        }
    }
    for(int j=qhead[k];j;j=q[j].next){//步骤3
        if(vis[q[j].to]==2){
            q[j].ans=find(q[j].to);
            if(j%2)q[j+1].ans=q[j].ans;
            else q[j-1].ans=q[j].ans;
        }
    }
    vis[k]=2;
}

int main(){
    scanf("%d%d%d",&n,&m,&s);
    for(int X,Y,i=1;i<n;i++){
        scanf("%d%d",&X,&Y);
        add(X,Y,i*2-1);//存两遍
        add(Y,X,i*2);
        f[i]=i;
    }
    f[n]=n;
    for(int x,y,i=1;i<=m;i++){
        scanf("%d%d",&x,&y);
        add1(x,y,i*2-1);//两遍
        add1(y,x,i*2);
    }
    dfs(s);//步骤1
    for(int i=1;i<=n;i++)printf("%d
",q[i*2].ans);//存了两遍，两个一输出
    return 0;
}