bzoj-2286 消耗战【虚树+倍增lca+单调栈】

2286: [Sdoi2011消耗战

Time Limit: 20 Sec  Memory Limit: 512 MB

Submit: 1815  Solved: 645

[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

对于每次查询,如果用一次树型dp就能得出结果。

dp方程:

f[father]+=fmin(g[son]?inf:f[son],(min_e(son,father));(g[i]标记是否是关键点)

这个时间效率很直观O(m*n)

每次查询,我们只需要遍历关键点与关键点之间的lca,其它点时可忽略的或可跳跃的。

那么就需要用到虚树的技巧了,虚树就是通过维护一个单调栈把树的关键点和它们之间的lca按照dfs序遍历一遍,遍历的过程中通过单调栈的调整来理清树的父亲和儿子之间的关系。

首先,对树节点进行dfs。在期间对节点进行标号dfn。

然后,维护一个单调栈。这个单调栈的节点都在一条链上。

对于栈顶元素 p,栈次顶元素 q, 即将插入节点x 有如下关系:

1.lca是p.此时dfn(x)>dfn(p)=dfn(lca)

这说明 x在p的下面,直接把x入栈即可

2.p和x分立在lca的两棵子树下.此时 dfn(x)>dfn(p)>dfn(ilca)

这时候就有三种讨论了

针对这道题的连边就是树型dp处理

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

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

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

重复判断上述过程

这里处理  min_e(p,q) p到q的路径中权值最小的边。需要用倍增lca或者树剖也是可以的。这个参见《挑战程序设计竞赛》吧,改改代码就可以了

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <vector>
#include <algorithm>
#define find_min(a,b) a>b?b:a
#define MAX_V 250008
#define MAX_LOG_V 21
#define INF 0x3f3f3f3f
#define inf (1ll<<40)
using namespace std;
typedef long long int ll;
struct edge{
	int to,cost;
};
vector<edge> G[MAX_V];
int par[MAX_LOG_V][MAX_V];//v节点向上走2^k步走到的节点
int mng[MAX_LOG_V][MAX_V];//v节点向上走2^k步中路过最小的边
int dfn[MAX_V];//每个点的dfs序标号
int dep[MAX_V];//深度
ll f[MAX_V];//树型dp
struct node{
	int h,dfn;
}hs[MAX_V];
bool g[MAX_V];//是否是关键点
int sta[MAX_V*2];// 模拟栈
int icnt;//栈顶 、id
int swap(int &x,int &y)
{//交换
	x=x^y;y=x^y,x=x^y;
}
//当前点、父亲节点 、深度、连接父亲点的边权
void dfs(int v,int p,int d,int pre_e)
{//lca搜索预处理
	par[0][v]=p,dep[v]=d,mng[0][v]=pre_e,dfn[v]=icnt++;
	for(int i=0;i<G[v].size();++i)
		if(G[v][i].to!=p)
			dfs(G[v][i].to,v,d+1,G[v][i].cost);
}
void init_tree()
{//预处理lca查询
	icnt=0;//id初始化为0
	dfs(1,-1,0,INF);
	for(int k=0;k+1<MAX_LOG_V;++k)
		for(int v=1;v<=MAX_V;++v)
		{
			if(par[k][v]<0)//超过树根
				par[k+1][v]=-1,mng[k+1][v]=INF;
			else
			{//能前进 2^(k+1)步
				int u=par[k][v];
				par[k+1][v]=par[k][u];
				mng[k+1][v]=find_min(mng[k][v],mng[k][u]);
			}
		}
}
int lca(int u,int v)
{
	if(dep[u]>dep[v]) swap(u,v);
	//先到同一深度
	for(int k=0;k<MAX_LOG_V;++k)
		if((dep[v]-dep[u])>>k & 1)
			v=par[k][v];
	if(u==v) return u;
	//同时向上 二分查询
	for(int k=MAX_LOG_V-1;k>=0;--k)
		if(par[k][u]!=par[k][v])
			u=par[k][u],v=par[k][v];
	return par[0][u];
}
int min_e(int u,int v)
{
	int ilca=lca(u,v);
	int res=INF;
	//u->lca
	int mov;
	if(dep[ilca]<dep[u])
	{
		mov=dep[u]-dep[ilca];
		for(int k=0;k<MAX_LOG_V;++k)
			if(mov>>k &1)
				res=find_min(res,mng[k][u]),u=par[k][u];
	}
	//v->lca
	if(dep[ilca]<dep[v])
	{
		mov=dep[v]-dep[ilca];
		for(int k=0;k<MAX_LOG_V;++k)
			if(mov>>k &1)
				res=find_min(res,mng[k][v]),v=par[k][v];
	}
	return res;
}
void add_edge(int u,int v,int c)
{
	G[u].push_back((edge){v,c});
	G[v].push_back((edge){u,c});
}
void init()
{//初始化边数置0
	for(int i=0;i<MAX_V;++i)
		G[i].clear();
}
int cmp(const void *a,const void *b)
{
	return ((node *)a)->dfn-((node *)b)->dfn;
}
ll fmin(ll a,ll b)
{
	return a>b?b:a;
}
void solve(int k)
{
	for(int i=1;i<=k;++i)
	{
		int o=hs[i].h;
		hs[i].dfn=dfn[o];//同步搜索序id
	}
	qsort(hs+1,k,sizeof(hs[0]),cmp);
	int tp=0;
	sta[tp]=0;
	sta[++tp]=1;
	f[1]=0,g[1]=0;
	for(int i=1;i<=k;++i)
	{
		int p=sta[tp],q=sta[tp-1],x=hs[i].h;
		int ilca=lca(p,x);
		while(dfn[p]>dfn[ilca])
		{
			if(dfn[q]<=dfn[ilca])
			{
				int tmp=fmin(g[tp]?inf:f[tp],(ll)min_e(p,ilca));
				sta[tp--]=0;
				if(ilca!=q)
					sta[++tp]=ilca,f[tp]=0,g[tp]=0;
				f[tp]+=tmp;
				break;
			}
			else
			{
				f[tp-1]+=fmin(g[tp]?inf:f[tp],(ll)min_e(p,q));
				sta[tp--]=0;

			}
			p=sta[tp],q=sta[tp-1];
		}
		if(sta[tp]!=x)
			sta[++tp]=x,f[tp]=0;
		g[tp]=1;
	}
	while(tp>1)
	{
		int p=sta[tp],q=sta[tp-1];
		f[tp-1]+=fmin(g[tp]?inf:f[tp],(ll)min_e(p,q));
		sta[tp--]=0;

	}
	printf("%lld\n",f[tp--]);
}
int main()
{
	int n;
	while(~scanf("%d",&n))
	{
		init();
		int u,v,w;
		for(int i=0;i<n-1;++i)
		{
			scanf("%d%d%d",&u,&v,&w);
			add_edge(u,v,w);
		}
		init_tree();
		int m,k,h;
		scanf("%d",&m);
		while(m--)
		{
			scanf("%d",&k);
			for(int i=1;i<=k;++i)
				scanf("%d",&hs[i].h);
			solve(k);
		}
	}
	return 0;
}
时间: 2024-11-05 11:42:17

bzoj-2286 消耗战【虚树+倍增lca+单调栈】的相关文章

BZOJ 2286 消耗战 (虚树+树形DP)

给出一个n节点的无向树,每条边都有一个边权,给出m个询问,每个询问询问ki个点,问切掉一些边后使得这些顶点无法与顶点1连接.最少的边权和是多少.(n<=250000,sigma(ki)<=500000) 考虑树形DP,我们令mn[i]表示i节点无法与1节点相连切除的最小权值.显然有mn[i]=min(E(fa,i),mn[fa]).大致就是i到1的简单路径上的最小边.我们对于每个询问.把询问的点不妨称为关键点.令dp[i]表示i节点不能与子树的关键点连接切掉的最小权值.那么有,如果son[i]

BZOJ 3611 HEOI2014 大工程 倍增LCA+单调栈+树形DP

题目大意:给定一棵树,m次询问,每次给出k个关键点,询问这k个点之间的两两距离和.最小距离和最大距离 n<=100W,m<=50000,Σk<=2*n 处理方法同2286 消耗战 地址见 http://blog.csdn.net/popoqqq/article/details/42493725 这个题的DP有些麻烦 因此我把要处理的节点单独拎出来做的DP 具体状态和转移见代码 #include <cstdio> #include <cstring> #includ

BZOJ 2286 SDOI2011 消耗战 倍增LCA+单调栈

题目大意:给定一棵树,边上有边权,m次询问,每次选定一些关键点,求将1号节点与所有关键点都切断所需的最小花销 关键点的总数<=50W 首先我们考虑暴力想法 令f[x]表示切断以x为根的子树中所有关键点的最小花销 g[x]表示x是不是关键点 那么对于x的每个子节点y有f[x]=Σmin(g[y]?INF:f[y],Distance(x,y) ) 这样每次暴力做一遍树形DP,时间复杂度是O(n*m)的 现在由于每次询问的点数不一定会达到n的级别,对所有节点进行DFS非常浪费 我们可以将询问的关键点拿

[SDOI2011][BZOJ2286] 消耗战|虚树|树型dp|树上倍增LCA

2286: [Sdoi2011]消耗战 Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 1040  Solved: 363[Submit][Status][Discuss] Description 在一场战争中,战场由n个岛屿和n-1个桥梁组成,保证每两个岛屿间有且仅有一条路径可达.现在,我军已经侦查到敌军的总部在编号为1的岛屿,而且他们已经没有足够多的能源维系战斗,我军胜利在望.已知在其他k个岛屿上有丰富能源,为了防止敌军获取能源,我军的任务是炸

BZOJ 3123 SDOI2013 森林 可持久化线段树+倍增LCA+启发式合并

题目大意:给定一棵森林,每个点有权值,提供两种操作: 1.查询两点间路径上第k小的权值 2.将两个点之间连一条边 保证连接后仍是一座森林 可持久化线段树部分同Count On A Tree 只是这道题加了个连接操作 对于连接操作我们要用到启发式合并 就是把小的那棵树暴力重建 很简单的一个操作但是可以证明是均摊O(nlogn)的 大小我用了并查集 其实记录根就可以了 此外本题的多组数据是在逗比 记住testcase恒等于1就是了 NND我倍增LCA又写错了0.0 预处理时居然从大往小写的0.0 样

【BZOJ-2286】消耗战 虚树 + 树形DP

2286: [Sdoi2011消耗战 Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 2120  Solved: 752[Submit][Status][Discuss] Description 在一场战争中,战场由n个岛屿和n-1个桥梁组成,保证每两个岛屿间有且仅有一条路径可达.现在,我军已经侦查到敌军的总部在编号为1的岛屿,而且他们已经没有足够多的能源维系战斗,我军胜利在望.已知在其他k个岛屿上有丰富能源,为了防止敌军获取能源,我军的任务是炸毁

【BZOJ2286】[Sdoi2011]消耗战 虚树

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

BZOJ 2286 消耗战

虚树裸题. 23333以后memset千万慎用. #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> #define maxv 250050 #define maxe 500050 #define inf 0x7f7f7f7f7f7f7f7fLL using namespace std; struct edge { long long v,w,nxt; }e[ma

BZOJ 3572 世界树(虚树)

http://www.lydsy.com/JudgeOnline/problem.php?id=3572 思路:建立虚树,然后可以发现,每条边不是同归属于一端,那就是切开,一半给上面,一半给下面. 1 #include<algorithm> 2 #include<cstdio> 3 #include<cmath> 4 #include<cstring> 5 #include<iostream> 6 #define N 300005 7 int t