直观思想是要找到以每个点为根的子树里,最多能有多少个节点薪水和不大于M,也就是要去把最小的点统计起来,乍一眼像是一个维护最小薪水的可并堆,但是考虑到必须要有出堆操作来使时间更优,而出堆元素越大越好,综上,维护一个子树中最大薪水的可并堆。DFS到一个点x时,先递归处理子树,再一个个合并儿子节点所代表的堆,并且在合并后进行不断的pop操作来删除超额节点,最后录入x的信息,每次去个max即可。代码如下。
#include<iostream>
#include<set>
#include<cmath>
#include<queue>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long LL;
const LL N=100005;
LL n,m,v[N],w[N];
struct node{LL to,next;}q[2*N];
LL h[N],cnt=0,root[N],add[N],sum[N],Ans=0;
struct data{LL L,R,val;}tr[100*N];
void qxx(LL x,LL y)
{
cnt++;q[cnt].to=y;q[cnt].next=h[x];h[x]=cnt;
}
LL Merge(LL x,LL y)
{
if(!x||!y)return x+y;
if(tr[x].val<tr[y].val)swap(x,y);
tr[x].L=Merge(tr[x].L,y);
swap(tr[x].L,tr[x].R);
return x;
}
LL Pop(LL x)
{
LL rt=root[x];
root[x]=Merge(tr[rt].L,tr[rt].R);
sum[x]--;add[x]-=tr[rt].val;
tr[rt].L=tr[rt].R=tr[rt].val=0;
}
void DFS(LL x)
{
LL i,y;add[x]=0;sum[x]=0;
for(i=h[x];i;i=q[i].next)
{
y=q[i].to;
DFS(y);
add[x]+=add[y];sum[x]+=sum[y];
root[x]=Merge(root[x],root[y]);
while(add[x]>m)Pop(x);
}
add[x]+=v[x];sum[x]++;
tr[x]=(data){0,0,v[x]};
root[x]=Merge(root[x],x);
while(add[x]>m)Pop(x);
Ans=max(Ans,sum[x]*w[x]);
}
int main()
{
scanf("%lld%lld",&n,&m);
LL i,j,x,y,k;
for(i=1;i<=n;i++)
{
scanf("%lld%lld%lld",&x,&v[i],&w[i]);
qxx(x,i);if(!x)k=i;
}
DFS(k);
printf("%lld",Ans);
return 0;
}