【BZOJ3611】大工程（虚树，DFS序，树形DP）

题意：有一棵树，树有边权，有若干次询问，给出一些点，求：

1.这些点互相之间的距离之和

2.点对距离中的最大和最小值

n<=1000000

q<=50000并且保证所有k之和<=2*n 

 

思路：感谢Gold_7

建立虚树，在上面树形DP即可

最大值和最小值用了一种精妙的写法来保证是最值+次值

终于会写类似点对距离和的树形DP了

 var head,vet,next,len,
     head1,vet1,next1,len1,
     h,stk,b,dep,dfn,flag,c:array[..]of longint;
     dp:array[..,..]of longint;
     size,g:array[..]of int64;
     f:array[..,..]of longint;
     n,i,tot,que,ans1,ans2,time,x,y:longint;
     ans:int64;

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

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

 function max(x,y:int64):int64;
 begin
  if x>y then exit(x);
  exit(y);
 end;

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

 procedure qsort(l,r:longint);
 var i,j,mid:longint;
 begin
  i:=l; j:=r; mid:=b[(l+r)>>];
  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;

 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:= to  do
   if d and (<<i)> then x:=f[x,i];
  for i:= downto  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,]);
 end;

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

 procedure add1(a,b:longint);
 begin
  if a=b then exit;
  inc(tot);
  next1[tot]:=head1[a];
  vet1[tot]:=b;
  len1[tot]:=abs(dep[a]-dep[b]);
  head1[a]:=tot;
 end;

 procedure dfs2(u:longint);
 var e,v:longint;
 begin
  size[u]:=c[u];
  g[u]:=;
  if c[u]= then begin dp[u,]:=; dp[u,]:=; end
   else begin dp[u,]:=-maxlongint div ; dp[u,]:=maxlongint div ; end;
  e:=head1[u];
  while e<> do
  begin
   v:=vet1[e];
   dfs2(v);
   ans:=ans+size[v]*g[u]+size[u]*g[v]+size[u]*size[v]*len1[e];
   size[u]:=size[u]+size[v];
   g[u]:=g[u]+g[v]+size[v]*len1[e];
   ans1:=max(ans1,dp[u,]+dp[v,]+len1[e]);
   ans2:=min(ans2,dp[u,]+dp[v,]+len1[e]);
   dp[u,]:=max(dp[u,],dp[v,]+len1[e]);
   dp[u,]:=min(dp[u,],dp[v,]+len1[e]);
   e:=next1[e];
  end;
  head1[u]:=;
 end;

 procedure solve;
 var q,top,i,now,m,p:longint;
 begin
  tot:=;
  read(m);
  for i:= to m do
  begin
   read(h[i]); b[i]:=dfn[h[i]];
   c[h[i]]:=;
  end;
  qsort(,m);
  //q:=;
  //for i:= to m do
   //if lca(h[i],h[q])<>h[q] then begin inc(q); h[q]:=h[i]; end;
  stk[]:=; top:=;
  for i:= to m do
  begin
   now:=h[i]; p:=lca(now,stk[top]);
   while true do
   begin
    if dep[p]>=dep[stk[top-]] 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-],stk[top]); dec(top);
   end;
   if stk[top]<>now then begin inc(top); stk[top]:=now; end;
  end;
  for i:=top- downto  do add1(stk[i],stk[i+]);
  ans:=; ans1:=-maxlongint div ; ans2:=maxlongint div ;
  dfs2();
  writeln(ans,' ',ans2,' ',ans1);
  for i:= to m do c[h[i]]:=;
 end;

 begin

  readln(n);
  for i:= to n- do
  begin
   readln(x,y);
   add(x,y,);
   add(y,x,);
  end;
  dfs();
  readln(que);
  for i:= to que do solve;

 end.

%了XYZ（虚树发明者）论文后的新的建虚树方法，简明易懂：

1：加入所有原关键点并按DFS序排序

2：将排序后两两相邻点对的LCA加入后去重，并再次排序

3：将第二次排序后的点依次入栈，若栈顶元素y非插入元素x的祖先则退栈，直到栈顶元素为x的祖先为止，链接x,y

 var head,vet,next,len,
     head1,vet1,next1,len1,
     h,stk,b,dep,dfn,flag,c,d:array[..]of longint;
     dp:array[..,..]of longint;
     size,g:array[..]of int64;
     f:array[..,..]of longint;
     n,i,tot,que,ans1,ans2,time,x,y:longint;
     ans:int64;

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

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

 function max(x,y:int64):int64;
 begin
  if x>y then exit(x);
  exit(y);
 end;

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

 procedure qsort1(l,r:longint);
 var i,j,mid:longint;
 begin
  i:=l; j:=r; mid:=b[(l+r)>>];
  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 qsort1(l,j);
  if i<r then qsort1(i,r);
 end;

 procedure qsort2(l,r:longint);
 var i,j,mid:longint;
 begin
  i:=l; j:=r; mid:=b[(l+r)>>];
  repeat
   while mid>b[i] do inc(i);
   while mid<b[j] do dec(j);
   if i<=j then
   begin
    swap(d[i],d[j]);
    swap(b[i],b[j]);
    inc(i); dec(j);
   end;
  until i>j;
  if l<j then qsort2(l,j);
  if i<r then qsort2(i,r);
 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:= to  do
   if d and (<<i)> then x:=f[x,i];
  for i:= downto  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,]);
 end;

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

 procedure add1(a,b:longint);
 begin
  if a=b then exit;
  inc(tot);
  next1[tot]:=head1[a];
  vet1[tot]:=b;
  len1[tot]:=abs(dep[a]-dep[b]);
  head1[a]:=tot;
 end;

 procedure dfs2(u:longint);
 var e,v:longint;
 begin
  size[u]:=c[u];
  g[u]:=;
  if c[u]= then begin dp[u,]:=; dp[u,]:=; end
   else begin dp[u,]:=-maxlongint div ; dp[u,]:=maxlongint div ; end;
  e:=head1[u];
  while e<> do
  begin
   v:=vet1[e];
   dfs2(v);
   ans:=ans+size[v]*g[u]+size[u]*g[v]+size[u]*size[v]*len1[e];
   size[u]:=size[u]+size[v];
   g[u]:=g[u]+g[v]+size[v]*len1[e];
   ans1:=max(ans1,dp[u,]+dp[v,]+len1[e]);
   ans2:=min(ans2,dp[u,]+dp[v,]+len1[e]);
   dp[u,]:=max(dp[u,],dp[v,]+len1[e]);
   dp[u,]:=min(dp[u,],dp[v,]+len1[e]);
   e:=next1[e];
  end;
  head1[u]:=;
 end;

 procedure solve;
 var q,top,i,now,m,p:longint;
 begin
  tot:=;
  read(m);
  for i:= to m do
  begin
   read(h[i]); b[i]:=dfn[h[i]];
   c[h[i]]:=;
  end;
  qsort1(,m);
  q:=;
  for i:= to m do
  begin
   inc(q); d[q]:=h[i]; flag[h[i]]:=;
  end;
  for i:= to m- do
  begin
   p:=lca(h[i],h[i+]);
   if flag[p]= then begin flag[p]:=; inc(q); d[q]:=p; end;
  end;
  for i:= to q do b[i]:=dfn[d[i]];
  qsort2(,q);

  stk[]:=d[]; top:=;
  for i:= to q do
  begin
   x:=d[i];
   while true do
   begin
    y:=stk[top];
    if lca(x,y)<>y then dec(top)
     else
     begin
      add1(y,x);
      break;
     end;
   end;
   inc(top); stk[top]:=x;
  end;

  ans:=; ans1:=-maxlongint div ; ans2:=maxlongint div ;
  dfs2(d[]);
  writeln(ans,' ',ans2,' ',ans1);
  for i:= to m do c[h[i]]:=;
  for i:= to q do flag[d[i]]:=;
 end;

 begin
  assign(input,'bzoj3611.in'); reset(input);
  assign(output,'bzoj3611.out'); rewrite(output);
  readln(n);
  for i:= to n- do
  begin
   readln(x,y);
   add(x,y,);
   add(y,x,);
  end;
  dfs();
  readln(que);
  fillchar(flag,sizeof(flag),);
  for i:= to que do solve;
  close(input);
  close(output);
 end.