HDU6031 Innumerable Ancestors LCA

要求两个集合中两点最深的公共祖先。

我们二分最深的深度，之后判断是否有两个集合的点在这个深度有公共祖先。

对于当前深度mid，我们对于每一个a【i】，判断在mid出是否有点，有则加入set，没有不加。

之后在枚举每一个b，判断b【i】在mid出的点是否在set中，如果在，说明当前b【i】与a中至少

一点在mid深处有公共祖先。则返回true，再往更深的深度查询即可。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<math.h>
#include<queue>
#include<set>
#include <vector>
#include<iostream>
#include<map>
using namespace std;
const int maxn = 100000 + 10;
struct Edge{
    int to,next;
}edge[maxn*2];
int head[maxn],cnt;
int deep[maxn],anc[maxn][20];

int n,m;

/模板

void add(int u,int v)
{
    edge[cnt].to = v;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}
void init()
{
     memset(head,-1,sizeof(head));
      memset(deep,0,sizeof(deep));
        memset(anc,-1,sizeof(anc));
    cnt = 0;
}
//倍增lca
void dfs(int u,int pre,int d)
{
    deep[u] = d;
    for( int i = head[u]; ~i; i = edge[i].next ){
        int v = edge[i].to;
        if(v == pre)continue;
        anc[v][0] = u;
        dfs(v,u,d+1);
    }
}
void Init()
{
    for( int j = 1; (1<<j) <= n; j++ ){
        for( int i = 1; i <= n; i++ ){
            if(anc[i][j-1] != -1){
                anc[i][j] = anc[anc[i][j-1]][j-1];
            }
        }
    }
}
int lca(int a,int b)
{
    int i,j;
    if(deep[a] < deep[b])swap(a,b);
    for( i = 0; (1<<i) <= deep[a]; i++ );
    i--;


    for( j = i; j >= 0; j-- ){
        if(deep[a] - (1<<j) >= deep[b]){
            a = anc[a][j];
        }
    }
    if(a == b)return a;


    for( j = i; j >= 0; j-- ){
        if(anc[a][j] != -1 && anc[a][j] != anc[b][j]){
            a = anc[a][j];
            b = anc[b][j];
        }
    }
    return anc[a][0];
}
/***********************/
int query(int u,int d)//查询u点往上d长度后的点
{
    if(d < 0)return -1;
    if(d == 0)return u;
    int i;
    for( i = 0; (1<<i) <= d; i++ );
    i--;
    for( ; i >= 0; i-- ){
        if(d - (1<<i) >= 0){
            d -= (1<<i);
            u = anc[u][i];
        }
    }
    return u;

}

/

int a[maxn],b[maxn];
int k1,k2;
bool check(int x)
{
    set<int>s;
    for( int i = 0; i < k1; i++ ){
        int dis = deep[a[i]] - x;
        int ret = query(a[i],dis);//点存在
        if(ret == -1)continue;
        s.insert(ret);//加入set
    }
    for( int i = 0; i < k2; i++ ){
        int dis = deep[b[i]] - x;
        int ret = query(b[i],dis);
        if(s.count(ret))return true;
    }
    return false;
}
int main()
{
    while(~scanf("%d%d",&n,&m)){
        init();
        for( int i = 0; i < n-1; i++ ){
            int u,v;
            scanf("%d%d",&u,&v);
            add(u,v);
            add(v,u);
        }
        dfs(1,1,1);
        Init();


        while(m--){
            scanf("%d",&k1);
            int l = 1,r = 1;
            for( int i = 0; i < k1; i++ )
                scanf("%d",a+i),r = max(r,deep[a[i]]);
            scanf("%d",&k2);
            for( int i = 0; i < k2; i++ )
                scanf("%d",b+i);
            int ans;
            while(l <= r){
                int mid = (l + r) >> 1;
                if(check(mid)){
                    ans = mid;
                    l = mid + 1;
                }
                else {
                    r = mid - 1;
                }
            }
            printf("%d\n",ans);
        }
    }
    return 0;
}