对于一棵树上的两个点，他们的所有公共祖先中深度最大的那一个被称为它们的最近公共祖先（LCA）。求 LCA 有很多不同的方法。
倍增
倍增求 LCA，首先需要对树进行 dfs（废话），标记每个节点的直接父亲（\(2^0\) 级祖先）。然后我们就可以利用倍增的思想预处理它的第 \(2^1, 2^2, ... ,2^{\log n}\) 级祖先。然后就可以在线地求两个点（设为 \(x, y\)，且有深度关系 \(d_x>d_y\)）的 LCA。步骤如下：
- 判断 \(x\) 与 \(y\) 是否相等，是则返回 \(x\)；
- 让 \(x\) 往上跳，直到与 \(y\) 的深度相同；
- 重复第 \(1\) 步；
- 让 \(x\) 和 \(y\) 往上跳，但是两个点不能相遇；
- 返回 \(fa_{x,0}\)。
复杂度为 \(O(q \log n)\)。一般来说是够用的。
代码：
int lmt,d[N],f[N][50];
void init()
{for(int i=1;i<=n;i++)l[i]=l[i-1]+(1<<l[i-1]==i);for(int j=1;j<=lmt;j++)for(int i=1;i<=n;i++)f[i][j]=f[f[i][j-1]][j-1];
}
inline int lca(int x,int y)
{if(x==y)return x;if(d[x]<d[y])x^=y^=x^=y;for(int i=lmt;i>=0;i--)if(d[f[x][i]]>=d[y])x=f[x][i];if(x==y)return x;for(int i=lmt;i>=0;i--)if(f[x][i]!=f[y][i])x=f[x][i],y=f[y][i];return f[x][0];
}
Tarjan
你学会了倍增求 LCA，然后有一天遇到了这道模板题：【模板】最近公共祖先（LCA）。你交了你最爱的倍增算法，但是发现 T 了若干个点。所以你去学习了（也许）更快的 Tarjan 求 LCA。
Tarjan 求 LCA 是一种离线算法。我们先存下来所有的询问（记得特判 \(x=y\)）。然后我们对树进行一次 dfs。当一个点到达过但是未回溯时，给这个点打上标记 \(1\)，回溯之后打上标记 \(2\)，并且在并查集上将其与它的直接父亲连起来。如果我们当前在 \(y\) 点，需要查询的 \(x\) 点已经被标记为 \(2\)，我们在并查集上查询 \(x\) 的祖先，就是 \(x,y\) 的 LCA。
如图，如果我们当前在 \(5\) 号点，需要查询的是 \(4\) 号点和它的 LCA，这个时候查询到 \(4\) 号点的祖先是 \(2\)，\(2\) 号点就是它们的 LCA。反正就是这么求的，证明略。感性理解一下qwq
时间复杂度大概为 \(O(n+q)\)，非常的够用。
代码：
struct query{int y,id,nxt;
}q[N*2];
int lq[N],leq=0;//存询问
inline void insertq(int x,int y,int i)
{q[++leq]={y,i,lq[x]};lq[x]=leq;
}
int vis[N],f[N];
int getf(int x)
{if(f[x]==x)return x;return f[x]=getf(f[x]);
}
int ans[N];
void tarjan(int x,int fa)
{vis[x]=1;for(int i=lk[x];i;i=e[i].nxt)if(e[i].y!=fa)tarjan(e[i].y,x);for(int i=lq[x];i;i=q[i].nxt)//遍历询问if(vis[q[i].y]==2||x==q[i].y)ans[q[i].id]=getf(q[i].y);vis[x]=2;f[x]=fa;//标记 2 并连上父亲
}
然后你通过了此题觉得万事大吉，以后再也不用倍增 LCA 了。
转化为 RMQ 问题
由于前一天问了人很好的 dalao 一道题，他对你说 kruskal 重构树，然而你并不知道那是什么，所以你刻苦学习，然后遇到了这道题：最小瓶颈路（加强版）。
注意到此题的 \(q\) 达到了惊人的 \(10^7\)，感觉内存不是很妙。然后你找到了一种通过欧拉序把求 LCA 转化为 RMQ 问题的神奇做法。
欧拉序即在 dfs 时到达一个点和从儿子返回这个点时都将此点加入生成的序列。我们令 \(pos_x\) 表示 \(x\) 第一次在欧拉序中出现的位置， \(eun_i\) 表示欧拉序的第 \(i\) 位的点，\(d_x\) 依然表示 \(x\) 的深度。显然 \(x,y\) 的 LCA 是欧拉序上从 \(pos_x\) 走到 \(pos_y\) 经过的所有点中深度最小的，也是欧拉序最小的。然后就很自然地转化为了 RMQ 问题，使用 st 表即可 \(O(1)\) 单次查询。
代码：
int d[N*2],eun[N*4],pos[N*2],now=0;
bool vis[N*2];
void dfs(int x)
{vis[x]=true;eun[++now]=x;pos[x]=now;for(int i=lk[x],y;i;i=nxt[i]){d[y=to[i]]=d[x]+1;dfs(y);eun[++now]=x;}
}
int lg[N*4];
int st[30][N*4],rev[30][N*4];
void init()
{for(int i=2;i<=cnt*2;i++)lg[i]=lg[i>>1]+1;//欧拉序的长度为 2*cnt-1for(int i=1;i<=cnt;i++)//点数为 cnt{if(!vis[getf(i)])d[fa[i]]=1,dfs(fa[i]);}for(int i=1;i<=now;i++)st[0][i]=d[eun[i]],rev[0][i]=eun[i];int lmt=lg[now];for(int j=1;j<=lmt;j++)for(int i=1;i+(1<<j)<=now+1;i++)if(st[j-1][i]<st[j-1][i+(1<<(j-1))])st[j][i]=st[j-1][i],rev[j][i]=rev[j-1][i];elsest[j][i]=st[j-1][i+(1<<(j-1))],rev[j][i]=rev[j-1][i+(1<<(j-1))];
}
inline int lca(int x,int y)
{if(x==y)return 0;x=pos[x];y=pos[y];if(x>y)swap(x,y);int k=lg[y-x+1];return st[k][x]<st[k][y-(1<<k)+1]?rev[k][x]:rev[k][y-(1<<k)+1];
}
树链剖分也可以，但是懒得用，这里已经有非常好的 \(O(1)\) LCA 了（逃走）。
