hiho1381 Little Y's Tree（dfs序+线段树+树的直径）

给定一棵树，边权为正整数。每次询问砍掉k条边之后，k+1个连通子树的直径和是多少。
我们考虑用线段树来维护连通子树的直径。
考虑如何合并两个连通子树的直径，即我们知道了连通子树的直径分别为x1-y1,d1;x2-y2,d2，我们要把这两个连通子树合并起来。那么新的直径的端点一定是这四个点之二。
至于为何，我们考虑这两个连通子树是由x-y这条边链接起来的。

如果新的直径不经过x-y:那么就是原来的两个直径最大的那个。

如果新的直径经过x-y：那么考虑x在自己的子树中能到达的最远点一定是x子树内的直径端点之一，y同理，因此新的直径两个端点一定分别为原来两个连通子树的直径的端点之一。

好的，我们做出dfs序，那么我们现在就可以用线段树来维护了。
（你说dfs序上连续的一段不一定在树上连通，是的哦，不过我们询问的时候一定是若干子树，一定联通啦，你线段树维护的时候就假装他连通好了qaq）

那么考虑我砍掉k条边。剩下的k+1个连通子树一定是dfs序上若干连续的区间，是$O(k)$级别的。我们分别统计答案即可。

（删一条边，相当于在dfs序上把这个点的子树所代表的区间隔离开了）

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
#define ll long long
#define inf 0x3f3f3f3f
#define N 100010
inline char gc(){
    static char buf[1<<16],*S,*T;
    if(S==T){T=(S=buf)+fread(buf,1,1<<16,stdin);if(T==S) return EOF;}
    return *S++;
}
inline int read(){
    int x=0,f=1;char ch=gc();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=gc();}
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=gc();
    return x*f;
}
int n,m,h[N],num=1,in[N],out[N],dfn=0,b[N],mn[N<<1][18],Log[N<<1],pos[N];
int dep[N],owo=0,id[N],a[N],K,now;ll dis[N],ans;
inline int Min(int x,int y){return dep[x]<dep[y]?x:y;}
inline int lca(int x,int y){
    x=pos[x];y=pos[y];if(x>y) swap(x,y);int d=Log[y-x+1];
    return Min(mn[x][d],mn[y-(1<<d)+1][d]);
}
inline ll caldis(int x,int y){return dis[x]+dis[y]-2*dis[lca(x,y)];}
struct node{
    int x,y;ll d;
    node(){d=-1;}
    friend node operator+(node a,node b){
        if(a.d==-1) return b;if(b.d==-1) return a;node res;
        ll dd=caldis(a.x,b.x);if(dd>res.d) res.d=dd,res.x=a.x,res.y=b.x;
        dd=caldis(a.x,b.y);if(dd>res.d) res.d=dd,res.x=a.x,res.y=b.y;
        dd=caldis(a.y,b.x);if(dd>res.d) res.d=dd,res.x=a.y,res.y=b.x;
        dd=caldis(a.y,b.y);if(dd>res.d) res.d=dd,res.x=a.y,res.y=b.y;
        if(a.d>res.d) res.d=a.d,res.x=a.x,res.y=a.y;
        if(b.d>res.d) res.d=b.d,res.x=b.x,res.y=b.y;
        return res;
    }
}tr[N<<2];
struct edge{
    int to,next,val;
}data[N<<1];
void dfs(int x,int Fa){
    in[x]=++dfn;id[dfn]=x;mn[++owo][0]=x;pos[x]=owo;
    for(int i=h[x];i;i=data[i].next){
        int y=data[i].to;if(y==Fa) continue;
        dep[y]=dep[x]+1;b[i>>1]=y;dis[y]=dis[x]+data[i].val;
        dfs(y,x);mn[++owo][0]=x;
    }out[x]=dfn;
}
inline void initrmq(){
    Log[0]=-1;
    for(int i=1;i<=n*2-1;++i) Log[i]=Log[i>>1]+1;
    for(int i=1;i<=Log[n*2-1];++i)
        for(int j=1;j<=n*2-1;++j){
            if(j+(1<<i-1)>2*n-1) break;
            mn[j][i]=Min(mn[j][i-1],mn[j+(1<<i-1)][i-1]);
        }
}
inline void build(int p,int l,int r){
    if(l==r){tr[p].x=tr[p].y=id[l];tr[p].d=0;return;}
    int mid=l+r>>1;build(p<<1,l,mid);build(p<<1|1,mid+1,r);
    tr[p]=tr[p<<1]+tr[p<<1|1];
}
inline bool cmp(int a,int b){return in[a]<in[b];}
inline node ask(int p,int l,int r,int x,int y){
    if(x<=l&&r<=y) return tr[p];
    int mid=l+r>>1;node res;
    if(x<=mid) res=res+ask(p<<1,l,mid,x,y);
    if(y>mid) res=res+ask(p<<1|1,mid+1,r,x,y);return res;
}
inline void solve(int x){
    int l=in[x],r=out[x];
    node res;
    while(now<=K&&in[x]<=in[a[now]]&&out[a[now]]<=out[x]){
        int y=a[now];++now;solve(y);
        if(l<=in[y]-1) res=res+ask(1,1,n,l,in[y]-1);l=out[y]+1;
    }if(l<=r) res=res+ask(1,1,n,l,r);ans+=res.d;
}
int main(){
//  freopen("a.in","r",stdin);
    n=read();
    for(int i=1;i<n;++i){
        int x=read(),y=read(),val=read();
        data[++num].to=y;data[num].next=h[x];h[x]=num;data[num].val=val;
        data[++num].to=x;data[num].next=h[y];h[y]=num;data[num].val=val;
    }dfs(1,0);initrmq();build(1,1,n);m=read();
    while(m--){
        K=read();now=1;ans=0;
        for(int i=1;i<=K;++i) a[i]=b[read()];sort(a+1,a+K+1,cmp);
        solve(1);printf("%lld\n",ans);
    }return 0;
}