【模板算法】LCA最近公共祖先问题——二分搜索

算法描述：

通过预处理parent数组，实现对两个节点公共祖先的二分搜索。主要目的是降低多次搜素的综合复杂度，预处理数组的复杂度为O(nlogn)，单词处理的复杂度为O(logn)。

算法实现原理：

对于任意顶点v，利用其父亲节点信息，可以通过parent[k+1][v]=parent[k][parent[k][v]]得到其每向上走2^k步所到的顶点parent[k][v]。有了k=floor(logn)以内的所有信息后，就可以进行二分搜索了。

数据保存

#define MAX_V 1000
#define MAX_LOG_V 4
using namespace std;
vector<int>G[MAX_V]; //用邻接表存储树
int root;//树的根节点
int N;//总结点数+root
int parent[MAX_LOG_V][MAX_V];
int depth[MAX_V];

预处理：

void dfs(int v,int p,int d){//初始化depth数组和parent数组第一层 
    parent[0][v]=p;
    depth[v]=d;
    for(int i=0;i<G[v].size();i++){
        dfs(G[v][i],v,d+1);
    }
} 
void init(int V){//初始化parent数组和depth数组 
    dfs(root,-1,0);
    for(int k=0;k+1<MAX_LOG_V;k++){
        for(int v=0;v<V;v++){
            if(parent[k][v]<0)parent[k+1][v]=-1;
            else parent[k+1][v]=parent[k][parent[k][v]];
        }
    }
}

LCA计算

1.让v为最深的节点
2.让v走到和u同一深度
3.让v和u走到同一节点
模拟3和8：
3为第2层，8为第4层
4-2=2，2=10(二进制)，0&1=0，所以第一次不走；1&1=1，所以走两步到达2，把2赋值给8
如果差5层，则为101，走4层再走1层；
3为第二层，2为第二层
先判断3向上走2^2步与2向上走2^2步是否为同一节点，明显是的，所以不走；
再判断3向上走2步与2向上走2步是否为同一节点，明显是的，所以不走；
再判断3向上走1步与2向上走1步是否为同一节点，明显是的，所以不走；
返回3的父节点，即为1。
如果差3辈，则会加2；如果差4辈，则会加2加1；

int lca(int u,int v){
    if(depth[u]>depth[v])swap(u,v);//保证v是更深的那个节点 
    printf("%d %d\n",u,v);
    for(int k=0;k<MAX_LOG_V;k++){//让v走到和u同一深度 
        if((depth[v]-depth[u])>>k&1){
            v=parent[k][v];
        }
    }
    printf("%d %d\n",u,v);
    if(u==v)return u;
    for(int k=MAX_LOG_V-1;k>=0;k--){//走到同一节点 
        if(parent[k][u]!=parent[k][v]){
            u=parent[k][u];
            v=parent[k][v];
            printf("%d %d\n",u,v);
        }
    }
    return parent[0][u];
}

测试代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<string>
#include<vector>
#include<algorithm>
#define INF 99999999
#define MAX_V 1000
#define MAX_LOG_V 4
using namespace std;
vector<int>G[MAX_V]; 
int root;//树的根节点
int N;//总结点数（起始为1）
int parent[MAX_LOG_V][MAX_V];
int depth[MAX_V];
void dfs(int v,int p,int d){//初始化depth数组和parent数组第一层 
    parent[0][v]=p;
    depth[v]=d;
    for(int i=0;i<G[v].size();i++){
        dfs(G[v][i],v,d+1);
    }
} 
void init(int V){//初始化parent数组和depth数组 
    dfs(root,-1,0);
    for(int k=0;k+1<MAX_LOG_V;k++){
        for(int v=0;v<V;v++){
            if(parent[k][v]<0)parent[k+1][v]=-1;
            else parent[k+1][v]=parent[k][parent[k][v]];
        }
    }
}
int lca(int u,int v){
    if(depth[u]>depth[v])swap(u,v);//保证v是更深的那个节点 
    printf("%d %d\n",u,v);
    for(int k=0;k<MAX_LOG_V;k++){//让v走到和u同一深度 
        if((depth[v]-depth[u])>>k&1){
            v=parent[k][v];
        }
    }
    printf("%d %d\n",u,v);
    if(u==v)return u;
    for(int k=MAX_LOG_V-1;k>=0;k--){//走到同一节点 
        if(parent[k][u]!=parent[k][v]){
            u=parent[k][u];
            v=parent[k][v];
            printf("%d %d\n",u,v);
        }
    }
    return parent[0][u];
}
int main(){
    root=1;
    N=9;
    G[1].push_back(2);
    G[1].push_back(3);
    G[2].push_back(4);
    G[2].push_back(5);
    G[3].push_back(6);
    G[5].push_back(7);
    G[5].push_back(8);
    init(N);
    for(int i=0;i<MAX_LOG_V;i++){
        for(int j=1;j<N;j++){
            printf("%d ",parent[i][j]);
        } 
        printf("\n");
    }
    printf("%d\n",lca(3,8));
    return 0;
}