bzoj 2286: [Sdoi2011]消耗战

Description

在一场战争中，战场由n个岛屿和n-1个桥梁组成，保证每两个岛屿间有且仅有一条路径可达。现在，我军已经侦查到敌军的总部在编号为1的岛屿，而且他们已经没有足够多的能源维系战斗，我军胜利在望。已知在其他k个岛屿上有丰富能源，为了防止敌军获取能源，我军的任务是炸毁一些桥梁，使得敌军不能到达任何能源丰富的岛屿。由于不同桥梁的材质和结构不同，所以炸毁不同的桥梁有不同的代价，我军希望在满足目标的同时使得总代价最小。

侦查部门还发现，敌军有一台神秘机器。即使我军切断所有能源之后，他们也可以用那台机器。机器产生的效果不仅仅会修复所有我军炸毁的桥梁，而且会重新随机资源分布（但可以保证的是，资源不会分布到1号岛屿上）。不过侦查部门还发现了这台机器只能够使用m次，所以我们只需要把每次任务完成即可。

Input

第一行一个整数n，代表岛屿数量。

接下来n-1行，每行三个整数u,v,w，代表u号岛屿和v号岛屿由一条代价为c的桥梁直接相连，保证1<=u,v<=n且1<=c<=100000。

第n+1行，一个整数m，代表敌方机器能使用的次数。

接下来m行，每行一个整数k_i，代表第i次后，有k_i个岛屿资源丰富，接下来k个整数h₁,h₂,…h_k，表示资源丰富岛屿的编号。

Output

输出有m行，分别代表每次任务的最小代价。

 

Sample Input

10
1 5 13
1 9 6
2 1 19
2 4 8
2 3 91
5 6 8
7 5 4
7 8 31
10 7 9
3
2 10 6
4 5 7 8 3
3 9 4 6

Sample Output

12
32
22

HINT

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

Source

Stage2 day2

学了一下虚树的创建

所谓虚树就是把所有用到的点和lca建出来的树

大概就是按照dfs访问顺序先把需要用到的点排序，然后求lca判断构造新树

实现方法看这里→http://www.cnblogs.com/chenhuan001/p/5639482.html

然后构造完虚树后就是一个很普通的树dp了

看当前虚树上的点是否为输入给定的点

如果是，那么dp[d]+=a[i].x;

否则的话dp[d]+=min(a[i].x,dp[t]);

#include<queue>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
using namespace std;
struct line
{
	int s,t;
	long long x;
	int next;
}a[500001],exa[500001];
int head[250001],exhead[250001];
int edge,exedge;
inline void add(int s,int t,long long x)
{
	a[edge].next=head[s];
	head[s]=edge;
	a[edge].s=s;
	a[edge].t=t;
	a[edge].x=x;
}
inline void exadd(int s,int t,long long x)
{
	exa[exedge].next=exhead[s];
	exhead[s]=exedge;
	exa[exedge].s=s;
	exa[exedge].t=t;
	exa[exedge].x=x;
}
bool v[500001];
int dep[500001];
int ans[500001][22];
long long anc[500001][22];
queue<int> Q;
inline void bfs(int r)
{
     memset(anc,127/3,sizeof(anc));
     int i,j;
     dep[r]=1;
     for(i=0;i<=21;i++)
          ans[r][i]=r;
     while(!Q.empty())
          Q.pop();
     Q.push(r);
     v[r]=true;
     while(!Q.empty())
     {
          int d=Q.front();
          Q.pop();
          for(i=head[d];i!=0;i=a[i].next)
          {
               int t=a[i].t;
               if(!v[t])
               {
                    v[t]=true;
                    Q.push(t);
                    dep[t]=dep[d]+1;
                    ans[t][0]=d;
                    anc[t][0]=a[i].x;
                    int dt;
					long long dc;
                    for(j=1;j<=21;j++)
                    {
                    	 dt=ans[t][j-1];
                    	 dc=anc[t][j-1];
                         ans[t][j]=ans[dt][j-1];
                         dc=min(dc,anc[dt][j-1]);
                         anc[t][j]=dc;
                    }
               }
          }
     }
}
long long ansx;
inline int swim(int x,int y)
{
	 int i=21; 
     while(dep[x]!=dep[y])
     {
          while(dep[ans[y][i]]<dep[x])
               i--;
          ansx=min(ansx,anc[y][i]);
          y=ans[y][i];
     }
     return y;
}
inline long long lca(int x,int y)
{
	 ansx=2100000000;
     if(dep[x]>dep[y])
     {
          int t=x;
          x=y;
          y=t;
     }
     y=swim(x,y);
     int i=21;
     while(x!=y)
     {
          while(ans[x][i]==ans[y][i]&&i!=0)
               i--;
          ansx=min(anc[x][i],ansx);
          ansx=min(anc[y][i],ansx);
          x=ans[x][i];
          y=ans[y][i];
     }
     return x;
}
int tot;
int ld[250001],rd[250001];
inline void dfs(int d)
{
	tot++;
	ld[d]=tot;
	v[d]=true;
	int i;
	for(i=head[d];i!=0;i=a[i].next)
	{
		int t=a[i].t;
		if(!v[t])
			dfs(t);
	}
	rd[d]=tot;
}
int poi[250001],stak[250001];
bool mark[250001],vx[250001];
inline bool cmp(int x,int y)
{
	return ld[x]<ld[y];
}
inline void create(int k)
{
	int i,j,lc;
	int top=0;
	top++;
	stak[top]=poi[1];
	exedge=0;
	exhead[1]=0;
	for(i=2;i<=k;i++)
	{
		lc=lca(stak[top],poi[i]);
		if(lc==stak[top])
		{
			exhead[poi[i]]=0;
			top++;
			stak[top]=poi[i];
		}
		else
		{
			int tmp=top;
			while(tmp>0&&dep[stak[tmp]]>dep[lc])
				tmp--;
			tmp++;
			for(j=tmp;j<=top-1;j++)
			{
				lca(stak[j],stak[j+1]);
				exedge++;
				exadd(stak[j],stak[j+1],ansx);
				exedge++;
				exadd(stak[j+1],stak[j],ansx);
			}
			int pretmp=stak[tmp];
			if(tmp==0)
			{
				exhead[lc]=0;
				top=1;
				stak[top]=lc;
			}
			else if(stak[tmp-1]!=lc)
			{
				exhead[lc]=0;
			//	tmp++;
				stak[tmp]=lc;
				top=tmp;
			}
			else
				top=tmp-1;
			lca(pretmp,lc);
			exedge++;
			exadd(pretmp,lc,ansx);
			exedge++;
			exadd(lc,pretmp,ansx);
			exhead[poi[i]]=0;
			top++;
			stak[top]=poi[i];
		}
	}
	for(i=1;i<=top-1;i++)
	{
		lca(stak[i],stak[i+1]);
		exedge++;
		exadd(stak[i],stak[i+1],ansx);
		exedge++;
		exadd(stak[i+1],stak[i],ansx);
	}
}
long long f[250001];
inline void trdp(int d)
{
	Q.push(d);
	f[d]=0;
	v[d]=true;
	bool flag=false;
	int i;
	for(i=exhead[d];i!=0;i=exa[i].next)
	{
		int t=exa[i].t;
		if(!v[t])
		{
			flag=true;
			trdp(t);
			if(mark[t])
				f[d]+=exa[i].x;
			else
				f[d]+=min(exa[i].x,f[t]);
		}
	}
	if(!flag)
		f[d]=100000000LL*100000000LL;
}
int main()
{
//	freopen("data.in","r",stdin); 
//	freopen("data.out","w",stdout);
	int n;
	scanf("%d",&n);
	int i,j;
	int s,t;
	long long x;
	for(i=1;i<=n-1;i++)
	{
		scanf("%d%d%lld",&s,&t,&x);
		edge++;
		add(s,t,x);
		edge++;
		add(t,s,x);
	}
	bfs(1);
	memset(v,false,sizeof(v));
	dfs(1);
	int m,k;
	scanf("%d",&m);
	memset(f,0,sizeof(f));
	memset(v,false,sizeof(v));
	memset(vx,false,sizeof(vx));
	memset(mark,0,sizeof(mark));
	for(i=1;i<=m;i++)
	{
		scanf("%d",&k);
		k++;
		poi[1]=1;
		for(j=2;j<=k;j++)
		{
			scanf("%d",&poi[j]);
			mark[poi[j]]=1;
		}
		sort(poi+1,poi+1+k,cmp);
		create(k);
		trdp(1);
		printf("%lld\n",f[1]);
		
		while(!Q.empty())
		{
			v[Q.front()]=false;
			Q.pop();
		}
		for(j=2;j<=k;j++)
			mark[poi[j]]=0;
	}
	return 0;
}