我好菜啊 _(:з」∠)_

如果学过 fhqtreap 的话，发现左偏树其实非常好写咩！

提供一个该题的详细课件

题目

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

代码

（我语文好差啊。。。直接看课件好了）

其实就是说找一个节点，在它子树上贪一把，求一个子树点集 S，使得 S 中所有元素的 薪水和小于预算，且子树树根的领导力 L × |S| 最大。

考虑到总是选工资低的忍者，所以维护一个大根堆，DFS 从树叶开始搜，超过预算就扔掉 一些节点，每个节点从自己儿子上合并堆（这样就用到左偏树）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;
const int MAX_N = 1E6 + 1E5;
typedef long long LL;

int N, M;
int Mast = 0;
LL ans = 0;

struct tgno {
    int u, v; tgno *n;
} POOL[MAX_N], *Head[MAX_N]; int ppos;

struct {
    int b, c, l;
} Ninja[MAX_N];

void addEdge(int u, int v) {
    POOL[ppos].u = u;
    POOL[ppos].v = v;
    POOL[ppos].n = Head[u];
    Head[u] = &POOL[ppos++];
}

struct lnode {
    int w, dist;
    lnode *l, *r;
};

lnode* mknod(int w) {
    lnode *x = new lnode;
    x->w = w;
    x->dist = 0;
    x->l = x->r = NULL;
    return x;
}

#define DIST(_) ((_) ? (_)->dist : 0)

lnode* tmerge(lnode* x, lnode* y) {
    if(!x || !y) return x ? x : y;
    else {
        if(x->w < y->w) swap(x, y);
        x->r = tmerge(x->r, y);
        if(DIST(x->l) < DIST(x->r)) swap(x->l, x->r);
        x->dist = x->r ? x->r->dist + 1 : 0;
        return x;
    }
}

struct ltree {
    lnode* root;
    int ncnt;
    LL sum;

    ltree(lnode* rt = NULL, int ncnt = 0, LL sum = 0) :
        root(rt), ncnt(ncnt), sum(sum) { }

    static ltree merge(ltree lhs, ltree rhs) {
        return ltree(tmerge(lhs.root, rhs.root), lhs.ncnt + rhs.ncnt,
            lhs.sum + rhs.sum);
    }

    void push(int x) {
        lnode *nd = mknod(x);
        root = tmerge(root, nd);
        sum += x;
        ncnt += 1;
    }

    int top() {
        return root ? root->w : 0;
    }

    void pop() {
        if(!root) return;
        sum -= root->w; ncnt -= 1;
        lnode* tmp = tmerge(root->l, root->r);
        delete root;
        root = tmp;
    }
};

ltree TDP(int cur) {
    typedef tgno* It;
    ltree lt;

    lt.push(Ninja[cur].c);

    for(It i=Head[cur];i;i=i->n) {
        ltree sub = TDP(i->v);
        lt = ltree :: merge(lt, sub);
    }

    while(lt.sum > M)
        lt.pop();

    ans = max(ans, LL(lt.ncnt) * Ninja[cur].l);

    return lt;
}

int main() {
    scanf("%d %d", &N, &M);

    for(int i=1;i<=N;i++) {
        scanf("%d %d %d", &Ninja[i].b, &Ninja[i].c, &Ninja[i].l);
        if(Ninja[i].b) addEdge(Ninja[i].b, i);
        else Mast = i;
    }

    TDP(Mast);
    printf("%lld\n", ans);
}