LCA + 二分(倍增)

两个最近的点u和v的最近的公共的祖先称为最近公共祖先(LCA)。普通的LCA算法，每算一次LCA的时间复杂度为线性o(n);

这里讲LCA + 二分的方法。首先对于任意的节点v，利用其父节点的信息，可以通过par2[v]=par[par[v]]得到向上走两步的节点。依此信息可以通过par4[v]=par2[par2[v]]得到向上走4步的节点。所以，根据此方法可以得到向上走2^k所得到的节点par[k][v]。每次搜索的复杂度为o(log n)，预处理par[k][v]的复杂度为o(nlog n)。(我觉得挑战程序设计LCA部分写的挺明白的)

模版代码如下:

//LCA + 二分

vector <int> G[MAX_V]; //邻接表
int root; //根的编号

int par[MAX_LOG_V][MAX_V]; // 向上走2^k所到的父节点编号(根节点的父节点为-1)
int dep[MAX_V]; //节点的深度

void dfs(int v , int p , int d) { //3个参数分别表示 当前节点 父节点 深度
    par[v][0] = p;
    dep[v] = d;
    for(int i = 0 ; i < G[v].size() ; i++) {
        dfs(G[v][i] , v , d + 1);
    }
}
//预处理
void init(int n) {
    dfs(root , -1 , 0); //预处理出par[0]和dep
    for(int k = 0 ; k + 1 < MAX_LOG_V ; k++) {
        for(int v = 1 ; v <= n ; v++) {
            if(par[k][v] < 0) 
                par[k + 1][v] = -1; //v向上的2 ^ (k + 1)的节点超过根节点
            else
                par[k + 1][v] = par[k][par[k][v]]; //v向上的2^k的节点 又向上的2^k个节点，所以是向上2^(k + 1)个节点
        }
    }
}
//计算u和v的LCA
int lca(int u , int v) {
    if(dep[u] < dep[v]) //让u和v向上走到同一深度
        swap(u , v);
    for(int k = 0 ; k < MAX_LOG_V ; k++) {
        if((dep[v] - dep[u]) >> k & 1) { //把深度差化为2进制(快速幂原理) 依次从低位相减
            v = par[k][v];
        }
    }
    if(u == v) //要是节点相同则输出LCA
        return u;
    for(int k = MAX_LOG_V - 1 ; k >= 0 ; k--) { //二分搜索计算LCA
        if(par[k][u] != par[k][v]) {  //若他们的2^k节点不相同 则u和v向上移动，一直移动直到他们的上一个节点相同
            u = par[k][u];
            v = par[k][v];
        }
    }
    return par[0][u];
}