【BZOJ2286】消耗战（虚树，DFS序，树形DP）

题意：一棵N个点的树上有若干个关键点，每条边有一个边权，现在要将这些关键点到1的路径全部切断，切断一条边的代价就是边权。

共有M组询问，每组询问有k[i]个关键点，对于每组询问求出完成任务的最小代价。

对于100%的数据，2<=n<=250000,m>=1,sigma(ki)<=500000,1<=ki<=n-1

思路：第一题虚树，需要详细地记录一下。

对于此题，朴素的树形DP很好理解：

dp[u]为将u子树中的关键点全部切断的最小代价

dp[u]=min(cut[u],sigma(dp[v])) 其中cut[u]为1到u中最小的边权

但因为询问有多次且需要切断的关键点不同，会超时

经过思考可以发现只有很少的点需要被作为关键点进行处理：当一个点是关键点，或者为某两个关键点的LCA时，这个点会被作为关键点

显然关键点的数量是O(n)级别的

对于每次询问重新构造一棵虚树，使用栈

现将关键点按DFS序从小到大排序

对于一条链上的点只需保留两个

设新插入的点为x，栈顶的第一个点为y，第二个点为z，x与y的LCA为w：

1.dfn[w]<dfn[z] (w,x)连边,x入栈

2.dfn[w]=dfn[z] (y,z)连边

3.dfn[w]>dfn[z] 将w加入栈，(w,z),(w,x)之间连边

const oo=1000000000000;
var head,vet,next,len,head1,vet1,next1,
    dep,flag,dfn,b,h,stk:array[0..500000]of longint;
    dp,cut:array[1..500000]of int64;
    f:array[1..500000,0..20]of longint;
    n,i,x,y,z,tot,time,que:longint;

procedure add(a,b,c:longint);
begin
 inc(tot);
 next[tot]:=head[a];
 vet[tot]:=b;
 len[tot]:=c;
 head[a]:=tot;
end;

function min(x,y:int64):int64;
begin
 if x<y then exit(x);
 exit(y);
end;

procedure swap(var x,y:longint);
var t:longint;
begin
 t:=x; x:=y; y:=t;
end;

function lca(x,y:longint):longint;
var i,d:longint;
begin
 if dep[x]<dep[y] then swap(x,y);
 d:=dep[x]-dep[y];
 for i:=0 to 20 do
  if d and (1<<i)>0 then x:=f[x,i];
 for i:=20 downto 0 do
  if f[x,i]<>f[y,i] then
  begin
   x:=f[x,i]; y:=f[y,i];
  end;
 if x=y then exit(x);
 exit(f[x,0]);
end;

procedure dfs(u:longint);
var e,i,v:longint;
begin
 for i:=1 to 20 do
 begin
  if dep[u]<(1<<i) then break;
  f[u,i]:=f[f[u,i-1],i-1];
 end;
 inc(time); dfn[u]:=time;
 flag[u]:=1;
 e:=head[u];
 while e<>0 do
 begin
  v:=vet[e];
  if flag[v]=0 then
  begin
   f[v,0]:=u;
   dep[v]:=dep[u]+1;
   cut[v]:=min(cut[u],len[e]);
   dfs(v);
  end;
  e:=next[e];
 end;
end;

procedure qsort(l,r:longint);
var i,j,mid:longint;
begin
 i:=l; j:=r; mid:=b[(l+r)>>1];
 repeat
  while mid>b[i] do inc(i);
  while mid<b[j] do dec(j);
  if i<=j then
  begin
   swap(h[i],h[j]);
   swap(b[i],b[j]);
   inc(i); dec(j);
  end;
 until i>j;
 if l<j then qsort(l,j);
 if i<r then qsort(i,r);
end;

procedure add1(a,b:longint);
begin
 if a=b then exit;
// writeln(a,' ',b);
 inc(tot);
 next1[tot]:=head1[a];
 vet1[tot]:=b;
 head1[a]:=tot;
end;

procedure dfs2(u:longint);
var e,v:longint;
    s:int64;
begin
 e:=head1[u]; dp[u]:=cut[u];
 s:=0;
 while e<>0 do
 begin
  v:=vet1[e];
  dfs2(v);
  s:=s+dp[v];
  e:=next1[e];
 end;
 head1[u]:=0;
 if s=0 then dp[u]:=cut[u]
  else dp[u]:=min(s,dp[u]);
end;

procedure solve;
var m,i,top,now,p,q:longint;
begin
 read(m); tot:=0;
 for i:=1 to m do begin read(h[i]); b[i]:=dfn[h[i]]; end;
 qsort(1,m);
 q:=1;
 for i:=2 to m do
  if lca(h[q],h[i])<>h[q] then begin inc(q); h[q]:=h[i]; end;
 //for i:=1 to q do writeln(h[i]);
 stk[1]:=1; top:=1;
 for i:=1 to q do
 begin
  now:=h[i]; p:=lca(now,stk[top]);
  while true do
  begin
   if dep[p]>=dep[stk[top-1]] then
   begin
    add1(p,stk[top]); dec(top);
    if stk[top]<>p then begin inc(top); stk[top]:=p; end;
    break;
   end;
   add1(stk[top-1],stk[top]); dec(top);
  end;
  if stk[top]<>now then begin inc(top); stk[top]:=now; end;
 end;
 repeat
  dec(top);
  if top<=0 then break;
  add1(stk[top],stk[top+1]);
 until top=0;
 dfs2(1);
 writeln(dp[1]);
end;

begin
 assign(input,'bzoj2286.in'); reset(input);
 assign(output,'bzoj2286.out'); rewrite(output);
 readln(n);
 for i:=1 to n-1 do
 begin
  readln(x,y,z);
  add(x,y,z);
  add(y,x,z);
 end;
 readln(que);
 //fillchar(cut,sizeof(cut),$1f);
 cut[1]:=oo;
 dfs(1);
 for i:=1 to que do solve;
 close(input);
 close(output);
end.