算法学习笔记【1】| LCA（最近公共祖先）

LCA(最近公共祖先)

Part 1:逐步上跳

假设u，v是所求的两点，先把深度大的点逐步上移直到深度相同。 然后两者同时上移，直到第一次遇到相同的点为止。

时间复杂度： O(n)<script type="math/tex;mode=inline" id="MathJax-Element-1">O(n)</script>O(n)

Part 2:倍增

考虑优化跳的过程。

定义anc[k][i]，表示i向上第 2k<script type="math/tex;mode=inline" id="MathJax-Element-2">2^k </script>2^k 个祖先。
anc可以按照k为阶段动态规划得出，初始化为：anc[0][i]=fa[i];。

//Author: Velvet on Luogu(uid=443675)
void init(){
    F(k,1,18){
        F(i,1,n){
            anc[k][i]=anc[k-1][anc[k-1][i]];
        }
    }
}
//Author: Velvet on Luogu(uid=443675)
int LCA(int u,int v){
    if(dep[u]<dep[v]) swap(u,v);
    dF(i,18,0){
        if(dep[anc[i][u]]>=dep[v]){
            u=anc[i][u];
        }
    }
    if(u==v) return u;
    dF(i,18,0){
        if(anc[i][u]!=anc[i][v]){
            u=anc[i][u];v=anc[i][v];
        }
    }
    return anc[0][u];
}

if(u==v) return u;，这句话很重要，没有的话会导致答案变成LCA的祖先。

至于anc可能超出树的大小的问题，可以这样理解：
如果anc[i][u]超出树的范围，dep[anc[i][u]]=0，必然不会赋值给u。
下面也是一样，anc都是0，不会赋值，保证答案的合法。

Part 3:Tarjan(离线算法)

Tarjan 是基于并查集的。

倍增法优化了向上跳这一步骤，Tarjan 算法则在第一次遍历整棵树的时候得到所有答案，因此需要先存储下每个询问，故该算法为离线算法。

假设 x,y 的LCA为 u。那么x，y必须是u的不同子树中的节点。
我们把每一次操作完后的子树和其父亲节点合并，这里使用并查集。
然后对于任意一个其他子树中的被提问节点，判断其询问的另一个节点有无访问记录，若是，记录答案为其并查集树根。

//Author: Velvet on Luogu(uid=443675)
void dfs(int now){
    fa[now]=now;//并查集初始化
    vis[now]=1;//访问记录
    for(auto i:G[now]){
        if(vis[i]) continue;
        dfs(i);
        fa[i]=now;//合并
    }
    for(auto i:Q[now]){//询问列表（i.first是另一个询问，i.second是询问的顺序
        if(!vis[i.first]) continue;
        ans[i.second]=find(i.first);
    }
}

Part 4:树剖

先重链剖分这棵树。每次求LCA就不断跳重链，直到u，v在同一条重链上，答案就是u，v中深度小的。
向上跳重链时需要先跳所在重链顶端深度较大的那个。

//Author: Velvet on Luogu(uid=443675)
const int N=500005,M=(N<<1),inf=0x3f3f3f3f;
int n,m,s,siz[N],fa[N],hson[N],top[N],dep[N];
vector<int> G[N];
void dfs1(int now,int father){
    siz[now] = 1;
    for(auto i:G[now]){
        if(i == father) continue;
        dep[i] = dep[now] + 1;
        dfs1(i,now);
        siz[now] += siz[i];
        fa[i] = now;
        if(siz[hson[now]]<siz[i])
            hson[now] = i;
    }
}
void dfs2(int now,int t){
    top[now] = t;
    if(hson[now])
        dfs2(hson[now],t);
    for(auto i:G[now]){
        if(i == hson[now]||i == fa[now]) continue;
        dfs2(i,i);
    }
}
int LCA(int u,int v){
    while(top[u] != top[v]){
        if(dep[top[u]]<dep[top[v]]) v=fa[top[v]];
        else u = fa[top[u]];
    }
    return dep[u] > dep[v] ? v : u;
}
int main(){
    ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    cin>>n>>m>>s;
    F(i,1,n-1){
        int u,v;
        cin>>u>>v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    dep[s] = 1;
    dfs1(s,-1);
    dfs2(s,s);
    F(i,1,m){
        int u,v;
        cin>>u>>v;
        cout<<LCA(u,v)<<endl;
    }
    return 0;
}

模板题（on Luogu）：SP14932，P3379