HDU 6031 Innumerable Ancestors

树状数组，倍增，枚举，$dfs$序。

对于每一次的询问，可以枚举$B$集合中的所有点，对于每一个点，在树上二分$LCA$，找到最低的更新答案。

判断是否是$LCA$可以搞个$dfs$序，将$A$集合中所有点标$1$，然后查询子树对应的区间上的区间和。

#include <bits/stdc++.h>
using namespace std;

const int maxn = ;
int L[maxn],R[maxn];
int c[*maxn];
int h[maxn];
int to[*maxn];
int nx[*maxn];
int sz;
int tt;
int dp[][];
int dep[];
int ans;
int n,m;

int k1,k2;
int A[],B[];

void add(int a,int b)
{
    to[sz] = b;
    nx[sz] = h[a];
    h[a] = sz++;
}

void dfs(int x,int y)
{
    L[x] = tt; tt++;
    dp[x][] = y;

    if(y==-) dep[x]=;
    else dep[x] = dep[y]+;

    for(int i=h[x];i!=-;i = nx[i])
    {
        if(L[to[i]]) continue;
        dfs(to[i],x);
    }
    R[x] = tt; tt++;
}

int lowbit(int x)
{
    return x&(-x);
}

void update(int pos,int val)
{
    for(int i=pos;i<=*n;i=i+lowbit(i))
    {
        c[i] += val;
    }
}

int get(int pos)
{
    int res=;

    for(int i=pos;i>;i=i-lowbit(i))
    {
        res=res+c[i];
    }

    return res;
}

void work(int x)
{
    while()
    {
        int Q = dp[x][];
        if(get(R[Q])-get(L[Q]-))
        {
            ans = max(ans,dep[Q]);
            break;
        }

        for(int i=;i>=;i--)
        {
            int to = dp[x][i];
            if(to==-) continue;
            if(get(R[to])-get(L[to]-)) continue;
            x=to;
            break;
        }
    }

    x = dp[x][];
    ans = max(ans,dep[x]);
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        sz=;

        for(int i=;i<=n;i++)
        {
            c[i]=;
            h[i]=-;
            L[i]=;
            R[i]=;
        }

        for(int i=;i<=n-;i++)
        {
            int a,b; scanf("%d%d",&a,&b);
            add(a,b); add(b,a);
        }

        tt=; dfs(,-);

        for(int j=;j<=;j++)
        {
            for(int i=;i<=n;i++)
            {
                if(dp[i][j-]==-) dp[i][j]=-;
                else dp[i][j] = dp[dp[i][j-]][j-];
            }
        }

        for(int i=;i<=m;i++)
        {
            scanf("%d",&k1); for(int j=;j<=k1;j++) scanf("%d",&A[j]), update(L[A[j]],);
            scanf("%d",&k2);

            ans=;

            for(int j=;j<=k2;j++)
            {
                scanf("%d",&B[j]);
                if(get(R[B[j]])-get(L[B[j]]-))
                {
                    ans = max(ans,dep[B[j]]);
                    continue;
                }

                work(B[j]);
            }

            printf("%d\n",ans);

            for(int j=;j<=k1;j++) update(L[A[j]],-);
        }
    }
    return ;
}