LCA模板（tarjan+ST+倍增）

离线    tarjan：每次找最接近叶子节点的根，如果询问的两点在这个根上（两点能被这个根同时访问），则这个根为两点的lca

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
const int N=500005;
int vis[N],f[N],ans[N];
vector<int>e[N],num[N],q[N];
int getf(int x)
{
    return f[x]==x?x:f[x]=getf(f[x]);
}
void mix(int x,int y)
{
    int tx=getf(x);
    int ty=getf(y);
    if(tx!=ty)
    {
        f[tx]=ty;
    }
}
void tarjan(int u)
{
    vis[u]=1;
    for(int i=0;i<e[u].size();i++)
    {
        int v=e[u][i];
        if(!vis[v])
        {
            tarjan(v);
            mix(v,u);
        }
    }
    for(int i=0; i<q[u].size(); i++)
    {
        int v=q[u][i];
        if(vis[v])
        {
            ans[num[u][i]]=getf(v);
        }
    }
}
int main()
{
    int n,u,v,m,s,root;
    scanf("%d%d%d",&n,&m,&root);
    for(int i=1;i<=n;i++)f[i]=i;
    for(int i=1;i<n;i++)
    {
        scanf("%d%d",&u,&v);
        e[u].push_back(v);
        e[v].push_back(u);
    }
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&u,&v);
        q[u].push_back(v);
        num[u].push_back(i);
        q[v].push_back(u);
        num[v].push_back(i);
    }
    tarjan(root);
    for(int i=1;i<=m;i++)
        printf("%d\n",ans[i]);
    return 0;
}

在线    ST(RMQ+dfs序):

首先得出一个dfs表，记录每个点出现的最早时间，则在dfs表中两点的最小时间之间 出现时间最早的点 即为lca

#include<bits/stdc++.h>
using namespace std;
const int N=5e5+50;
int num[N<<2],pos[N<<2],tot,f[N<<1][21],loc[N<<1][21];
vector<int>e[N];
void dfs(int u,int fa)
{
    num[++tot]=u;
    for(int i=0;i<e[u].size();i++)
    {
        int v=e[u][i];
        if(v==fa)continue;
        dfs(v,u);
        num[++tot]=u;
    }
}
void init()
{
    for(int i=1;i<=tot;i++)
        {
            f[i][0]=pos[num[i]];
            loc[i][0]=num[i];
        }

    for(int j=1;j<20;j++)
    {
        int k=tot-(1<<j)+1;
        for(int i=1;i<=k;i++)
        {
            int x=i+(1<<(j-1));
            if(f[i][j-1]<=f[x][j-1])
            {
                f[i][j]=f[i][j-1];
                loc[i][j]=loc[i][j-1];
            }
            else
            {
                f[i][j]=f[x][j-1];
                loc[i][j]=loc[x][j-1];
            }
        }
    }
}
int find(int x,int y)
{
    int a,b,k;
    a=min(x,y);
    b=max(x,y);
    k=log(b-a+1.0)/log(2.0);
    if(f[a][k]<=f[b-(1<<k)+1][k])
        return loc[a][k];
    return loc[b-(1<<k)+1][k];
}
int main()
{
        int n,m,s,x,y;
    scanf("%d%d%d",&n,&m,&s);
    for(int i=1;i<n;i++)
    {
        scanf("%d%d",&x,&y);
        e[x].push_back(y);
        e[y].push_back(x);
    }
    dfs(s,-1);
    for(int i=1;i<=tot;i++)
    if(pos[num[i]]==0)pos[num[i]]=i;
    init();
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        printf("%d\n",find(pos[x],pos[y]));
    }
    return 0;
}

在线    倍增：同样也是用二进制优化，预处理出每个点的第2^i个父节点是谁，先将两个点处理到相同深度，然后同时向上找父节点（因为每个点距lca的深度可以用二进制表示）

#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
const int N=5e5+50;
int f[N][21],d[N],n;
vector<int>e[N];
void dfs(int u)
{
    for(int i=0;i<e[u].size();i++)
    {
        int v=e[u][i];
        if(v==f[u][0])continue;
        d[v]=d[u]+1;
        f[v][0]=u;
        dfs(v);
    }
}
void init()
{
    for(int j=1;(1<<j)<=n;j++)
    {
        for(int i=1;i<=n;i++)
        {
            f[i][j]=f[f[i][j-1]][j-1];
        }
    }
}
int lca(int a,int b)
{
    if(d[a]>d[b])swap(a,b);
    int p=d[b]-d[a];
    for(int i=0;(1<<i)<=p;i++)
        if((1<<i)&p)b=f[b][i];
    if(a!=b)
    {
        for(int i=(int)log2(N);i>=0;i--)
        {
            if(f[a][i]!=f[b][i])
                a=f[a][i],b=f[b][i];
        }
        a=f[a][0];
    }
    return a;
}
int main()
{
    int m,s,x,y;
    scanf("%d%d%d",&n,&m,&s);
    for(int i=1;i<n;i++)
    {
        scanf("%d %d",&x,&y);
        e[x].push_back(y);
        e[y].push_back(x);
    }
    dfs(s);
    init();
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        printf("%d\n",lca(x,y));
    }
    return 0;
}