bzoj2286

很明显，20%=mincut 40%=每次暴力树形dp
那么正解是什么呢？不难发现∑ki<=500000,也就是每次询问的复杂度都要跟k有关
从树形dp工作的角度来看，确实有很多点我们根本就没必要访问，我们设每次要割断的岛屿为关键点
这里引入了一个新的东西叫做虚树，简单来说就是把树上没用的点去掉收缩成一棵树
具体来说，如果一个点的子树中至多只有一棵子树包含关键点，那么这个点就可以删掉
也就是说只有关键点和他们的lca会被保留下来就行了，证明总点数<=2*k-1
那么怎么构建虚树？我们先按dfs序排序，然后按这个顺序不断加点维护虚树上最新的路径
感觉建树的方法只可意会不可言传，具体见代码吧……

type node=record
       len,po,next:longint;
     end;

var e:array[0..500010] of node;
    anc:array[0..250010,0..20] of longint;
    b,d,p,c,fa,st,a:array[0..250010] of longint;
    f:array[0..250010] of int64;
    v:array[0..250010] of boolean;
    w,s,m,h,t,n,len,i,x,y,z:longint;

function min(a,b:longint):longint;
  begin
    if a>b then exit(b) else exit(a);
  end;

procedure swap(var a,b:longint);
  var c:longint;
  begin
    c:=a;
    a:=b;
    b:=c;
  end;

procedure sort(l,r: longint);
  var i,j,x:longint;
  begin
    i:=l;
    j:=r;
    x:=b[a[(l+r) shr 1]];
    repeat
      while b[a[i]]<x do inc(i);
      while x<b[a[j]] do dec(j);
      if not(i>j) then
      begin
        swap(a[i],a[j]);
        inc(i);
        j:=j-1;
      end;
    until i>j;
    if l<j then sort(l,j);
    if i<r then sort(i,r);
  end;

procedure add(x,y,z:longint);
  begin
    inc(len);
    e[len].po:=y;
    e[len].len:=z;
    e[len].next:=p[x];
    p[x]:=len;
  end;

procedure dfs(x:longint);
  var i,y:longint;
  begin
    inc(t);
    b[x]:=t;  //dfs序
    for i:=1 to h do
    begin
      y:=anc[x,i-1];
      if y<>0 then anc[x,i]:=anc[y,i-1]
      else break;
    end;
    i:=p[x];
    while i<>0 do
    begin
      y:=e[i].po;
      if fa[x]<>y then
      begin
        fa[y]:=x;
        anc[y,0]:=x;
        c[y]:=min(c[x],e[i].len);  //c[]表示把这个点和根节点割开最小代价
        d[y]:=d[x]+1;
        dfs(y);
      end;
      i:=e[i].next;
    end;
  end;

function lca(x,y:longint):longint;
  var i,p:longint;
  begin
    if d[x]<d[y] then swap(x,y);
    p:=trunc(ln(d[x])/ln(2));
    if d[x]>d[y] then
      for i:=p downto 0 do
        if d[x]-1 shl i>=d[y] then x:=anc[x,i];
    if x=y then exit(x);
    for i:=p downto 0 do
      if (anc[y,i]<>anc[x,i]) then
      begin
        x:=anc[x,i];
        y:=anc[y,i];
      end;
    exit(fa[x]);
  end;

procedure dp(x:longint);  //dp过程很简单
  var i,y:longint;
      s:int64;
  begin
    if x=1 then f[1]:=2147483647*2147483647
    else f[x]:=c[x];
    i:=p[x];
    s:=0;
    while i<>0 do
    begin
      y:=e[i].po;
      dp(y);
      s:=s+f[y];
      i:=e[i].next;
    end;
    p[x]:=0;
    if (s<>0) then
      if f[x]>s then f[x]:=s;
  end;

begin
  readln(n);
  h:=trunc(ln(n)/ln(2));
  for i:=1 to n-1 do
  begin
    readln(x,y,z);
    add(x,y,z);
    add(y,x,z);
  end;
  c[1]:=2147483647;
  dfs(1);
  readln(m);
  fillchar(p,sizeof(p),0);
  while m>0 do
  begin
    dec(m);
    read(s);
    for i:=1 to s do
      read(a[i]);

    sort(1,s);
    w:=1;
    for i:=2 to s do
      if lca(a[w],a[i])<>a[w] then  //这里一点点优化，如果存在祖先关系的关键点，肯定割祖先以上的边
      begin
        inc(w);
        a[w]:=a[i];
      end;
    len:=0;
    st[1]:=1;
    t:=1;
    for i:=1 to w do
    begin
      x:=a[i];
      z:=lca(x,st[t]); 
      while d[z]<d[st[t]] do  //这里画个图比较好理解，类似一个新路径和原来维护的路径的一个分叉
      begin
        if d[z]>=d[st[t-1]] then
        begin
          add(z,st[t],0);
          dec(t);
          if st[t]<>z then
          begin
            inc(t);
            st[t]:=z;
          end;
          break;
        end;
        add(st[t-1],st[t],0);  //把原来分叉的那段建出来
        dec(t);
      end;
      if st[t]<>x then
      begin
        inc(t);
        st[t]:=x;
      end;
    end;
    while t>1 do   //把维护的路径建出来
    begin
      add(st[t-1],st[t],0);
      dec(t);
    end;
    dp(1);
    writeln(f[1]);
  end;
end.