LCA问题及倍增解法

概述：

 

LCA（Lowest Common Ancestors），即最近公共祖先，是这样一个问题：在有根树中，找出某两个结点u和v最近的公共祖先（或者说，离树根最远的公共祖先）

倍增解法：

倍增解法的核心是分治思想。当已知两个点在树中的深度时，先让较深的结点向上走，直到两个结点深度一样；再二分找出离他们最近的公共祖先。我们记一个结点的父节点为它的2^0=1倍祖先，它的父节点的父节点为它的2倍祖先，以此类推。接下来开始描述倍增算法的具体流程

第一步：在树上预处理每个结点的深度和1倍祖先，也就是每个结点的父节点。用d数组来表示每个结点的深度，p[v][h]表示结点v的h倍祖先的结点编号。d数组中的元素初始为-1

代码如下：

const int MAX_N = 100000;
const int MAX_M = 1000000;
int d[MAX_N], p[MAX_N][20];

void init() {
    memset(d, -1, sizeof(d));
}

void dfs(int node) {
    for (int i = f[node]; i != -1; i = e[i].next) {
        if (d[e[i].v] == -1) {    
            d[e[i].v] = d[node] + 1;
            p[e[i].v][0] = node;
            dfs(e[i].v);
        }
    }
}

初始化完成后，p[a][0]保存的时a的2^0=1倍祖先结点，即它的父节点，时间复杂度为O(V)

for (int level = 1; (1 << level) <= n; level++) {
    for (int i = 1; i <= n; i++) {
        p[i][level] = p[p[i][level - 1]][level - 1];  // i 的第 2^j 祖先就是 i 的第 2^(j-1) 祖先的第 2^(j-1) 祖先
    }
}

int lca(int x, int y) {
    int i, j;
    // 确保 x 的深度比 y 大
    if (d[x] < d[y]) {
        swap(x, y);
    }
    // 接下来，让 x 向上找，直到 x 的深度和 y 一致
    for (i = 0; (1 << i) <= d[x]; i++);  // 2^i > d[x]
    i--;  // 找出的 i 是最大的可能需要从 d[x] 里减去的 2^i，也就是，i 是满足 2^i<=d[x] 的最大值
    for (j = i; j >= 0; j--) {
        if (d[x] - (1 << j) >= d[y]) {
            x = p[x][j];
        }
    }
    // 若此时 x 和 y 相等，则当前的 x 就是他们的 LCA
    if (x == y) {
        return x;
    }
    // 否则，继续二分，找到深度最小的 x' 和 y'
    for (j = i; j >= 0; j--) {
        if (p[x][j] != p[y][j]) {
            x = p[x][j];
            y = p[y][j];
        }
    }
    // p[x'][0] 就是 LCA
    return p[x][0];
}

LCA的使用如下：

#include <iostream>
#include<cstring>
using namespace std;
const int MAX_N=100000;
const int MAX_M=1000000;
struct edge{
    int v,next;
}E[MAX_M];
int p[MAX_N],eid;
void init()
{
    memset(p,-1,sizeof(p));
    eid=0;
}
void insert(int u,int v)
{
    E[eid].v=v;
    E[eid].next=p[u];
    p[u]=eid++;
}
int d[MAX_N],fa[MAX_N][20];

void dfs(int u)
{
    for(int i = p[u];i+1;i=E[i].next){
        if(d[E[i].v] == -1){
            d[E[i].v] = d[u] + 1;
            fa[E[i].v][0] = u;
            dfs(E[i].v);
        }
    }
}

int lca(int x,int y){
    int i,j;
    if(d[x] < d[y]){
        swap(x,y);
    }
    for(i = 0;(1 << i) <= d[x];i++);
    --i;
    for(j = i;j>=0;j--){
        if(d[x] - (1 << j) >= d[y]){
            x = fa[x][j];
        }
    }
    if(x == y){
        return x;
    }
    for(j=i;j>=0;j--){
		if(fa[x][j] != fa[y][j]){
            x = fa[x][j];
            y = fa[y][j];
        }
    }
    return fa[x][0];
}

int main() {
    int n;
    init();
    cin>>n;
    for(int i=0;i<n-1;++i)
    {
        int u,v;
        cin>>u>>v;
        insert(u,v);
        insert(v,u);
    }
    memset(d,-1,sizeof(d));
    dfs(1);
    for(int level = 1;(1 << level) <= n;level++){
        for(int i=1;i<=n;i++){
            fa[i][level] = fa[fa[i][level-1]][level - 1];
        }
    }
    int q;
    cin>>q;
    while(q--){
        int a,b;
        cin>>a>>b;
        cout<<lca(a,b)<<endl;
    }
    return 0;
}