bzoj3252攻略（线段树+dfs序）或者（树链剖分+dfs）

3252: 攻略
Time Limit: 10 Sec Memory Limit: 128 MB
Submit: 1341 Solved: 642
[Submit][Status][Discuss]
Description
题目简述：树版[k取方格数]
众所周知，桂木桂马是攻略之神，开启攻略之神模式后，他可以同时攻略k部游戏。今天他得到了一款新游戏《XX
半岛》，这款游戏有n个场景(scene)，某些场景可以通过不同的选择支到达其他场景。所有场景和选择支构成树状
结构：开始游戏时在根节点（共通线），叶子节点为结局。每个场景有一个价值，现在桂马开启攻略之神模式，同
时攻略k次该游戏，问他观赏到的场景的价值和最大是多少（同一场景观看多次是不能重复得到价值的）
“为什么你还没玩就知道每个场景的价值呢？”
“我已经看到结局了。”
Input
第一行两个正整数n,k
第二行n个正整数，表示每个场景的价值
以下n-1行,每行2个整数a,b，表示a场景有个选择支通向b场景（即a是b的父亲）
保证场景1为根节点
n<=200000，1<=场景价值<=2^31-1
Output
输出一个整数表示答案
Sample Input
5 2

4 3 2 1 1

1 2

1 5

2 3

2 4
Sample Output
10

花了挺长时间才弄懂的一道题目。两种方法都写了一下，先说第一种。
树链剖分+dfs
每个节点只能走一次。我们把题目的样例画一下，发现正好是一条按权值的重链和一条轻链。这样我们可以按着权值将树剖成重链和轻链。我们再把权值放到优先队列里，酱紫就可以按着题目要求实现了。
代码如下:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#include<queue>
#include<cmath>
#define ll long long
using namespace std;

const int maxx=2e5+100;
int head[maxx],son[maxx],f[maxx];
ll a[maxx],size[maxx];
int top[maxx];
struct edge{
	int to;
	int next;
}e[maxx*2];
int tot,n,m;

void init()
{
	tot=0;
	memset(head,-1,sizeof(head));
	memset(size,0,sizeof(size));
}
void addedge(int u,int v)
{
	e[tot].to=v,e[tot].next=head[u],head[u]=tot++;
}

void dfs1(int u,int fa)
{
	size[u]+=a[u];
	f[u]=fa;
	for(int i=head[u];i!=-1;i=e[i].next)
	{
		int to=e[i].to;
		if(to==fa) continue;
		dfs1(to,u);
		if(size[to]>size[son[u]]) son[u]=to;
	}
	size[u]+=size[son[u]];
}
priority_queue<ll> q;
void dfs2(int u,int Top)
{
	top[u]=Top;
	if(son[u]) dfs2(son[u],Top);
	for(int i=head[u];i!=-1;i=e[i].next)
	{
		int to=e[i].to;
		if(to==f[u]||to==son[u]) continue;
		dfs2(to,to);
	}
}

int main()
{
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		init();
		for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
		int x,y;
		for(int i=0;i<n-1;i++)
		{
			scanf("%d%d",&x,&y);
			addedge(x,y);
		}
		dfs1(1,0);
		dfs2(1,1);
		for(int i=1;i<=n;i++) if(i==top[i]) q.push(size[i]);
		ll ans=0;
		while(q.size()&&m--) ans+=q.top(),q.pop();
		printf("%lld\n",ans);
	}
	return 0;
}

接下来说第二种方法，线段树+dfs序
其实还是第一次遇到这种dfs序的。
按这题目要求，我们应该贪心找前缀和最大的一条链。找到之后，我们应该把所有叶子节点都减去相应的权值，这个操作交给线段树去做。还有一点，我们有可能会重复更新一些点，但是这有可能会超时。所以我们应该标记住哪些点更新了，然后只更新一次就好了。
代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<string>
#include<algorithm>
#define ll long long
using namespace std;

const int maxx=2e5+100;
int head[maxx],s[maxx],t[maxx],pre[maxx],fa[maxx];
ll a[maxx],size[maxx];
bool vis[maxx];
struct edge{
	int to;
	int next;
}e[maxx*4];
struct node{
	int l;
	int r;
	ll v;
	ll lazy;
	int flag;
}p[maxx*4];
int tot,n,m,sign;
/*----------------事前准备---------------*/ 
void init()
{
	tot=sign=0;
	memset(head,-1,sizeof(head));
	memset(size,0,sizeof(size));
	memset(vis,0,sizeof(vis));
}
void add(int u,int v)
{
	e[tot].to=v,e[tot].next=head[u],head[u]=tot++;
	e[tot].to=u,e[tot].next=head[v],head[v]=tot++;
}
/*-------------------dfs-------------------*/
void dfs(int u,int f)
{
	size[u]=size[f]+a[u];
	fa[u]=f;
	bool fz=0;
	for(int i=head[u];i!=-1;i=e[i].next)
	{
		if(e[i].to==f) continue;
		fz=1;
	}
	if(fz==0)
	{
		s[u]=t[u]=++sign;
		pre[sign]=u;
		return ;
	}
	s[u]=sign+1;
	for(int i=head[u];i!=-1;i=e[i].next)
	{
		int to=e[i].to;
		if(to==f) continue;
		dfs(to,u);
	}
	t[u]=sign;
}
/*------------------线段树------------------*/
void pushup(int cur)
{
	p[cur].v=max(p[cur*2].v,p[cur*2+1].v);
	p[cur].flag=(p[cur*2].v>p[2*cur+1].v?p[2*cur].flag:p[2*cur+1].flag);
}
void pushdown(int cur)
{
	if(p[cur].lazy)
	{
		p[cur*2].lazy+=p[cur].lazy;
		p[2*cur+1].lazy+=p[cur].lazy;
		p[2*cur].v+=p[cur].lazy;
		p[2*cur+1].v+=p[cur].lazy;
		p[cur].lazy=0; 
	}
}
void build(int l,int r,int cur)
{
	p[cur].l=l;
	p[cur].r=r;
	p[cur].lazy=p[cur].v=0;
	if(l==r)
	{
		p[cur].v=size[pre[l]];
		p[cur].flag=pre[l];
		return ;
	}
	int mid=(l+r)/2;
	build(l,mid,2*cur);
	build(mid+1,r,2*cur+1);
	pushup(cur);
}
void update(int l,int r,int cur,ll add)
{
	int L=p[cur].l;
	int R=p[cur].r;
	if(l<=L&&R<=r)
	{
		p[cur].v+=add;
		p[cur].lazy+=add;
		return ;
	}
	pushdown(cur);
	int mid=(L+R)/2;
	if(r<=mid) update(l,r,2*cur,add);
	else if(l>mid) update(l,r,2*cur+1,add);
	else
	{
		update(l,mid,2*cur,add);
		update(mid+1,r,2*cur+1,add);
	}
	pushup(cur);
}
void solve(int cur)
{
	while(cur)
	{
		if(vis[cur]) break;
		vis[cur]=1;
		update(s[cur],t[cur],1,-a[cur]);
		cur=fa[cur];
	}
}
int main()
{
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		init();
		for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
		int x,y;
		for(int i=1;i<=n-1;i++)
		{
			scanf("%d%d",&x,&y);
			add(x,y);
		}
		dfs(1,0);
		build(1,n,1);
		ll ans=0;
		for(int i=1;i<=m;i++)
		{
			ans+=p[1].v;
			solve(p[1].flag);
		}
		printf("%lld\n",ans);
	}
	return 0;
}

第一种方法不论是代码量，时间，空间，都优于第二种。树链剖分还是很强大的。
努力加油a啊，(^o)/~