ZOJ - 4048 Red Black Tree LCA+ 二分

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=4048
连着TLE了两个星期，换一个编译器过了？
题目要求询问K个点中间最大的点权，点权指某个黑点到最近的红点的距离。可以随便改一个黑点为红点。
最大最下……emmmm应该是二分。首先我们先来贪心地想一下，我们更改的这个点一定是这些点的公共的LCA，那我们先对这些点的点权进行排序，求出LCA，判断的时候判断一下这些点的之间的距离是否满足要求就可以了

#include <cstdio>
#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
#include <queue>
#include <map>
#define ll long long
using namespace std;
const int MAXN = 1e5 + 10;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll rmq[2*MAXN];//rmq数组，就是欧拉序列对应的深度序列
struct ST
{
    ll mm[2*MAXN];
    ll dp[2*MAXN][20];//最小值对应的下标
    void init(int n)
    {
        mm[0] = -1;
        for(int i = 1; i <= n; i++)
        {
            mm[i] = ((i&(i-1)) == 0)?mm[i-1]+1:mm[i-1];
            dp[i][0] = i;
        }
        for(int j = 1; j <= mm[n]; j++)
            for(int i = 1; i + (1<<j) - 1 <= n; i++)
                dp[i][j] = rmq[dp[i][j-1]] < rmq[dp[i+(1<<(j-1))][j-1]]?dp[i][j-1]:dp[i+(1<<(j-1))][j-1];
    }
    int query(int a,int b)//查询[a,b]之间最小值的下标
    {
        if(a > b)
            swap(a,b);
        int k = mm[b-a+1];
        return rmq[dp[a][k]] <= rmq[dp[b-(1<<k)+1][k]]?dp[a][k]:dp[b-(1<<k)+1][k];
    }
};
struct Edge
{
    int to,next;
    int w;
};
Edge edge[MAXN*2];
int tot,head[MAXN];
int F[MAXN*2];//欧拉序列，就是dfs遍历的顺序，长度为2*n-1,下标从1开始
int P[MAXN];//P[i]表示点i在F中第一次出现的位置
ll rdis[MAXN],dis[MAXN];
int col[MAXN],prec[MAXN];
int cnt;
ST st;
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v,int w)//加边，无向边需要加两次
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    edge[tot].w = w;
    head[u] = tot++;
}
void dfs(int u,int pre,int dep,ll sum,ll sum1)
{

    F[++cnt] = u;
    rmq[cnt] = dep;
    P[u] = cnt;

    if(col[u]) sum1 = 0;
    dis[u] = sum,rdis[u] = sum1;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(v == pre)
            continue;
        dfs(v,u,dep+1,sum + edge[i].w,sum1 + edge[i].w);
        F[++cnt] = u;
        rmq[cnt] = dep;
    }
}
void LCA_init(int root,int node_num)//查询LCA前的初始化
{
    cnt = 0;
    //memset(dist,0,sizeof(dist));
    dfs(1,-1,1,0,0);
    st.init(2*node_num-1);
}
int query_lca(int u,int v)//查询u,v的lca编号
{
    return F[st.query(P[u],P[v])];
}
int k;
int t[MAXN];
bool check(ll mid)
{
    if(rdis[t[0]] <= mid) return 1;

    int lca = t[0];

    for(int i = 1;i<k;i++)
    {
        if(rdis[t[i]] <= mid) break;

        lca=  query_lca(lca,t[i]);
    }
    for(int i = 0;i<k;i++)
    {
        if(rdis[t[i]] <= mid) return 1;
        if(dis[t[i]] - dis[lca] > mid) return 0;
    }
    return 1;
}
bool cmp(int x,int y) {return rdis[x] > rdis[y];}
int main()
{

    int ca;
    scanf("%d",&ca);
    while(ca--)
    {
        int n,m,q;
        scanf("%d%d%d",&n,&m,&q);
        memset(col,0,sizeof(col));
        for(int i = 0;i<m;i++)
        {
            int c;
            scanf("%d",&c);
            col[c] = 1;
        }
        init();
        for(int i = 0;i < n -1;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w);
            addedge(v,u,w);
        }
        LCA_init(1,n);
        while(q--)
        {
            scanf("%d",&k);
            for(int i = 0;i<k;i++) scanf("%d",&t[i]);

            sort(t,t+k,cmp);
            ll l = 0,r = dis[t[0]];
            while(l < r)
            {
                ll mid = (l + r) >> 1;
                if(check(mid))
                {
                    r = mid;
                }
                else l = mid + 1;
            }
            printf("%lld\n",l);
        }
    }
    return 0;
}