bzoj 2286: [Sdoi2011消耗战 （虚树+树形DP）

最新推荐文章于 2019-06-07 08:13:00 发布
最新推荐文章于 2019-06-07 08:13:00 发布
阅读量354 收藏 1
点赞数
分类专栏： 动态规划 虚树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clover_hxy/article/details/61614735
版权

2286: [Sdoi2011消耗战

Time Limit: 20 Sec  Memory Limit: 512 MB
Submit: 2881  Solved: 1033
[ Submit][ Status][ Discuss]

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行，每行一个整数ki，代表第i次后，有ki个岛屿资源丰富，接下来k个整数h1,h2,…hk，表示资源丰富岛屿的编号。

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

[ Submit][ Status][ Discuss]

题解：虚树+树形DP

构建过程如下:

按照原树的dfs序递增顺序遍历选择的节点. 每次遍历节点都把这个节点插到树上.

首先虚树一定要有一个根.一般强制1号点（或者原树的根节点）为虚树的根.

维护一个栈,它表示在我们已经(用之前的那些点)构建完毕的虚树上,以最后一个插入的点为端点的DFS链.

设最后插入的点为p(就是栈顶的点),当前遍历到的点为x.我们想把x插入到我们已经构建的树上去.

求出lca(p,x),记为lca.有两种情况:

　　1.p和x分立在lca的两棵子树下.

　　2.lca是p.

对于第二种情况,直接在栈中插入节点x即可,不要连接任何边.

对于第一种情况,要仔细分析.

我们是按照dfs序号遍历的，所以dfn(x)>dfn(p)>dfn(lca).

这说明什么呢? 说明一件很重要的事:我们已经把lca所引领的子树中,p所在的子树全部遍历完了!

这样,我们就直接构建lca引领的,p所在的那个子树. 我们在退栈的时候构建子树.

p所在的子树如果还有其它部分,它一定在之前就构建好了(所有退栈的点都已经被正确地连入树中了),就剩那条链.

如何正确地把p到lca那部分连进去呢?

设栈顶的节点为p,栈顶第二个节点为q.

重复以下操作:

如果dfn(q)>dfn(lca),可以直接连边q->p,然后退一次栈.

如果dfn(q)=dfn(lca),说明q=lca,直接连边lca->p,此时子树已经构建完毕.

如果dfn(q)<dfn(lca),说明lca被p与q夹在中间,此时连边lca->q,退一次栈,再把lca压入栈.此时子树构建完毕.

最后,为了维护dfs链,要把x压入栈. 

剩下的就是树形DP的锅了。f[i]表示子树中的所有关键点(题目中给出的点)全部割断的最小代价，如果这个点是给出的点，那么他上面的边一定会被割断，并且子树中的其他点都不必再割，如果不是关键点就对上面的边和所有儿子的代价和取min

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define N 500003
using namespace std;
typedef long long LL;
const LL inf=10000000000000LL;
int tot,nxt[N],point[N],v[N],c[N],deep[N],fa[N][20],mi[20];
int n,m,k,top,st[N],a[N],pos[N],sz;
LL f[N],mn[N];
void add(int x,int y,int z)
{
	tot++; nxt[tot]=point[x]; point[x]=tot; v[tot]=y; c[tot]=z;
	tot++; nxt[tot]=point[y]; point[y]=tot; v[tot]=x; c[tot]=z;
}
void dfs(int x,int f)
{
	pos[x]=++sz; deep[x]=deep[f]+1;
	for (int i=1;i<=19;i++) {
		if (deep[x]-mi[i]<0) break;
		fa[x][i]=fa[fa[x][i-1]][i-1];
	}
	for (int i=point[x];i;i=nxt[i]) {
		if (v[i]==f) continue;
		mn[v[i]]=min(mn[x],(LL)c[i]);
		fa[v[i]][0]=x;
		dfs(v[i],x);
	}
}
int lca(int x,int y)
{
	if (deep[x]<deep[y]) swap(x,y); 
	int k=deep[x]-deep[y];
	for (int i=0;i<=19;i++)
	 if ((k>>i)&1) x=fa[x][i];
	if (x==y) return x;
	for (int i=19;i>=0;i--) 
	 if (fa[x][i]!=fa[y][i]) {
	 	x=fa[x][i]; 
	 	y=fa[y][i];
	 }
	return fa[x][0];
}
void build(int x,int y)
{
	if (x==y) return;
	tot++; nxt[tot]=point[x]; point[x]=tot; v[tot]=y;
}
void dp(int x)
{
	f[x]=mn[x];
	LL sum=0;
	for (int i=point[x];i;i=nxt[i]){
		dp(v[i]);
		sum+=f[v[i]];
	}
	point[x]=0;
	if (sum) f[x]=min(f[x],sum);
}
int cmp(int x,int y)
{
	return pos[x]<pos[y];
}
void solve()
{
	scanf("%d",&k);
	for (int i=1;i<=k;i++) scanf("%d",&a[i]);
	sort(a+1,a+k+1,cmp);
	int cnt=0;
	a[++cnt]=a[1];
	for (int i=2;i<=k;i++)
	 if (lca(a[cnt],a[i])!=a[cnt]) a[++cnt]=a[i];
	k=cnt;
	top=0; st[++top]=1; tot=0;
	for (int i=1;i<=k;i++) {
		int now=a[i]; int f=lca(st[top],now);
		while (true) {
			if (deep[f]>=deep[st[top-1]]) {
				build(f,st[top--]);
				if (f!=st[top]) st[++top]=f;
				break;
			}
		    build(st[top-1],st[top]); top--;
		}
		if (st[top]!=now) st[++top]=now; 
	}
	while (top-1) build(st[top-1],st[top]),top--;
	dp(1);
	printf("%lld\n",f[1]);
}
int main()
{
	freopen("a.in","r",stdin);
	scanf("%d",&n);
	for (int i=1;i<n;i++) {
		int x,y,z; scanf("%d%d%d",&x,&y,&z);
		add(x,y,z);
	}
	mi[0]=1; 
	for (int i=1;i<=19;i++) mi[i]=mi[i-1]*2; 
	mn[1]=inf; dfs(1,0);
	scanf("%d",&m);
	memset(point,0,sizeof(point));
	memset(nxt,0,sizeof(nxt));
	for (int i=1;i<=m;i++) solve();
}

版本2： 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define N 500003
using namespace std;
typedef long long LL;
const LL inf=10000000000000LL;
int tot,nxt[N],point[N],v[N],deep[N],fa[N][20],mi[20];
int n,m,k,top,st[N],a[N],pos[N],sz;
LL f[N],mn[N],c[N],len[N][20];
void add(int x,int y,int z)
{
	tot++; nxt[tot]=point[x]; point[x]=tot; v[tot]=y; c[tot]=z;
	tot++; nxt[tot]=point[y]; point[y]=tot; v[tot]=x; c[tot]=z;
}
void dfs(int x,int f)
{
	pos[x]=++sz; deep[x]=deep[f]+1;
	for (int i=1;i<=19;i++) {
		if (deep[x]-mi[i]<0) break;
		fa[x][i]=fa[fa[x][i-1]][i-1];
		len[x][i]=min(len[x][i-1],len[fa[x][i-1]][i-1]);
	}
	for (int i=point[x];i;i=nxt[i]) {
		if (v[i]==f) continue;
		mn[v[i]]=min(mn[x],(LL)c[i]);
		fa[v[i]][0]=x; len[v[i]][0]=c[i];
		dfs(v[i],x);
	}
}
int lca(int x,int y)
{
	if (deep[x]<deep[y]) swap(x,y); 
	int k=deep[x]-deep[y];
	for (int i=0;i<=19;i++)
	 if ((k>>i)&1) x=fa[x][i];
	if (x==y) return x;
	for (int i=19;i>=0;i--) 
	 if (fa[x][i]!=fa[y][i]) {
	 	x=fa[x][i]; 
	 	y=fa[y][i];
	 }
	return fa[x][0];
}
LL getlen(int x,int y)
{
	if (deep[x]<deep[y]) swap(x,y); 
	int k=deep[x]-deep[y]; LL l=inf;
	for (int i=0;i<=19;i++)
	 if ((k>>i)&1) l=min(l,len[x][i]),x=fa[x][i];
	if (x==y) return l;
	for (int i=19;i>=0;i--) 
	 if (fa[x][i]!=fa[y][i]) {
	 	l=min(l,len[x][i]),x=fa[x][i]; 
	 	l=min(l,len[y][i]),y=fa[y][i];
	 }
	l=min(l,len[x][0]); l=min(l,len[y][0]);
	return l;
}
void build(int x,int y)
{
	if (x==y) return;
	LL t=getlen(x,y);
	tot++; nxt[tot]=point[x]; point[x]=tot; v[tot]=y; c[tot]=t;
//	cout<<x<<" "<<y<<" "<<t<<endl;
}
void dp(int x,LL mn)
{
	f[x]=mn;
	LL sum=0;
	for (int i=point[x];i;i=nxt[i]){
		dp(v[i],c[i]);
		sum+=f[v[i]];
	}
	point[x]=0;
	if (sum) f[x]=min(f[x],sum);
}
int cmp(int x,int y)
{
	return pos[x]<pos[y];
}
void solve()
{
	scanf("%d",&k);
	for (int i=1;i<=k;i++) scanf("%d",&a[i]);
	sort(a+1,a+k+1,cmp);
	int cnt=0;
	a[++cnt]=a[1];
	for (int i=2;i<=k;i++)
	 if (lca(a[cnt],a[i])!=a[cnt]) a[++cnt]=a[i];
	k=cnt;
	top=0; st[++top]=1; tot=0;
	for (int i=1;i<=k;i++) {
		int now=a[i]; int f=lca(st[top],now);
		while (true) {
			if (deep[f]>=deep[st[top-1]]) {
				build(f,st[top--]);
				if (f!=st[top]) st[++top]=f;
				break;
			}
		    build(st[top-1],st[top]); top--;
		}
		if (st[top]!=now) st[++top]=now; 
	}
	while (top-1) build(st[top-1],st[top]),top--;
	dp(1,inf);
	printf("%lld\n",f[1]);
}
int main()
{
	freopen("a.in","r",stdin);
	scanf("%d",&n);
	for (int i=1;i<n;i++) {
		int x,y,z; scanf("%d%d%d",&x,&y,&z);
		add(x,y,z);
	}
	mi[0]=1; 
	for (int i=1;i<=19;i++) mi[i]=mi[i-1]*2; 
	memset(len,127,sizeof(len));
	mn[1]=inf; dfs(1,0);
	scanf("%d",&m);
	memset(point,0,sizeof(point));
	memset(nxt,0,sizeof(nxt));
	for (int i=1;i<=m;i++) solve();
}



clover_hxy
关注
专栏目录
bzoj 3879: SvT 后缀自动机+虚树+树形dp
beginend
11-09 525
题意有一个长度为n的仅包含小写字母的字符串S,下标范围为[1,n]. 现在有若干组询问,对于每一个询问,我们给出若干个后缀(以其在S中出现的起始位置来表示),求这些后缀两两之间的LCP(LongestCommonPrefix)的长度之和.一对后缀之间的LCP长度仅统计一遍. 有S<=5*10^5,且Σt<=3*10^6.分析我们把S反过来后建后缀自动机，就转换成了求两两前缀的lcs。显然两个前缀
bzoj 4818: [Sdoi2017]序列计数 动态规划+矩阵乘法
beginend
04-11 1716
题意Alice想要得到一个长度为nn的序列，序列中的数都是不超过mm的正整数，而且这nn个数的和是pp的倍数。 Alice还希望，这nn个数中，至少有一个数是质数。 Alice想知道，有多少个序列满足她的要求。 对100%100\%的数据，1≤n≤109,1≤m≤2×107,1≤p≤1001\leq n \leq 10^9,1\leq m \leq 2×10^7,1\leq p\leq 100
bzoj 2286: [Sdoi2011消耗战 虚树+树形dp
beginend
12-14 479
题意在一场战争中，战场由n个岛屿和n-1个桥梁组成，保证每两个岛屿间有且仅有一条路径可达。现在，我军已经侦查到敌军的总部在编号为1的岛屿，而且他们已经没有足够多的能源维系战斗，我军胜利在望。已知在其他k个岛屿上有丰富能源，为了防止敌军获取能源，我军的任务是炸毁一些桥梁，使得敌军不能到达任何能源丰富的岛屿。由于不同桥梁的材质和结构不同，所以炸毁不同的桥梁有不同的代价，我军希望在满足目标的同时使得总代价
bzoj2286消耗战 虚树+树型动规
maxtir的博客
08-28 322
2286: [Sdoi2011]消耗战 Time Limit: 20 Sec  Memory Limit: 512 MB Submit: 3772  Solved: 1357 [Submit][Status][Discuss] Description 在一场战争中，战场由n个岛屿和n-1个桥梁组成，保证每两个岛屿间有且仅有一条路径可达。现在，我军已经侦查到敌军的总部在编号为1的岛屿，
消耗战
liankewei的博客
04-05 192
消耗战 在一场战争中，战场由 $n$ 个岛屿和 $n-1$ 个桥梁组成，保证每两个岛屿间有且仅有一条路径可达。现在，我军已经侦查到敌军的总部在编号为 $1$ 的岛屿，而且他们已经没有足够多的能源维系战斗，我军胜利在望。已知在其他 $k$ 个岛屿上有丰富能源，为了防止敌军获取能源，我军的任务是炸毁一些桥梁，使得敌军不能到达任何能源丰富的岛屿。由于不同...
BZOJ2286：消耗战（虚树 & 树形dp）
junior19的博客
01-19 258
在一场战争中，战场由n个岛屿和n-1个桥梁组成，保证每两个岛屿间有且仅有一条路径可达。现在，我军已经侦查到敌军的总部在编号为1的岛屿，而且他们已经没有足够多的能源维系战斗，我军胜利在望。已知在其他k个岛屿上有丰富能源，为了防止敌军获取能源，我军的任务是炸毁一些桥梁，使得敌军不能到达任何能源丰富的岛屿。由于不同桥梁的材质和结构不同，所以炸毁不同的桥梁有不同的代价，我军希望在满足目标的同时使得总代价最
[洛谷P2459] SDOI2011 消耗战
weixin_30877755的博客
06-07 88
问题描述 在一场战争中，战场由n个岛屿和n-1个桥梁组成，保证每两个岛屿间有且仅有一条路径可达。现在，我军已经侦查到敌军的总部在编号为1的岛屿，而且他们已经没有足够多的能源维系战斗，我军胜利在望。已知在其他k个岛屿上有丰富能源，为了防止敌军获取能源，我军的任务是炸毁一些桥梁，使得敌军不能到达任何能源丰富的岛屿。由于不同桥梁的材质和结构不同，所以炸毁不同的桥梁有不同的代价，我军希望在满足目标的同时使...
BZOJ2282: [Sdoi2011]消防（洛谷P2491）
forezxl的博客
02-25 438
树的直径 二分答案 BZOJ题目传送门 洛谷题目传送门 这道题和树网的核数据加强版很像啊 首先，在不考虑路径长度的情况下，最优的路径就应该在树的直径上，答案就是离树的直径最远的点到直径的距离。 因此，YY一下，这道题的路径也应该造在直径上。（因为我太菜所以严格证明我并不会） 那么我们只要把直径找出来，再以离树的直径最远的点到直径的距离为l，树的直径的长度为r二分答案即可。 具体实现见...
【BZOJ2282】【Sdoi2011】消防 树的直径+双指针+单调队列 有一系列乱七八糟的证明
辗转山河弋流歌
03-25 2387
题解： 首先表示这个代码是线性的，是怎么构造数据也卡不住的！ 而网上普遍流行的那个二分的是基于直径长度dd的O(dlog2d)O(dlog_2 d)算法，一旦直径长点，然后数据范围大点，它就挂啦！诶我什么心态啊。 算法： 首先答案路径一定在某直径上[证明1，见文末]，然后我们求出这个直径序列（任一直径即可[证明2，见文末]）， 处理出一些数组： fif_i表示i是路径左端点时直径上
bzoj4712: 洪水 动态Dp 树链剖分+线段树 或 LCT维护矩阵乘法
maxtir的博客
07-22 527
bzoj4712: 洪水 Description 小A走到一个山脚下，准备给自己造一个小屋。这时候，小A的朋友（op，又叫管理员）打开了创造模式，然后飞到 山顶放了格水。于是小A面前出现了一个瀑布。作为平民的小A只好老实巴交地爬山堵水。那么问题来了：我们把这 个瀑布看成是一个n个节点的树，每个节点有权值（爬上去的代价）。小A要选择一些节点，以其权值和作为代价将 这些点删除（堵上），使得根...
BZOJ2286 [Sdoi2011]消耗战 【虚树 + 树形Dp】
weixin_30682127的博客
12-16 100
2286: [Sdoi2011]消耗战 Time Limit:20 SecMemory Limit:512 MB Submit:4261Solved:1552 [Submit][Status][Discuss] Description 在一场战争中，战场由n个岛屿和n-1个桥梁组成，保证每两个岛屿间有且仅有一条路径可达。现在，我军已经侦查到敌军的总部在编号为1的岛屿，而且...
bzoj-2286 消耗战【虚树+倍增lca+单调栈】
a915800048的专栏
05-10 1746
2286: [Sdoi2011消耗战 Time Limit: 20 Sec  Memory Limit: 512 MB Submit: 1815  Solved: 645 [Submit][Status][Discuss] Description 在一场战争中，战场由n个岛屿和n-1个桥梁组成，保证每两个岛屿间有且仅有一条路径可达。现在，我军已经侦查到敌军的总部在编号为1的岛屿，而且
[bzoj2286] [洛谷P2495] [sdoi2015] 消耗战
weixin_30426879的博客
05-22 100
Description 在一场战争中，战场由 \(n\) 个岛屿和 \(n-1\) 个桥梁组成，保证每两个岛屿间有且仅有一条路径可达。现在，我军已经侦查到敌军的总部在编号为1的岛屿，而且他们已经没有足够多的能源维系战斗，我军胜利在望。已知在其他 \(k\) 个岛屿上有丰富能源，为了防止敌军获取能源，我军的任务是炸毁一些桥梁，使得敌军不能到达任何能源丰富的岛屿。由于不同桥梁的材质和结构不同，所以炸毁...
[bzoj2286][Sdoi2011]消耗战——虚树入门例题
ylsoi的博客
10-16 223
题目大意： 在一场战争中，战场由n个岛屿和n-1个桥梁组成，保证每两个岛屿间有且仅有一条路径可达。现在，我军已经侦查到敌军的总部在编号为1的岛屿，而且他们已经没有足够多的能源维系战斗，我军胜利在望。已知在其他k个岛屿上有丰富能源，为了防止敌军获取能源，我军的任务是炸毁一些桥梁，使得敌军不能到达任何能源丰富的岛屿。由于不同桥梁的材质和结构不同，所以炸毁不同的桥梁有不同的代价，我军希望在满足目标的同时...
SDOI2017 Round2 滚粗记
clover_hxy的博客
05-24 1545
其实SD二轮已经过去快一个星期了，一直不知道该怎么开始这次游记，所以拖到现在。。。DAY0从学校坐车去济南，发现跟一轮没什么区别，就是人少了一半。 和ATP坐在一起搞事情，zyf2000不舒服所以自己走了。 到颐正大厦后，跟lx住在一起，lx开开心心的出去找同学玩去了，自己叫了一份焗饭就下去领密码条。有了第一次挑密码条的教训，这次决定直接站着等，不一会密码条就到手了，结果发现和Yveh连座。╮(
weixin121作品集展示微信小程序+ssm.rar
09-13
所有源码，都可正常运行
weixin090体育资讯软件的实现+ssm.rar
09-13
所有源码，都是可以运行起来的
基于java的财务管理系统设计与实现.docx
09-13
基于java的财务管理系统设计与实现.docx
吕嘉诚_训练班表.pdf
最新发布
09-13
吕嘉诚_训练班表.pdf
树形动态规划详解：二叉苹果树问题与策略
"树形动态规划是一种特殊的动态规划方法，主要应用于解决在树状结构上具有最优子结构的问题，包括计数问题、存在性问题和某些最优性问题。该PDF文件深入讲解了树形动态规划的基础概念、递归关系及其实现策略。 在树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值