BZOJ2809 - [APIO2012]派遣Dispatching

2017/03/20

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

如果学过 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);
}