bzoj2809dispatching 左偏树

2809: [Apio2012]dispatching

Time Limit: 10 Sec   Memory Limit: 128 MB
Submit: 4164   Solved: 2142
[ Submit][ Status][ Discuss]

Description

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

 

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

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

 

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

1  ≤Ci ≤ M                     忍者的薪水；

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

 

 

Input

从标准输入读入数据。

 

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

 

接下来 N行描述忍者们的上级、薪水以及领导力。其中的第 i 行包含三个整  B i , 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，

用户的满意度为 2      ，是可以得到的用户满意度的最大值。

这题之前用主席树过去了，现在又用左偏树打了一遍
左偏树以薪水为关键字（大根堆），里面额外维护子树大小和薪水和，自底向上合并上去，超出预算就不停弹堆弹到合法，然后每合到一个节点就更新一次答案。
左偏树真是个好东西，好想好写，简约而不简单。O(∩_∩)O~

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<cmath>
#define maxn 105050
using namespace std;
const int inf = 1e9;
long long read()
{
    char ch = getchar(); long long x = 0, f = 1;
    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;
}
 
struct tree {
    int l, r;
    long long sum, size;
    tree() : l(0), r(0), sum(0), size(0) {}
}t[maxn * 40];
 
int pre[maxn], top;
struct edge {
    int to, next;
}e[maxn * 2];
void add(int u, int v) {
    e[top].to = v;
    e[top].next = pre[u];
    pre[u] = top++;
}
 
int h[maxn], w[maxn], root[maxn], rt, n;
long long m, lead[maxn], ans;
 
void update(int u) {
    h[u] = h[t[u].r] + 1;
    t[u].size = t[t[u].l].size + t[t[u].r].size + 1;
    t[u].sum = t[t[u].l].sum + t[t[u].r].sum + w[u];
}
 
int merge(int u, int v) {
    if(!u || ! v) return u + v;
    if(w[u] < w[v]) swap(u, v);
    t[u].r = merge(t[u].r, v);
    if(h[t[u].r] > h[t[u].l]) swap(t[u].r, t[u].l);
    update(u);
    return u;
}
 
void dfs(int u)
{
    root[u] = u; t[u].sum = w[u]; t[u].size = 1;
    for(int i = pre[u]; ~i; i = e[i].next)
    {
        int v = e[i].to;
        dfs(v);
        root[u] = merge(root[u], root[v]);
    }
    while(t[root[u]].size && t[root[u]].sum > m) {
        root[u] = merge(t[root[u]].l, t[root[u]].r);
    }
    ans = max(t[root[u]].size * lead[u], ans);
}
 
int main()
{
    memset(pre, -1, sizeof(pre)); top = 0;
    n = read(); m = read();
    for(int i = 1;i <= n; ++i) {
        int fa = read(); w[i] = read(); lead[i] = read();
        if(!fa) rt = i;
        else add(fa, i);
    }
    ans = 0; dfs(rt);
    printf("%lld\n", ans);
    return 0;
}
/*
7 10
0 2 1
1 2 1
1 2 1000
2 2 1
2 10 4
3 4 1
3 2 2
 
*/