最近公共祖先(LCA)模板

以下转自：https://www.cnblogs.com/JVxie/p/4854719.html

首先是最近公共祖先的概念(什么是最近公共祖先？)：

在一棵没有环的树上，每个节点肯定有其父亲节点和祖先节点，而最近公共祖先，就是两个节点在这棵树上深度最大的公共的祖先节点。

换句话说，就是两个点在这棵树上距离最近的公共祖先节点。

所以LCA主要是用来处理当两个点仅有唯一一条确定的最短路径时的路径。

有人可能会问：那他本身或者其父亲节点是否可以作为祖先节点呢？

答案是肯定的，很简单，按照人的亲戚观念来说，你的父亲也是你的祖先，而LCA还可以将自己视为祖先节点。

举个例子吧，如下图所示４和５的最近公共祖先是２，５和３的最近公共祖先是１，２和１的最近公共祖先是１。　

这就是最近公共祖先的基本概念了，那么我们该如何去求这个最近公共祖先呢？

通常初学者都会想到最简单粗暴的一个办法：对于每个询问，遍历所有的点，时间复杂度为O(n*q)，很明显，n和q一般不会很小。

常用的求LCA的算法有：Tarjan（离线）、倍增法（在线）

下面贴两种写法的代码，以HDU 2586 How far away ？为例：

题目大意：

给你一棵树n个节点，m次询问，每次询问树上节点u和v的最小距离。

Tarjan(时间复杂度O(n+Qlogn))

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int N=4e4+5;

struct node{
    int to,w;
    node(int to,int w):to(to),w(w){}
};

struct qnode{
    int to,id;
    qnode(int to,int id):to(to),id(id){}
};

vector<node>v[N];
vector<qnode>q[N];
bool vis[N];                //vis[i]表示点i是否被访问过
int res[N],root[N],dis[N];  //res记录答案

int find(int x){
    return root[x]==x?x:root[x]=find(root[x]);
}

void lca(int u){
    vis[u]=true;
    for(int i=0;i<v[u].size();i++){
        node t=v[u][i];
        if(!vis[t.to]){
            dis[t.to]=dis[u]+t.w;
            lca(t.to);
            root[t.to]=u;
        }
    }
    for(int i=0;i<q[u].size();i++){
        qnode t=q[u][i];
        if(vis[t.to]){
            res[t.id]=dis[u]+dis[t.to]-2*dis[find(t.to)];
        }
    }
}

int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        int n,m;
        scanf("%d%d",&n,&m);
        memset(vis,false,sizeof(vis));
        memset(dis,0,sizeof(dis));
        for(int i=1;i<=n;i++){
            root[i]=i;
            v[i].clear();
        }
        for(int i=1;i<=m;i++){
            q[i].clear();
        }
        for(int i=1;i<=n-1;i++){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            v[a].push_back(node(b,c));
            v[b].push_back(node(a,c));
        }
        for(int i=1;i<=m;i++){
            int a,b;
            scanf("%d%d",&a,&b);
            q[a].push_back(qnode(b,i));
            q[b].push_back(qnode(a,i));
        }
        lca(1);
        for(int i=1;i<=m;i++){
            printf("%d
",res[i]);
        }
    }
    return 0;
}

倍增法（时间复杂度O（nlogn+Qlogn））

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int N=1e5+5;

struct node{
    int to,w;
    node(int to,int w):to(to),w(w){}
};
vector<node>v[N];

int n,m;
int depth[N],fa[N][31],dis[N];
bool vis[N];


void init(){
    memset(depth,0,sizeof(depth));
    memset(fa,0,sizeof(fa));
    memset(dis,0,sizeof(dis));
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;i++) v[i].clear();
}

void dfs(int u){
    vis[u]=true;
    for(int i=0;i<v[u].size();i++){
        node t=v[u][i];
        if(!vis[t.to]){
            depth[t.to]=depth[u]+1;
            fa[t.to][0]=u;
            dis[t.to]=dis[u]+t.w;
            dfs(t.to);
        }
    }
}

//倍增,处理fa数组
void bz(){
    for(int j=1;j<=30;j++){
        for(int i=1;i<=n;i++){
            fa[i][j]=fa[fa[i][j-1]][j-1];
        }
    }
}

int lca(int x,int y){
    //保证深度大的点为x
    if(depth[x]<depth[y])
        swap(x,y);
    int dc=depth[x]-depth[y];
    for(int i=0;i<30;i++){
        if(1<<i&dc)                 //一个判断，模拟下就会清楚
            x=fa[x][i];
    }
    if(x==y)    return x;           //如果深度一样，两个点相同，直接返回
    for(int i=29;i>=0;i--){
        if(fa[x][i]!=fa[y][i]){     //跳2^i不一样，就跳，否则不跳
            x=fa[x][i];
            y=fa[y][i];
        }
    }
    x=fa[x][0];
    return x;
}

int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        init();
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n-1;i++){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            v[a].push_back(node(b,c));
            v[b].push_back(node(a,c));
        }
        dfs(1);
        bz();
        for(int i=1;i<=m;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            printf("%d
",dis[x]+dis[y]-2*dis[lca(x,y)]);
        }
    }
    return 0;
}

 相关题目了解一下（转自这里）：

hdu 2586 How far away ？

模板题，直接求LCA，可以在线，离线算法均可解，可以测试一下模板

poj 1986 Distance Queries

模板题，直接求LCA

hdu 2874 Connections between cities

模板题，不过不是树是森林，所以某些点不存在LCA，要做判断

zoj 3195 Design the city

任然算是模板题，上面的题要求两点间的最短距离，这里要求3点间的最短距离，其实就是两两之间求一次LCA并计算出距离，然后相加除以2即可

hdu 3078 Network

LCA + 修改点权值 + 排序：每个点有初始的权值，一边查询一边伴随着修改某些点的权值，查询是从a到b路径中第k大的权值是多少。不需要太多的技巧，修改操作就直接修改，查询操作先求LCA，然后从a走到b保存下所有的权值，排序，然后直接输出即可

poj 2763 Housewife Wind

LCA + 修改边权：一边查询两点间的距离，一边修改某些边权。对于修改了某些边的边权，就要从此开始遍历下面的子孙后代更改他们的dir值（点到根的距离）。也不需要太多技巧，直接按题意实现即可，不过时间比较糟糕，用线段树或树状数组可以对修改操作进行优化，时间提升很多

poj 3694 Network

连通分量 + LCA ： 先缩点，再求LCA，并且不断更新，这题用了朴素方法来找LCA，并且在路径上做了一些操作

poj 3417 Network

LCA + Tree DP  :  在运行Tarjan处理完所有的LCA询问后，进行一次树DP，树DP不难，但是要想到用树DP并和这题结合还是有点难度

poj 3728 The merchant

LCA + 并查集的变形，优化：好题，难题，思维和代码实现都很有难度，需要很好地理解Tarjan算法中并查集的本质然后灵活变形，需要记录很多信息（有点dp的感觉）

hdu 3830 Checkers

LCA + 二分：好题，有一定思维难度。先建立出二叉树模型，然后将要查询的两个点调整到深度一致，然后二分LCA所在的深度，然后检验