P1552 [APIO2012]派遣

分析：

明显忍者上下级图是一棵树，考虑对于每个点 u ，找到它和它的子树中最多的点，这些点的数量为 num ，薪水和为 sum，则在 sum<=m 的情况下，最大化求：$$num\ast L[u]$$贪心来说对于每个点，把它和所有子节点按薪水从小到大排序选到不能选为止，这种方案肯定是可行的，但是时间复杂度太高了。我们考虑对于一个节点 u ，先把 u 和所有子节点的薪水累加和，然后维护一个大顶堆，若 sum>m 就减去堆顶代表的节点的薪水，合并两个子堆再继续判断，
因为涉及到堆的合并，所以用左偏树维护大顶堆。

代码：

#include<cstdio>
#define N 100010
#define LL long long
using namespace std;

int inline rd()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

void swap(int &x,int &y){int t=x;x=y;y=t;}
LL max(LL x,LL y){if(x<y) return y;return x;}

#define ls H[x].son[0]
#define rs H[x].son[1]

int n,m;

struct Tree{
	int dis,val,son[2],rt;
}H[N];

int merge(int x,int y){
	if(x==0||y==0) return x+y;
	if(H[x].val<H[y].val) swap(x,y);
	rs=merge(rs,y);
	if(H[ls].dis<H[rs].dis) swap(ls,rs);
	
	H[ls].rt=H[rs].rt=H[x].rt=x;
	H[x].dis=H[rs].dis+1;
	
	return x;
}

int getf(int x){
	if(H[x].rt==x) return x;
	int root=getf(H[x].rt);
	return H[x].rt=root;
}

int L[N],sz[N];
LL sum[N],ans;

struct node{
	int to,nxt;
}e[N];
int head[N],tot=1;

void add(int u,int v)
{
	e[++tot].to=v;
	e[tot].nxt=head[u];
	head[u]=tot;
} 

void dfs(int u)
{
	sum[u]=H[u].val,sz[u]=1;
	for(int i=head[u];i;i=e[i].nxt)
	{
		int v=e[i].to;
		dfs(v);
		sum[u]+=sum[v];
		 sz[u]+=sz[v];
		H[u].rt=merge(H[u].rt,H[v].rt);
	}
	while(sum[u]>m&&sz[u])
	{
		int x=H[u].rt;
		sum[u]-=H[x].val;
		H[ls].rt=ls;
		H[rs].rt=rs;
		H[x].rt=H[u].rt=merge(ls,rs);
		sz[u]--;
	}
	ans=max(ans,(LL)sz[u]*L[u]);
}

int main()
{
	n=rd(),m=rd();
	H[0].dis=-1;
	for(int i=1,x;i<=n;i++)
	{
		H[i].rt=i,H[i].dis=0;
		x=rd(),H[i].val=rd(),L[i]=rd();
		add(x,i);
	}
	dfs(1);
	printf("%lld",ans);
}