BZOJ2286消耗战题解（树上倍增+虚树+树形DP）

题目：BZOJ2286.
题目大意：给定一棵$n$个点的树，并给出若干次询问.每次询问给出$k$个点，现在要求切断一些边使得$1$号点无法达到给出的$k$个点，询问切断边的最小边权和.
$1\le n\le 2.5\ast 10^5,1\le \sum k\le 5\ast 10^5$.

对每次询问大力建出虚树，虚树边权为原来这条边代表的链上的边权最小值，用树上倍增即可处理.

现在我们设$f[i]$表示以点$i$为根的子树中，让所有给出点不能到达点$i$的最小边权和，直接树形DP即可.

时间复杂度$O((n+\sum k)\log n)$.

代码如下：

#include<bits/stdc++.h>
using namespace std;

typedef long long LL;

const int N=1000000,C=20,INF=(1<<30)-1;

int n;
struct side{
  int y,next,v;
}e[N*2+9];
int lin[2][N+9],cs;

void Ins(int id,int x,int y,int v){e[++cs].y=y;e[cs].v=v;e[cs].next=lin[id][x];lin[id][x]=cs;}
void Ins2(int id,int x,int y,int v){Ins(id,x,y,v);Ins(id,y,x,v);}

void into(){
  scanf("%d",&n);
  for (int i=1;i<n;++i){
	int x,y,v;
	scanf("%d%d%d",&x,&y,&v);
	Ins2(0,x,y,v);
  }
}

int dep[N+9],gr[N+9][C],mn[N+9][C];
int dfs[N+9],co;

void Dfs_gr(int k,int fa){
  dep[k]=dep[fa]+1;
  dfs[k]=++co;
  for (int i=1;i<C;++i){
	gr[k][i]=gr[gr[k][i-1]][i-1];
	mn[k][i]=min(mn[k][i-1],mn[gr[k][i-1]][i-1]);
  }
  for (int i=lin[0][k];i;i=e[i].next)
	if (e[i].y^fa){
	  gr[e[i].y][0]=k;
	  mn[e[i].y][0]=e[i].v;
	  Dfs_gr(e[i].y,k);
	}
}

int Query_lca(int x,int y){
  if (dep[x]<dep[y]) swap(x,y);
  for (int i=C-1;i>=0;--i)
	if (dep[gr[x][i]]>=dep[y]) x=gr[x][i];
  if (x==y) return x;
  for (int i=C-1;i>=0;--i)
	if (gr[x][i]^gr[y][i]) x=gr[x][i],y=gr[y][i];
  return gr[x][0];
}

int Query_min(int x,int anc){
  int t=dep[x]-dep[anc],res=INF;
  for (int i=0;i<C;++i)
	if (t>>i&1) res=min(res,mn[x][i]),x=gr[x][i];
  return res;
}

void work(){
  Dfs_gr(1,0);
}

int ca,a[N+9],lca[N+9],tag[N+9];
int sta[N+9],cst;

bool cmp(const int &a,const int &b){return dfs[a]<dfs[b];}

void Build(){
  sort(a+1,a+ca+1,cmp);
  sta[cst=1]=a[0]=1;
  for (int i=1;i<=ca;++i){
	lca[i]=Query_lca(a[i],a[i-1]);
	lin[1][a[i]]=lin[1][lca[i]]=tag[lca[i]]=0;
  }
  for (int i=1;i<=ca;++i) tag[a[i]]=1;
  for (int i=1;i<=ca;++i){
	for (;cst>1&&dep[lca[i]]<dep[sta[cst-1]];--cst)
	  Ins(1,sta[cst-1],sta[cst],Query_min(sta[cst],sta[cst-1]));
    if (lca[i]^sta[cst]){
	  Ins(1,lca[i],sta[cst],Query_min(sta[cst],lca[i]));
	  if (lca[i]^sta[--cst]) sta[++cst]=lca[i];
	}
	if (a[i]^sta[cst]) sta[++cst]=a[i];
  }
  for (;cst>1;--cst) Ins(1,sta[cst-1],sta[cst],Query_min(sta[cst],sta[cst-1]));
}

LL dp[N+9];

void Dfs_dp(int k){
  dp[k]=0;
  for (int i=lin[1][k];i;i=e[i].next){
	Dfs_dp(e[i].y);
	dp[k]+=tag[e[i].y]?e[i].v:min(dp[e[i].y],(LL)e[i].v);
  }
}

void outo(){
  int cq,last=cs;
  scanf("%d",&cq);
  for (;cq--;){
	scanf("%d",&ca);
	for (int i=1;i<=ca;++i)
	  scanf("%d",&a[i]);
    cs=last;
    Build();
	Dfs_dp(1);
	printf("%lld\n",dp[1]);
  }
}

int main(){
  into();
  work();
  outo();
  return 0;
}