bzoj 2809: [Apio2012]dispatching

Description

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

$1 \leq N \leq 100000$ 忍者的个数；

$1 \leq M \leq1000000000$ 薪水总预算；

$0 \leq B_i < i$ 忍者的上级的编号；

$1 \leq C_i \leq M$ 忍者的薪水；

$1 \leq L_i \leq 1000000000$ 忍者的领导力水平。

Input

从标准输入读入数据。

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

接下来 $N$ 行描述忍者们的上级、薪水以及领导力。其中的第 $i$ 行包含三个整 $Bi , C_i,L_i$ 分别表示第i个忍者的上级，薪水以及领导力。$Master$ 满足$B_i = 0$，并且每一个忍者的老板的编号一定小于自己的编号 $B_i < 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$，用户的满意度为 $6$，是可以得到的用户满意度的最大值。

Source

solution

• 所有忍者之间的关系构成一棵树

• 对于一个节点 $x$ ，我们先派遣 $x$ 子树中的所有节点

• 如果这个时候的总薪水比 $m$ 大，我们就取出 $x$ 子树中薪水最大的那个点，直到总薪水 $\leq m$

• 那这样我们就需要一个取最大值而且可以合并的数据结构

• 左偏树是个不错的选择

code

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;

template<typename T>
void input(T &x) {
    x=0; T a=1;
    register char c=getchar();
    for(;c<48||c>57;c=getchar())
        if(c==45) a=-1;
    for(;c>=48&&c<=57;c=getchar())
        x=x*10+c-48;
    x*=a;
    return;
}

#define MAXN 100010

struct Leftist_Tree {
    int lc,rc,dis,val;
    bool operator < (const Leftist_Tree &q) const {
        return val>q.val;
    }
};

Leftist_Tree t[MAXN];
int fa[MAXN];

#define Lc t[x].lc
#define Rc t[x].rc

int Merge(int x,int y) {
    if(!x||!y) return x+y;
    if(t[y]<t[x]) swap(x,y);
    if(t[y].val==t[x].val&&x>y) swap(x,y);
    fa[Rc=Merge(Rc,y)]=x;
    if(t[Lc].dis<t[Rc].dis) swap(Lc,Rc);
    t[x].dis=t[Rc].dis+1;
    return x;
}

int pop(int x) {
    fa[Lc]=fa[Rc]=0;
    int ans=Merge(Lc,Rc);
    Lc=Rc=0;
    return ans;
}

#undef Lc
#undef Rc

struct Edge {
    int u,v,next;
    Edge(int u=0,int v=0,int next=0):
        u(u),v(v),next(next) {}
};

Edge edge[MAXN];
int head[MAXN],cnt;

void addedge(int u,int v) {
    edge[++cnt]=Edge(u,v,head[u]);
    head[u]=cnt;
    return;
}

int n;
int root[MAXN],tot;
int size[MAXN];

ll m,ans;
ll L[MAXN],C[MAXN];
ll sum[MAXN];

void dfs(int u) {
    root[u]=++tot;
    t[tot].val=C[u];
    size[u]=1,sum[u]=C[u];
    for(int i=head[u],v;i;i=edge[i].next) {
        v=edge[i].v;
        dfs(v);
        sum[u]+=sum[v];
        size[u]+=size[v];
        root[u]=Merge(root[u],root[v]);
    }
    while(sum[u]>m) {
        sum[u]-=t[root[u]].val;
        root[u]=pop(root[u]);
        size[u]--;
    }
    ans=max(ans,L[u]*size[u]);
    return;
}

int main() {
    input(n),input(m);
    t[0].dis=-1;
    int Root;
    for(int i=1,Bi;i<=n;i++) {
        input(Bi),input(C[i]),input(L[i]);
        if(Bi) addedge(Bi,i);
        else Root=i;
    }
    dfs(Root);
    printf("%lld\n",ans);
    return 0;
}