概念
首先是最近公共祖先的概念(什么是最近公共祖先？)：
在一棵沒有環的樹上，每個節點肯定有其父親節點和祖先節點，而最近公共祖先，就是兩個節點在這棵樹上深度最大的公共的祖先節點。
換句話說，就是兩個點在這棵樹上距離最近的公共祖先節點。
所以LCA主要是用來處理當兩個點僅有唯一一條確定的最短路徑時的路徑。
有人可能會問：那他本身或者其父親節點是否可以作為祖先節點呢？
答案是肯定的，很簡單，按照人的親戚觀念來說，你的父親也是你的祖先，而LCA還可以將自己視為祖先節點。
舉個例子吧，如下圖所示4和5的最近公共祖先是2，5和3的最近公共祖先是1，2和1的最近公共祖先是1。
這就是最近公共祖先的基本概念了，那么我們該如何去求這個最近公共祖先呢？
通常初學者都會想到最簡單粗暴的一個辦法：對於每個詢問，遍歷所有的點，時間復雜度為\(O(n*q)\) ，很明顯，\(n\)和\(q\)一般不會很小。
怎么辦辦？
LCA其實有很多種解法，這里介紹幾個
一、Tarjan大法好！
什么是\(Tarjan\)(離線)算法呢？顧名思義，就是在一次遍歷中把所有詢問一次性解決，所以其時間復雜度是\(O(n+q)\)。
\(Tarjan\)算法的優點在於相對穩定，時間復雜度也比較居中，也很容易理解。
下面詳細介紹一下\(Tarjan\)算法的基本思路：
-
任選一個點為根節點，從根節點開始。
-
遍歷該點\(u\)所有子節點\(v\)，並標記這些子節點\(v\)已被訪問過。
-
若是\(v\)還有子節點，返回\(2\)，否則下一步。
-
合並\(v\)到\(u\)上。
-
尋找與當前點\(u\)有詢問關系的點\(v\)。
-
若是\(v\)已經被訪問過了，則可以確認\(u\)和\(v\)的最近公共祖先為\(v\)被合並到的父親節點\(a\)。
遍歷的話需要用到\(dfs\)來遍歷(相信來看的人都懂吧...)，至於合並，最優化的方式就是利用並查集來合並兩個節點。
- 偽代碼
Tarjan(u)//marge和find為並查集合並函數和查找函數
{
for each(u,v) //訪問所有u子節點v
{
Tarjan(v); //繼續往下遍歷
marge(u,v); //合並v到u上
標記v被訪問過;
}
for each(u,e) //訪問所有和u有詢問關系的e
{
如果e被訪問過;
u,e的最近公共祖先為find(e);
}
}
個人感覺這樣還是有很多人不太理解，所以打算模擬一遍給大家看。
假設我們有一組數據 9個節點 8條邊 聯通情況如下：
1--2，1--3，2--4，2--5，3--6，5--7，5--8，7--9 即下圖所示的樹
設我們要查找最近公共祖先的點為9--8，4--6，7--5，5--3；
設f[]數組為並查集的父親節點數組，初始化f[i]=i，vis[]數組為是否訪問過的數組，初始為0;
下面開始模擬過程：
取1為根節點，往下搜索發現有兩個兒子2和3；
先搜2，發現2有兩個兒子4和5，先搜索4，發現4沒有子節點，則尋找與其有關系的點；
發現6與4有關系，但是vis[6]=0，即6還沒被搜過，所以不操作；
發現沒有和4有詢問關系的點了，返回此前一次搜索，更新vis[4]=1；
表示4已經被搜完，更新f[4]=2，繼續搜5，發現5有兩個兒子7和8;
先搜7，發現7有一個子節點9，搜索9，發現沒有子節點，尋找與其有關系的點；
發現8和9有關系，但是vis[8]=0,即8沒被搜到過，所以不操作；
發現沒有和9有詢問關系的點了，返回此前一次搜索，更新vis[9]=1；
表示9已經被搜完，更新f[9]=7，發現7沒有沒被搜過的子節點了，尋找與其有關系的點；
發現5和7有關系，但是vis[5]=0，所以不操作；
發現沒有和7有關系的點了，返回此前一次搜索，更新vis[7]=1；
表示7已經被搜完，更新f[7]=5，繼續搜8，發現8沒有子節點，則尋找與其有關系的點；
發現9與8有關系，此時vis[9]=1，則他們的最近公共祖先為find(9)=5；
(find(9)的順序為f[9]=7-->f[7]=5-->f[5]=5 return 5;)
發現沒有與8有關系的點了，返回此前一次搜索，更新vis[8]=1；
表示8已經被搜完，更新f[8]=5，發現5沒有沒搜過的子節點了，尋找與其有關系的點；
發現7和5有關系，此時vis[7]=1，所以他們的最近公共祖先為find(7)=5；
(find(7)的順序為f[7]=5-->f[5]=5 return 5;)
又發現5和3有關系，但是vis[3]=0，所以不操作，此時5的子節點全部搜完了；
返回此前一次搜索，更新vis[5]=1，表示5已經被搜完，更新f[5]=2；
發現2沒有未被搜完的子節點，尋找與其有關系的點；
又發現沒有和2有關系的點，則此前一次搜索，更新vis[2]=1；
表示2已經被搜完，更新f[2]=1，繼續搜3，發現3有一個子節點6；
搜索6，發現6沒有子節點，則尋找與6有關系的點，發現4和6有關系；
此時vis[4]=1，所以它們的最近公共祖先為find(4)=1;
(find(4)的順序為f[4]=2-->f[2]=2-->f[1]=1 return 1;)
發現沒有與6有關系的點了，返回此前一次搜索，更新vis[6]=1，表示6已經被搜完了；
更新f[6]=3，發現3沒有沒被搜過的子節點了，則尋找與3有關系的點；
發現5和3有關系，此時vis[5]=1，則它們的最近公共祖先為find(5)=1；
(find(5)的順序為f[5]=2-->f[2]=1-->f[1]=1 return 1;)
發現沒有和3有關系的點了，返回此前一次搜索，更新vis[3]=；
更新f[3]=1，發現1沒有被搜過的子節點也沒有有關系的點，此時可以退出整個dfs了。
經過這次dfs我們得出了所有的答案，有沒有覺得很神奇呢？是否對Tarjan算法有更深層次的理解了呢？
二、倍增LCA
何為倍增？
所謂倍增，就是按\(2\)的倍數來增大，也就是跳 \(1,2,4,8,16,32……\) 不過在這我們不是按從小到大跳，而是從大向小跳，即按\(……32,16,8,4,2,1\)來跳，如果大的跳不過去，再把它調小。這是因為從小開始跳，可能會出現“悔棋”的現象。拿 55 為例，從小向大跳，\(5≠1+2+4\),所以我們還要回溯一步，然后才能得出\(5=1+4\)；而從大向小跳，直接可以得出\(5=4+1\)。這也可以拿二進制為例，\(5(101)\)，從高位向低位填很簡單，如果填了這位之后比原數大了，那我就不填，這個過程是很好操作的。
這里以編號為17和18結點為例
\(17->3\)
\(18->5->3\)
可以看出向上跳的次數大大減小。這個算法的時間復雜度為\(O(nlogn)\),已經可以滿足大部分的需求。
想要實現這個算法，首先我們要記錄各個點的深度和他們\(2^i\)級的的祖先，用數組\(\rm{deep}\)表示每個節點的深度，\(fa[i][j]\)表示節點\(i\)的\(2^j\)級祖先。 代碼如下：
inline void getdeep(int now,int father)//now表示當前節點，father表示它的父親節點
{
deep[now]=deep[father]+1;
fa[now][0]=father;
for(int i=1;(1<<i)<=deep[now];i++)
fa[now][i]=fa[fa[now][i-1]][i-1];//這個轉移可以說是算法的核心之一
//意思是f的2^i祖先等於f的2^(i-1)祖先的2^(i-1)祖先
//2^i=2^(i-1)+2^(i-1)
for(int i=head[now];i;i=edge[i].next)//注意：盡量用鏈式前向星來存邊，速度會大大提升
{
if(edge[i].to==father)continue;
getdeep(edge[i].to,now);
}
}
然后我們要算出log2n
log2n=log(n)/log(2)+0.5;
接下來就是倍增LCA了，我們先把兩個點提到同一高度，再統一開始跳。
但我們在跳的時候不能直接跳到它們的LCA，因為這可能會誤判，比如\(4\)和\(8\)，在跳的時候，我們可能會認為\(1\)是它們的LCA，但\(1\)只是它們的祖先，它們的LCA其實是\(3\)。所以我們要跳到它們LCA的下面一層，比如\(4\)和\(8\)，我們就跳到\(4\)和\(5\)，然后輸出它們的父節點，這樣就不會誤判了。
inline int lca(int u,int v)
{
int deepu=deep[u],deepv=deep[v];
if(deepu!=deepv)//先跳到同一深度
{
if(deep[u]<deep[v])
{
swap(u,v);
swap(deepu,deepv);
}
int d=deepu-deepv;
for(int i=0;i<=log2n;i++)
if((1<<i)&d)u=fa[u][i];
}
if(u==v)return u;
for(int i=log2n;i>=0;i--)
{
if(deep[fa[u][i]]<=0)continue;
if(fa[u][i]==fa[v][i])continue;
else u=fa[u][i],v=fa[v][i];//因為我們要跳到它們LCA的下面一層，所以它們肯定不相等，如果不相等就跳過去。
}
return fa[u][0];
}
完整的求17和18的LCA的路徑：
\(17->10->7->3\)
\(18->16->8->5->3\)
解釋：首先，\(18\)要跳到和\(17\)深度相同，然后\(18\)和\(17\)一起向上跳，一直跳到LCA的下一層(\(17\)是\(7\)，\(18\)是\(5\))，此時LCA就是它們的父親
總體來說就是這樣了;