LCA

LCA

倍增法

在线算法

时间复杂度：

• 预处理：$O(N)$
• 查询：$O(log_2N)$

这里应用到了树中很重要的倍增思想，其实很多基础的树上操作题都可以用与 LCA 相似的方法求解。

#include<cstdio>
#include<cmath>
using namespace std;

const int MAXN=1000005;

int N,M,S;
int anc[MAXN][20],deep[MAXN];

struct E{int to,next;} e[MAXN];int ecnt,G[MAXN];
void addEdge(int u, int v)
{e[++ecnt]=(E){v,G[u]};G[u]=ecnt;}

void dfs(int u,int ln)
{
    for(int i=G[u];i;i=e[i].next)
    {
        int v=e[i].to;
        if(v==ln) continue;
        deep[v]=deep[u]+1;
        anc[v][0]=u;
        dfs(v,u);        
    }
}

void getReady()
{
    for(int i=1;(1<<i)<=N;i++)
    { 
        for(int j=1;j<=N;j++)
            anc[j][i]=anc[anc[j][i-1]][i-1];
    }
}

int getlca(int x, int y)
{
    int i;
    if(deep[x]<deep[y]) swap(x,y);
    int maxlogn=floor(log(N)/log(2));
    for(i=maxlogn;i>=0;i--)
    {
        if(deep[x]-(1<<i)>=deep[y])
            x=anc[x][i];
    }
    if(x==y) return x;
    for(i=maxlogn;i>=0;i--)
    {
        if(anc[x][i]!=anc[y][i])
        {
            x=anc[x][i];
            y=anc[y][i];
        }
    }
    return anc[x][0];
}

int main()
{
    scanf("%d%d%d",&N,&M,&S);
    for(int i=1;i<N;i++)
    {
        int u,v;scanf("%d%d",&u,&v);
        addEdge(u,v);addEdge(v,u);
    }
    dfs(S,S);
    getReady();
    for(int i=1;i<=M;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        printf("%d\n",getlca(a,b));
    }
    return 0;
}

Tarjan法

离线算法

利用并查集，注意 dfs 时先执行递归操作再加入并查集。

#include<iostream>
#include<cstdio>
using namespace std;

const int MAXN=1000005;

int N,M,S;

//CFS
struct E{int to,next;} e[MAXN];int ecnt,G[MAXN];
void addEdge(int u,int v)
{e[++ecnt]=(E){v,G[u]};G[u]=ecnt;}

//UFS
int fa[MAXN];
inline void initUFS()
{for(int i=1;i<=N;i++) fa[i]=i;}
int getFa(int x)
{return fa[x]==x?fa[x]:fa[x]=getFa(fa[x]);}

struct A{int to,id,next;} ask[MAXN];int acnt,hd[MAXN];
void addAsk(int x,int y,int z)
{ask[++acnt]=(A){y,z,hd[x]};hd[x]=acnt;}

int ans[MAXN],vis[MAXN];
void calLCA(int u)
{
    int i;vis[u]=true;
    for(i=G[u];i;i=e[i].next)
    {
        int v=e[i].to;
        if(!vis[v])
        {
            calLCA(v);
            fa[v]=u;
        }
    }
    for(i=hd[u];i;i=ask[i].next)
    {
        int v=ask[i].to,id=ask[i].id;
        if(vis[v]) ans[id]=getFa(v);
    }
}

int main()
{
    scanf("%d%d%d",&N,&M,&S);
    int i;
    for(i=1;i<N;i++)
    {
        int u,v;scanf("%d%d",&u,&v);
        addEdge(u,v);addEdge(v,u);
    }
    for(i=1;i<=M;i++)
    {
        int x,y;scanf("%d%d",&x,&y);
        addAsk(x,y,i);addAsk(y,x,i);
    }
    initUFS();
    calLCA(S);
    for(i=1;i<=M;i++)
        printf("%d\n",ans[i]);
    return 0;
}

RMQ法

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>

const int MAXN=5e5+5;

struct E{int next,to;} e[MAXN<<1];int ecnt,G[MAXN];
void addEdge(int u,int v){e[++ecnt]=(E){G[u],v};G[u]=ecnt;}
void addEdge2(int u,int v){addEdge(u,v),addEdge(v,u);}

class LCA
{
    private:
        int ncnt;
        int seq[MAXN<<1],pos[MAXN<<1],dpt[MAXN<<1];
        void dfs(int u,int fa,int d)
        {
            pos[u]=++ncnt,seq[ncnt]=u,dpt[ncnt]=d;
            for(int i=G[u];i;i=e[i].next)
            {
                int v=e[i].to;
                if(v==fa) continue;
                dfs(v,u,d+1);
                seq[++ncnt]=u,dpt[ncnt]=d;
            }
        }
        int f[MAXN<<1][20];
        void initST(int * na,int len)
        {
            int i,k;
            for(i=1;i<=len;i++) f[i][0]=i;
            for(k=1;(1<<k)<=len;k++)
                for(i=1;i+(1<<k)-1<=len;i++)
                {
                    if(dpt[f[i][k-1]]<dpt[f[i+(1<<(k-1))][k-1]])
                        f[i][k]=f[i][k-1];
                    else f[i][k]=f[i+(1<<(k-1))][k-1];
                }
        }
        int calRMQPos(int l,int r)
        {
            int k=std::log(r-l+1)/std::log(2);
            return dpt[f[l][k]]<dpt[f[r+1-(1<<k)][k]]?f[l][k]:f[r+1-(1<<k)][k];
        }
    public:
        void init(int rt)
        {
            ncnt=0;
            memset(seq,0,sizeof(seq));memset(pos,0,sizeof(pos));
            memset(dpt,0,sizeof(dpt));
            dfs(rt,0,1);
            initST(dpt,ncnt);
        }
        int calc(int x,int y)
        {
            x=pos[x],y=pos[y];
            if(x>y) std::swap(x,y);
            return seq[calRMQPos(x,y)];
        }
} lca;

inline int read()
{
    int x=0,flag=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')flag=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*flag;
}

int main()
{
    int N=read(),M=read(),S=read();
    for(int i=1;i<N;i++)
        addEdge2(read(),read());
    lca.init(S);
    while(M--) printf("%d\n",lca.calc(read(),read()));
    return 0;
}