LCA在线处理 基于二分搜索

记节点v到根点的深度为depth[v]，那么当w是v和u的最近公共祖先时，可以想让v和u在同一个深度，即让深度高的走|depth[v]-depth[u]|然后一起走，

直到遇见相同的祖先时就是最近公共祖先了。如果是计算一次的话还可以，但有很多询问时就不行了。

那么可以利用父亲节点的信息来做了，可以通过parent2[v] = parent[parent[v]]得到v向上走两步的节点。在利用这个信息，

又可以通过parent4[v] = parent2[parent2[v]]得到向上走4步得到的节点，这样搜索的复杂度是O(long(n))了，预处理parent[k][v]的复杂度是O(nlong(n))。

#include <iostream>
#include <stdio.h>
#include <vector>
#include <string.h>
using namespace std;
const int N = 1e4+10;
vector<int> G[N];
int vis[N], parent[30][N], depth[N], t, n;

void dfs(int v, int p, int d){
    parent[0][v] = p;
    depth[v] = d;
    for(int i = 0; i < G[v].size(); i ++){
        if(G[v][i] != p) dfs(G[v][i],v,d+1);
    }
}
int lca(int u, int v){
    if(depth[u] > depth[v]) swap(u,v);
    for(int k = 0; k < 30; k ++){
        if((depth[v]-depth[u]) >> k&1){
            v = parent[k][v];
        }
    }
    if(v == u) return u;
    for(int k = 29; k >= 0; k--){
        if(parent[k][u] != parent[k][v]){
            u = parent[k][u];
            v = parent[k][v];
        }
    }
    return parent[0][u];
}
void init(){
    memset(parent,-1,sizeof(parent));
    for(int i = 1; i < N; i ++){
        parent[0][i] = i;
        G[i].clear();
    }
    memset(vis,0,sizeof(vis));
    memset(depth,0,sizeof(depth));
}
int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        init();
        int x, y;
        for(int i = 1; i < n; i ++){
            scanf("%d %d",&x,&y);
            G[x].push_back(y);
            G[y].push_back(x);
            vis[y] = 1;
        }
        for(int i = 1; i <= n; i ++){
            if(!vis[i]){
                dfs(i,-1,0);
                for(int k = 0; k+1 < 30; k ++){
                    for(int v = 0; v < N; v ++){
                        if(parent[k][v] < 0) parent[k+1][v] = -1;
                        else parent[k+1][v] = parent[k][parent[k][v]];
                    }
                }
            }
        }
        scanf("%d%d",&x,&y);
        printf("%d
",lca(x,y));
    }
    return 0;
}