POJ 1330 挑战程序设计 LCA模版

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cmath>
#include<cstring>
#define N 30000+10
using namespace std;
int vis[N],id[N],depth[N],dp[N][20],in[N],k;
vector<int>G[N];

int Min(int a,int b)
{
    if(depth[a]<=depth[b])//找到区间中最小的那个深度，就是LCA（最近公共父节点）
        return a;//返回父节点的下标
    return b;
}

void init_rmq(int n)//返回的不是最小值，而是最小值对应的下标
{
    for(int i=1;i<=n;i++)//初始化dp[i][0]为i,表示从区间i开始（从dfs遍历顺序为i的地方开始）
        dp[i][0]=i;
    for(int j=1;(1<<j)<=n;j++)
        for(int i=1;i+(1<<j)-1<=n;i++)
            dp[i][j]=Min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);//i到i+的j次方这段区间dfs访问中深度最小的那个点就是最近公共父节点，dp存的是父节点的下标，但是比较的是父节点之间的深度
}

void dfs(int v,int d)//v表示的是节点，d表示的是深度
{
    id[v]=k;//v这个节点第一次进入dfs的顺序是k(v这个节点第一次出现在vis数组中的位置)
    vis[k]=v;//记录访问节点的顺序
    depth[k]=d;//记录每个节点的深度
    k++;//记录下一个节点
    for(int i=0;i<G[v].size();i++)//遍历v节点的儿子们
    {
        dfs(G[v][i],d+1);//递归v节点的儿子们
        vis[k]=v;//回溯时也要记录v节点
        depth[k]=d;//记录v节点的深度
        k++;//记录下一个节点
    }
}

void init(int root,int n)
{
    k=1;//k记录的是下标
    dfs(root,0);
    init_rmq(n*2-1);//找区间最小值
}

int query(int l,int r)
{
    int k=(int)(log10(r-l+1)/log10(2.0));
    int rev=Min(dp[l][k],dp[r-(1<<k)+1][k]);//rev是深度最小的节点在vis中的下标
    return vis[rev];
}

int main()
{
    int t,n,a,b,x,y;
    cin>>t;
    while(t--)
    {
        for(int i=0;i<N;i++)
            G[i].clear();//G是链表
        memset(in,0,sizeof(in));//in标记不是根节点的点
        cin>>n;
        for(int i=1;i<n;i++)
        {
            scanf("%d%d",&a,&b);
            G[a].push_back(b);//a这个点连接的其他点
            in[b]=1;
        }
        int i;
        for(i=1;i<=n;i++)//找到根节点
            if(in[i]==0)
                break;
        init(i,n);//初始化树？
        cin>>x>>y;
        int ans=query(min(id[x],id[y]),max(id[x],id[y]));//dfs访问x（或者y）之后y之前所经过的顶点中离根最近的那个就是LCA
        cout<<ans<<endl;
    }
    return 0;
}