bzoj 2809: [Apio2012]dispatching（配对堆，左偏树）

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，是可以得到的用户满意度的最大值。

题解：堆的快速合并，用左偏树实现。

当确定了指定点R后，根据计算价值的式子，在R的子树内显然应该尽量多的选点，
而每个点对价值的贡献现在是一样的，因此应该选Ci尽量小的点，当和大于M时，我们将
Ci 较大的点舍弃掉。
考虑对每个点维护一个大根堆，堆内存储的是这个节点子树内所有点的Ci。当堆内的和
大于M 时就要弹出堆顶元素；每个点的堆可以通过将所有儿子的堆合并起来再插入自己节
点的Ci 来得到，因此我们需要一个支持合并操作与删除最大值操作的堆，使用左偏树即可。

代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
const int Maxn=1e5+50;
inline int read()
{
    char ch=getchar();int i=0,f=1;
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){i=(i<<3)+(i<<1)+ch-'0';ch=getchar();}
    return i*f;
}
struct node
{
    node *lc,*rc;
    int sze,dist;
    long long sum,val;
    node(){}
    node(int v):lc(NULL),rc(NULL),sze(1),sum(v),dist(0),val(v){}
    inline void upt()
    {
        sze=(lc?lc->sze:0)+(rc?rc->sze:0)+1;
        sum=(lc?lc->sum:0)+(rc?rc->sum:0)+val;
    }
}*tr[Maxn];
int n,m,rt;
long long ans;
long long l[Maxn],c[Maxn];
int fa[Maxn];
vector<int>edge[Maxn];
inline void Insert(int x,int y)
{
    edge[x].push_back(y);
}
inline node* merge(node *x,node *y)
{
    if(x==NULL)return y;
    if(y==NULL)return x;
    if(x->val<y->val)swap(x,y);
    x->rc=merge(x->rc,y);
    if(!x->lc||x->lc->dist<x->rc->dist)swap(x->lc,x->rc);
    x->dist=x->rc?x->rc->dist+1:0;
    x->upt();
    return x;
}
inline void balance(node *&x)
{
    while(x->sum>m)
    x=merge(x->lc,x->rc);
}
inline  void solve()
{
    static int que[Maxn],qn;
    que[qn=1]=rt;
    for(int ql=1;ql<=qn;ql++)
    {
        int u=que[ql];
        for(int v,e=edge[u].size()-1;e>=0;e--)
        {
            v=edge[u][e];
            que[++qn]=v;
        }
    }
    for(int i=qn;i>=1;i--)
    {
        int u=que[i];
        ans=max(ans,(long long)tr[u]->sze*l[u]);
        if(fa[u])
        {
            tr[fa[u]]=merge(tr[fa[u]],tr[u]);
            balance(tr[fa[u]]);
        }
    }
}
int main()
{
    n=read(),m=read();
    for(int i=1;i<=n;i++)
    {
        fa[i]=read(),c[i]=read(),l[i]=read();
        tr[i]=new node(c[i]);
        if(fa[i]==0)rt=i;
        else Insert(fa[i],i);
    }
    solve();
    printf("%lld",ans);
}

当然，配对堆要比左偏树快。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int Maxn=2e5+50;
struct IO{
    streambuf *ib,*ob;
    int buf[50];
    inline void init(){
        ios::sync_with_stdio(false);
        cin.tie(NULL);cout.tie(NULL);
        ib=cin.rdbuf();ob=cout.rdbuf();
    }
    inline int read(){
        char ch=ib->sbumpc();
        int i=0,f=1;
        while(!isdigit(ch)){if(ch=='-')f=-1;ch=ib->sbumpc();}
        while(isdigit(ch)){i=(i<<1)+(i<<3)+ch-'0';ch=ib->sbumpc();}
        return i*f;
    }
    inline void W(ll x){
        if(!x){ob->sputc('0');return;}
        if(x<0){ob->sputc('-');x=-x;}
        while(x){buf[++buf[0]]=x%10;x/=10;}
        while(buf[0]){ob->sputc(buf[buf[0]--]+'0');}
    }
}io;
int n,m,cnt,root,l[Maxn],c[Maxn],ecnt;
ll ans;
vector<int>edge[Maxn];
struct Edge;
struct node;
struct Edge
{
    Edge *nxt;
    node* to;
    Edge():nxt(NULL){}
}PoolEdge[Maxn];
struct RecycPool
{
    Edge *que[Maxn];
    int top;
    inline Edge* recycle()
    {
        if(top)return que[top--];
        return (&PoolEdge[++ecnt]);
    }
}Pool;
struct node
{
    int val,sze;
    ll sum;
    node *fa;
    Edge *last;
    node():fa(NULL),last(NULL),sze(1){}
    friend inline void Merge(node*& x,node*& y)
    {
        if(!y)return;
        if(!x)
        {
            x=y;
            y=NULL;
            return;
        }       
        if(y->val>x->val)swap(x,y);
        y->fa=x;x->sze+=y->sze;x->sum+=y->sum;
        Edge *tmp=Pool.recycle();
        tmp->to=y;tmp->nxt=x->last;x->last=tmp;
        return;
    }
    inline node* pop()
    {
        node *tmp=NULL;this->sum-=this->val;
        for(Edge *e=this->last;e;e=e->nxt)
        {
            if(e->to->fa==this)
            {
                e->to->fa=NULL;
                Merge(tmp,e->to);
            }
            Pool.que[++Pool.top]=e;
        }
        this->last=NULL;
        return tmp;
    }
}heappool[Maxn],*heap[Maxn];

inline void balance(node*& now)
{
    while(now->sum>m)now=now->pop();
}
inline void dfs(int now,int f)
{
    for(int e=edge[now].size()-1;e>=0;e--)
    {
        int v=edge[now][e];
        if(v==f)continue;
        dfs(v,now);
        Merge(heap[now],heap[v]);
        balance(heap[now]);
    }
    ans=max(ans,1ll*l[now]*heap[now]->sze);
}
int main()
{
    io.init();n=io.read();m=io.read();
    for(int i=1;i<=n;i++)
    {
        int x=io.read();
        heap[i]=&heappool[i];
        if(x)edge[x].push_back(i);
        else root=i;
        heap[i]->val=heap[i]->sum=io.read();
        l[i]=io.read();
    }
    dfs(root,0);
    io.W(ans);
}