原文鏈接http://www.cnblogs.com/zhouzhendong/p/7256007.html
UPD(2018-5-13) : 細節修改以及使用了Markdown代碼，公式更加美觀。改的過程中發現許多敘述上的問題，已經修改。然而得到這么多閱讀量我真的是受寵若驚。於是我決定再補寫一個在線$O(1)$查詢的$RMQ$算法。
問題模型
對於一棵樹，求兩個節點的最近公共祖先（LCA）。
如下圖：（以下數字代表對應編號的節點）
$1$ 和 $6$ 的 LCA 是 $8$ 。
$11$ 和 $1$ 的 LCA 是 $8$ 。
$11$ 和 $15$ 的 LCA 是 $4$ 。
$14$ 和 $13$ 的 LCA 是 $1 $ 。
LCA_Tarjan
$Tarjan$ 算法求 LCA 的時間復雜度為 $O(n+q)$ ，是一種離線算法，要用到並查集。（注：這里的復雜度其實應該不是 $O(n+q)$ ，還需要考慮並查集操作的復雜度 ，但是由於在多數情況下，路徑壓縮並查集的單次操作復雜度可以看做 $O(1)$，所以寫成了 $O(n+q)$ 。）
$Tarjan$ 算法基於 dfs ，在 dfs 的過程中，對於每個節點位置的詢問做出相應的回答。
dfs 的過程中，當一棵子樹被搜索完成之后，就把他和他的父親合並成同一集合；在搜索當前子樹節點的詢問時，如果該詢問的另一個節點已經被訪問過，那么該編號的詢問是被標記了的，於是直接輸出當前狀態下，另一個節點所在的並查集的祖先；如果另一個節點還沒有被訪問過，那么就做下標記，繼續 dfs 。
當然，暫時還沒那么容易弄懂，所以建議結合下面的例子和標算來看看。
（下面的集合合並都用並查集實現）
比如：$8-1-14-13$ ,此時已經完成了對子樹 $1$ 的子樹 $14$ 的 $dfs$ 與合並（ $14$ 子樹的集合與 $1$ 所代表的集合合並），如果存在詢問 $(13,14)$ ，則其 LCA 即 $getfather(14)$ ，即 $1$ ；如果還存在由節點 $13$ 與 已經完成搜索的子樹中的 節點的詢問，那么處理完。然后合並子樹 $13$ 的集合與其父親 $1$ 當前的集合，回溯到子樹 $1$ ，並深搜完所有 $1$ 的其他未被搜索過的兒子，並完成子樹 $1$ 中所有節點的合並，再往上回溯，對節點 $1$ 進行類似的操作即可。
#include <cstring> #include <cstdio> #include <algorithm> #include <cstdlib> #include <cmath> using namespace std; const int N=40000+5; struct Edge{ int cnt,x[N],y[N],z[N],nxt[N],fst[N]; void set(){ cnt=0; memset(x,0,sizeof x); memset(y,0,sizeof y); memset(z,0,sizeof z); memset(nxt,0,sizeof nxt); memset(fst,0,sizeof fst); } void add(int a,int b,int c){ x[++cnt]=a; y[cnt]=b; z[cnt]=c; nxt[cnt]=fst[a]; fst[a]=cnt; } }e,q; int T,n,m,from,to,dist,in[N],rt,dis[N],fa[N],ans[N]; bool vis[N]; void dfs(int rt){ for (int i=e.fst[rt];i;i=e.nxt[i]){ dis[e.y[i]]=dis[rt]+e.z[i]; dfs(e.y[i]); } } int getf(int k){ return fa[k]==k?k:fa[k]=getf(fa[k]); } void LCA(int rt){ for (int i=e.fst[rt];i;i=e.nxt[i]){ LCA(e.y[i]); fa[getf(e.y[i])]=rt; } vis[rt]=1; for (int i=q.fst[rt];i;i=q.nxt[i]) if (vis[q.y[i]]&&!ans[q.z[i]]) ans[q.z[i]]=dis[q.y[i]]+dis[rt]-2*dis[getf(q.y[i])]; } int main(){ scanf("%d",&T); while (T--){ q.set(),e.set(); memset(in,0,sizeof in); memset(vis,0,sizeof vis); memset(ans,0,sizeof ans); scanf("%d%d",&n,&m); for (int i=1;i<n;i++) scanf("%d%d%d",&from,&to,&dist),e.add(from,to,dist),in[to]++; for (int i=1;i<=m;i++) scanf("%d%d",&from,&to),q.add(from,to,i),q.add(to,from,i); rt=0; for (int i=1;i<=n&&rt==0;i++) if (in[i]==0) rt=i; dis[rt]=0; dfs(rt); for (int i=1;i<=n;i++) fa[i]=i; LCA(rt); for (int i=1;i<=m;i++) printf("%d\n",ans[i]); } return 0; }
倍增
我們可以用倍增來在線求 LCA ，時間和空間復雜度分別是 $O((n+q)\log n)$ 和 $O(n \log n)$ 。
對於這個算法，我們從最暴力的算法開始：
①如果 $a$ 和 $b$ 深度不同，先把深度調淺，使他變得和淺的那個一樣
②現在已經保證了 $a$ 和 $b$ 的深度一樣，所以我們只要把兩個一起一步一步往上移動，直到他們到達同一個節點，也就是他們的最近公共祖先了。
#include <cstring> #include <cstdio> #include <cstdlib> #include <algorithm> #include <cmath> #include <vector> using namespace std; const int N=10000+5; vector <int> son[N]; int T,n,depth[N],fa[N],in[N],a,b; void dfs(int prev,int rt){ depth[rt]=depth[prev]+1; fa[rt]=prev; for (int i=0;i<son[rt].size();i++) dfs(rt,son[rt][i]); } int LCA(int a,int b){ if (depth[a]>depth[b]) swap(a,b); while (depth[b]>depth[a]) b=fa[b]; while (a!=b) a=fa[a],b=fa[b]; return a; } int main(){ scanf("%d",&T); while (T--){ scanf("%d",&n); for (int i=1;i<=n;i++) son[i].clear(); memset(in,0,sizeof in); for (int i=1;i<n;i++){ scanf("%d%d",&a,&b); son[a].push_back(b); in[b]++; } depth[0]=-1; int rt=0; for (int i=1;i<=n&&rt==0;i++) if (in[i]==0) rt=i; dfs(0,rt); scanf("%d%d",&a,&b); printf("%d\n",LCA(a,b)); } return 0; }
而實際上，一步一步往上移動太慢，我們可以做一個預處理：
$fa_{i,j}$ 表示節點 $i$ 往上走 $2^j$ 次所到達的祖先，那么不難寫出轉移式：
$fa_{i,0}=father_i,fa_{i,j}=fa_{fa_{i,j-1},j-1}$
然后在求 LCA 的時候，有這樣一個性質：（假設 $a$ 和 $b$ 深度一樣）
設 $anst_{x,y}$ 為節點 $x$ 向上走 $y$ 步到達的祖先，對於一個 $k$ ，如果 $anst_{a,k}=anst_{b,k}$ ,那么對於所有 $k^\prime(k^\prime>k)$ ，一定有 $anst_{a,k^\prime}=anst_{b,k^\prime}$ ；對於一個 $k$ ，如果 $anst_{a,k}\neq anst_{b,k}$ ,那么對於所有 $k^\prime(k^\prime<k)$ ，一定有 $anst_{a,k^\prime}\neq anst_{b,k^\prime}$ ,而且 $LCA(a,b)=LCA(anst_{a,k},anst_{b,k})$ 。
於是我們可以得出以下做法：
(UPD(2018-08-31): 這部分敘述修改了)
1. 把 $a$ 和 $b$ 移到同一深度（設 $depth_x$ 為節點 $x$ 的深度），假設 $depth_a\leq depth_b$ ，這個時候，之前預處理的 $fa$ 數組就派上用場了。從大到小枚舉 $k$ ，如果 $b$ 向上跳 $2^k$ 得到的節點的深度 $\geq depth_a$ ，那么 $b$ 就往上跳。
2.如果 $a=b$ ，那么顯然 LCA 就是 $a$。否則執行第 3 步。
3.這一步的主要目的是 ：分別找到最淺的 $a^\prime$ 和 $b^\prime$ ，並且 $a^\prime \neq b^\prime $ 。
利用之前的那個性質，再利用倍增，從大到小枚舉 $k$ ，如果對於當前的 $k$ ， $a$ 和 $b$ 的第 $2^k$ 個祖先不同，那么 $a$ 和 $b$ 都跳到其 $2^k$ 祖先的位置。LCA 就是 $fa_{a^\prime,0}$ 或者 $fa_{b^\prime,0}$ 。
UPD(2018-07-12): LCA 倍增關鍵部分模板更新
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
const int N=10000+5;
vector <int> son[N];
int T,n,depth[N],fa[N][20],in[N],a,b;
void dfs(int prev,int rt){
depth[rt]=depth[prev]+1;
fa[rt][0]=prev;
for (int i=1;i<20;i++)
fa[rt][i]=fa[fa[rt][i-1]][i-1];
for (int i=0;i<son[rt].size();i++)
dfs(rt,son[rt][i]);
}
int LCA(int x,int y){
if (depth[x]<depth[y])
swap(x,y);
for (int i=19;i>=0;i--)
if (depth[x]-(1<<i)>=depth[y])
x=fa[x][i];
if (x==y)
return x;
for (int i=19;i>=0;i--)
if (fa[x][i]!=fa[y][i])
x=fa[x][i],y=fa[y][i];
return fa[x][0];
}
int main(){
scanf("%d",&T);
while (T--){
scanf("%d",&n);
for (int i=1;i<=n;i++)
son[i].clear();
memset(in,0,sizeof in);
for (int i=1;i<n;i++){
scanf("%d%d",&a,&b);
son[a].push_back(b);
in[b]++;
}
depth[0]=-1;
int rt=0;
for (int i=1;i<=n&&rt==0;i++)
if (in[i]==0)
rt=i;
dfs(0,rt);
scanf("%d%d",&a,&b);
printf("%d\n",LCA(a,b));
}
return 0;
}
RMQ
現在來介紹一種 $O(n\log n)$ 預處理，$O(1)$ 在線查詢的算法。
RMQ 的意思大概是“區間最值查詢”。顧名思義，用 RMQ 來求 LCA 是通過 RMQ 來實現的。
首先，您可以了解一下 dfs 序。鏈接：http://www.cnblogs.com/zhouzhendong/p/7264132.html
在 dfs 的過程中，退出一個子樹之后就不會再進入了。這是個很好的性質。
所以很顯然，一個子樹中深度最淺的節點必定是該子樹的樹根。
顯然，兩個節點的 LCA 不僅是兩個節點的最近公共祖先，而且是囊括這兩個節點的最小子樹的根，即囊括這兩個節點的最小子樹中的深度最小的節點。
我們來想一想如何得到這個節點。
現在，我們稍微修改一下 dfs 序，搞一個歐拉序。
歐拉序，就是每次從 $father(x)$ 進入節點 $x$ 或者從子節點回溯到 $x$ 都要把 $x$ 這個編號扔到一個數組的最后。
這樣最終會得到一個長度約為 $2n$ 的數列。（考慮每一個節點貢獻為 $2$ ，分別是從其父親進入該節點，和從該節點回到其父親）
例如，上圖這棵樹的一個歐拉序為 $8,5,9,5,8,4,6,15,6,7,6,4,10,11,10,16,3,16,12,16,10,2,10,4,8,1,14,1,13,1,8$ 。
建議跟着我給出的歐拉序走一遍，再次理解歐拉序的含義。
再注意到，一對點的 LCA 不僅是囊括這兩個節點的最小子樹中的深度最小的節點，還是連接這對點的簡單路徑上深度最小的點。
而且從離開 $a$ 到進入 $b$ 的這段歐拉序必然包括所有這對點之間的簡單路徑上的所有點，所以我們考慮求得這段歐拉序中所包含的節點中的 深度最小的點即其 LCA 。
從 $a$ 到 $b$ 的這段歐拉序會包含這棵子樹中的其他節點，但是不會影響這個最淺點的求得，因為“一對點的 LCA 是囊括這兩個節點的最小子樹中的深度最小的節點”。
顯然， $a$ 到 $b$ 這段歐拉序是個連續區間。
你可以用線段樹維護，但是線段樹太 low 了。
現在我們考慮通過預處理來 $O(1)$ 獲得這個最淺點。
於是我們要學習一個叫做 ST表 的東西來搞定這個。（和之前倍增中處理的 $fa$ 數組差不多）
我再放一篇大佬博客來介紹 RMQ 與 ST表 ： https://blog.csdn.net/qq_31759205/article/details/75008659
接下來當然是輕松愉快的放代碼時間啦。
//CodeVS2370
#include <bits/stdc++.h>
#define time _____time
using namespace std;
const int N=50005;
struct Gragh{
int cnt,y[N*2],z[N*2],nxt[N*2],fst[N];
void clear(){
cnt=0;
memset(fst,0,sizeof fst);
}
void add(int a,int b,int c){
y[++cnt]=b,z[cnt]=c,nxt[cnt]=fst[a],fst[a]=cnt;
}
}g;
int n,m,depth[N],in[N],out[N],time;
int ST[N*2][20];
void dfs(int x,int pre){
in[x]=++time;
ST[time][0]=x;
for (int i=g.fst[x];i;i=g.nxt[i])
if (g.y[i]!=pre){
depth[g.y[i]]=depth[x]+g.z[i];
dfs(g.y[i],x);
ST[++time][0]=x;
}
out[x]=time;
}
void Get_ST(int n){
for (int i=1;i<=n;i++)
for (int j=1;j<20;j++){
ST[i][j]=ST[i][j-1];
int v=i-(1<<(j-1));
if (v>0&&depth[ST[v][j-1]]<depth[ST[i][j]])
ST[i][j]=ST[v][j-1];
}
}
int RMQ(int L,int R){
int val=floor(log(R-L+1)/log(2));
int x=ST[L+(1<<val)-1][val],y=ST[R][val];
if (depth[x]<depth[y])
return x;
else
return y;
}
int main(){
scanf("%d",&n);
for (int i=1,a,b,c;i<n;i++){
scanf("%d%d%d",&a,&b,&c);
a++,b++;
g.add(a,b,c);
g.add(b,a,c);
}
time=0;
dfs(1,0);
depth[0]=1000000;
Get_ST(time);
scanf("%d",&m);
while (m--){
int x,y;
scanf("%d%d",&x,&y);
if (in[x+1]>in[y+1])
swap(x,y);
int LCA=RMQ(in[x+1],in[y+1]);
printf("%d\n",depth[x+1]+depth[y+1]-depth[LCA]*2);
}
return 0;
}
聽說有人認為應該加個重鏈剖分做法？？？？
我認為單純求 LCA 沒必要寫樹鏈剖分，所以這里不展開介紹。如果您感興趣，那百度一下，你就知道。