LCA算法解析-Tarjan&倍增&RMQ

時間 2019-12-05

標籤 lca 算法解析 tarjan 倍增 rmq 简体版

原文原文鏈接

原文連接http://www.cnblogs.com/zhouzhendong/p/7256007.html php

UPD(2018-5-13) : 細節修改以及使用了Latex代碼，公式更加美觀。改的過程當中發現許多敘述上的問題，已經修改。然而獲得這麼多閱讀量我真的是受寵若驚。因而我決定再補寫一個在線$O(1)$查詢的$RMQ$算法。html

問題模型

　　對於一棵樹，求兩個節點的最近公共祖先（LCA）。

　　以下圖：（如下數字表明對應編號的節點）c++

　　$1$ 和 $6$ 的 LCA 是 $8$ 。算法

　　$11$ 和 $1$ 的 LCA 是 $8$ 。數組

　　$11$ 和 $15$ 的 LCA 是 $4$ 。
學習

　　$14$ 和 $13$ 的 LCA 是 $1 $ 。spa

LCA_Tarjan

　　$Tarjan$ 算法求 LCA 的時間複雜度爲 $O(n+q)$ ，是一種離線算法，要用到並查集。（注：這裏的複雜度其實應該不是 $O(n+q)$ ，還須要考慮並查集操做的複雜度，可是因爲在多數狀況下，路徑壓縮並查集的單次操做複雜度能夠看作 $O(1)$，因此寫成了 $O(n+q)$ 。）.net

　　$Tarjan$ 算法基於 dfs ，在 dfs 的過程當中，對於每一個節點位置的詢問作出相應的回答。code

　　dfs 的過程當中，當一棵子樹被搜索完成以後，就把他和他的父親合併成同一集合；在搜索當前子樹節點的詢問時，若是該詢問的另外一個節點已經被訪問過，那麼該編號的詢問是被標記了的，因而直接輸出當前狀態下，另外一個節點所在的並查集的祖先；若是另外一個節點尚未被訪問過，那麼就作下標記，繼續 dfs 。htm

　　固然，暫時還沒那麼容易弄懂，因此建議結合下面的例子和標算來看看。

（下面的集合合併都用並查集實現）

　　好比：$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 不必寫樹鏈剖分，因此這裏不展開介紹。若是您感興趣，那百度一下，你就知道。