消耗战（bzoj 2286）

/*
    虚树+树形DP
    设f[i]表示除掉以i为根的子树中所有关键点的最小花费，g[i]表示i是否是关键点。
    f[i]=Σmin(g[e[i].v]?inf:f[e[i].v],e[i].w)
    但是DP的复杂度是O(n)的，我们考虑每次的关键点是很少的，
    我们可以只把这些关键点和对答案有用的点(lca)提出来，建一棵虚树，在虚树上DP。
    如何建立虚树呢？用一个单调栈。
    将关键点按照dfs序排序，栈中的元素形成一条由根节点出发的链，初始栈中只有根节点。
    每次加入一个节点，求出节点与栈顶的LCA,将栈中所有深度大于LCA的节点全都弹掉。 
    然后将LCA和该节点入栈，注意有些重复的情况要考虑。 
    在这个模拟的DFS过程中顺便把DP做了即可。 
*/
#include<cstdio>
#include<iostream>
#include<algorithm>
#define N 250010
#define lon long long
#define inf 1000000000
using namespace std;
int head[N],a[N],n,m,tot,cnt;
int pos[N],dep[N],fa[N][20],dis[N][20];
int g[N],stack[N];
lon f[N];
struct node{int v,w,pre;}e[N*2];
void add(int x,int y,int z){
    e[++tot].v=y;
    e[tot].w=z;
    e[tot].pre=head[x];
    head[x]=tot;
}
void dfs(int x){
    pos[x]=++cnt;
    dep[x]=dep[fa[x][0]]+1;
    for(int i=head[x];i;i=e[i].pre)
        if(e[i].v!=fa[x][0]){
            fa[e[i].v][0]=x;
            dis[e[i].v][0]=e[i].w;
            dfs(e[i].v);
        }
}
bool cmp(int x,int y){
    return pos[x]<pos[y];
}
int LCA(int x,int y){
    if(dep[x]<dep[y]) swap(x,y);
    for(int i=19;i>=0;i--)
        if(dep[fa[x][i]]>=dep[y])
            x=fa[x][i];
    if(x==y) return x;
    for(int i=19;i>=0;i--)
        if(fa[x][i]!=fa[y][i])
            x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}
int calc(int x,int y){
    int re=inf;
    for(int i=19;i>=0;i--)
        if(dep[fa[x][i]]>=dep[y])
            re=min(re,dis[x][i]),x=fa[x][i];
    return re;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<n;i++){
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);
        add(y,x,z);
    }
    dfs(1);
    for(int j=1;j<=19;j++)
        for(int i=1;i<=n;i++){
            fa[i][j]=fa[fa[i][j-1]][j-1];
            dis[i][j]=min(dis[i][j-1],dis[fa[i][j-1]][j-1]);
        }
    int top=0;
    scanf("%d",&m);
    for(int i=1;i<=m;i++){
        int k;scanf("%d",&k);
        for(int j=1;j<=k;j++) scanf("%d",&a[j]);
        sort(a+1,a+k+1,cmp);
        stack[++top]=1;
        f[1]=0;g[1]=0;
        for(int j=1;j<=k;j++){
            int lca=LCA(stack[top],a[j]);
            while(dep[stack[top]]>dep[lca]){
                if(dep[stack[top-1]]<=dep[lca]){
                    int tmp=min(g[top]?inf:f[top],(lon)calc(stack[top],lca));
                    stack[top--]=0;
                    if(lca!=stack[top]){
                        stack[++top]=lca;
                        f[top]=0;g[top]=0;
                    }
                    f[top]+=tmp;
                    break;
                }
                else {
                    f[top-1]+=min(g[top]?inf:f[top],(lon)calc(stack[top],stack[top-1]));
                    stack[top--]=0;
                }
            }
            if(stack[top]!=a[j]){
                stack[++top]=a[j];
                f[top]=0;
            }
            g[top]=1;
        }
        while(top>1){
            f[top-1]+=min(g[top]?inf:f[top],(lon)calc(stack[top],stack[top-1]));
            stack[top--]=0;
        }
        printf("%lld\n",f[top--]);
    }
    return 0;
}