bzoj2809：dispatching（可持久化线段树+树上差分）

2809: [Apio2012]dispatching

Time Limit: 10 Sec  MemoryLimit: 128 MB

Description

在一个忍者的帮派里，一些忍者们被选中派遣给顾客，然后依据自己的工作获取报偿。在这个帮派里，有一名忍者被称之为 Master。除了 Master以外，每名忍者都有且仅有一个上级。为保密，同时增强忍者们的领导力，所有与他们工作相关的指令总是由上级发送给他的直接下属，而不允许通过其他的方式发送。现在你要招募一批忍者，并把它们派遣给顾客。你需要为每个被派遣的忍者 支付一定的薪水，同时使得支付的薪水总额不超过你的预算。另外，为了发送指令，你需要选择一名忍者作为管理者，要求这个管理者可以向所有被派遣的忍者 发送指令，在发送指令时，任何忍者（不管是否被派遣）都可以作为消息的传递 人。管理者自己可以被派遣，也可以不被派遣。当然，如果管理者没有被排遣，就不需要支付管理者的薪水。你的目标是在预算内使顾客的满意度最大。这里定义顾客的满意度为派遣的忍者总数乘以管理者的领导力水平，其中每个忍者的领导力水平也是一定的。写一个程序，给定每一个忍者 i的上级 Bi，薪水Ci，领导力L i，以及支付给忍者们的薪水总预算 M，输出在预算内满足上述要求时顾客满意度的最大值。

1  ≤N ≤ 100,000 忍者的个数；

1  ≤M ≤1,000,000,000 薪水总预算； 

0  ≤Bi < i  忍者的上级的编号；

1  ≤Ci ≤ M                     忍者的薪水；

1  ≤Li ≤ 1,000,000,000             忍者的领导力水平。

Input

从标准输入读入数据。

第一行包含两个整数 N和 M，其中 N表示忍者的个数，M表示薪水的总预算。

接下来 N行描述忍者们的上级、薪水以及领导力。其中的第 i 行包含三个整 Bi , C i , L i分别表示第i个忍者的上级，薪水以及领导力。Master满足B i = 0，并且每一个忍者的老板的编号一定小于自己的编号 Bi < i。

Output

输出一个数，表示在预算内顾客的满意度的最大值。

Sample Input

5  4

0  3 3

1  3 5

2  2 2

1  2 4

2  3 1

Sample Output

6

HINT
如果我们选择编号为 1的忍者作为管理者并且派遣第三个和第四个忍者，薪水总和为 4，没有超过总预算                        4。因为派遣了                             2   个忍者并且管理者的领导力为      3，
用户的满意度为2      ，是可以得到的用户满意度的最大值。

题目分析：这题我一开始想了一个treap+启发式合并的做法，时间复杂度O(n*log^2(n))，然后我发现自己简直就是个傻缺。我们可以借鉴noip2016Day1T2的方法，用树上差分去做。我们把刚进入该点的dfs时的线段树状态记录下来，然后再记录退出时的线段树状态，根据这两棵线段树做二叉查找。于是该题变成了可持久化线段树，时间复杂度O(n*log(n))。

ＣＯＤＥ：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=100100;
const int maxl=20;
typedef long long LL;

struct data
{
	int obj;
	data *Next;
} e[maxn];
data *head[maxn];
int Ecur=-1;

struct Tnode
{
	LL sum;
	int cnt;
	Tnode *lson,*rson;
} tree[(maxn<<2)+maxn*maxl];
Tnode *Root[maxn];
int Tcur=-1;

int c[maxn];
int temp[maxn];
int id[maxn];
int l[maxn];

int Time=0;
LL ans=0;
int n,m;

void Add(int x,int y)
{
	Ecur++;
	e[Ecur].obj=y;
	e[Ecur].Next=head[x];
	head[x]=e+Ecur;
}

bool Comp(int x,int y)
{
	return c[x]<c[y];
}

Tnode *New_node()
{
	Tcur++;
	tree[Tcur].sum=tree[Tcur].cnt=0;
	tree[Tcur].lson=tree[Tcur].rson=tree;
	return tree+Tcur;
}

void Update(Tnode *root,int L,int R,int x,int v)
{
	if ( L==x && x==R )
	{
		root->sum+=(long long)v;
		root->cnt++;
		return;
	}
	
	int mid=(L+R)>>1;
	Tnode *y=New_node();
	if (x<=mid)
	{
		*y=*(root->lson);
		root->lson=y;
		Update(y,L,mid,x,v);
	}
	else
	{
		*y=*(root->rson);
		root->rson=y;
		Update(y,mid+1,R,x,v);
	}
	
	root->sum=root->lson->sum+root->rson->sum;
	root->cnt=root->lson->cnt+root->rson->cnt;
}

int Query(Tnode *x,Tnode *y,int L,int R,LL v)
{
	if (L==R)
	{
		LL now_sum=y->sum-x->sum;
		LL now_cnt=y->cnt-x->cnt;
		if (now_sum<=v) return now_cnt;
		else return 0;
	}
	LL left_sum=y->lson->sum-x->lson->sum;
	LL left_cnt=y->lson->cnt-x->lson->cnt;
	int mid=(L+R)>>1;
	if (left_sum<=v) return left_cnt+Query(x->rson,y->rson,mid+1,R,v-left_sum);
	else return Query(x->lson,y->lson,L,mid,v);
}

void Dfs(int node)
{
	Time++;
	Root[Time]=New_node();
	*Root[Time]=*Root[Time-1];
	Update(Root[Time],1,n,id[node],c[node]);
	int x=Time-1;
	for (data *p=head[node]; p; p=p->Next) Dfs(p->obj);
	int num=Query(Root[x],Root[Time],1,n,(long long)m);
	LL nans=(long long)l[node]*(long long)num;
	ans=max(ans,nans);
}

int main()
{
	freopen("c.in","r",stdin);
	freopen("c.out","w",stdout);
	
	scanf("%d%d",&n,&m);
	for (int i=1; i<=n; i++) head[i]=NULL;
	for (int i=1; i<=n; i++)
	{
		int b;
		scanf("%d%d%d",&b,&c[i],&l[i]);
		temp[i]=i;
		if (b) Add(b,i);
	}
	
	sort(temp+1,temp+n+1,Comp);
	for (int i=1; i<=n; i++) id[ temp[i] ]=i;
	
	Root[0]=New_node();
	Dfs(1);
	
	cout<<ans<<endl;
	return 0;
}