分析

假设确定了\(i\)号节点，那么就应该是在\(i\)号点的子树中从小到大选择，直到代价和大于\(M\)。可以使用堆来帮助选择，复杂度\(O(N^2\cdot \log N)\)。

从下到上考虑，在\(i\)号节点所选的点一定是在它的儿子节点中选的点或者\(i\)号节点，所以只需要将它的儿子中选的点拿出来建堆。同样可以考虑启发式合并，复杂度为\(O(N \cdot \log^2N)\)

其实这个是涉及到两个堆合并的问题，那么就可以使用可并堆了，而左偏树是一种高效可并堆，所以使用左偏树。

转化一下，对于每个节点维护子树大根堆，若堆中忍者薪水和大于\(M\)，则pop。时间复杂度\(O(N \cdot \log N)\)

代码

#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<ctime>
#include<iostream>
#include<string>
#include<vector>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<complex>
#pragma GCC optimize ("O0")
using namespace std;
template<class T> inline T read(T&x){
    T data=0;
    int w=1;
    char ch=getchar();
    while(!isdigit(ch))
    {
        if(ch==‘-‘)
            w=-1;
        ch=getchar();
    }
    while(isdigit(ch))
        data=10*data+ch-‘0‘,ch=getchar();
    return x=data*w;
}
typedef long long ll;
const int INF=0x7fffffff;

const int MAXN=1e5+7;

struct Edge
{
    int nx,to;
}E[MAXN];
int head[MAXN],ecnt;

void addedge(int x,int y)
{
    E[++ecnt].to=y;
    E[ecnt].nx=head[x],head[x]=ecnt;
}

int n,m;
int c[MAXN],l[MAXN];
int root[MAXN],rcnt,size[MAXN];
ll sum[MAXN],ans;

struct LeftTree
{
    int ch[MAXN][2];
    int val[MAXN],dis[MAXN];
    int merge(int x,int y)
    {
        if(x==0||y==0)
            return x+y;
        if(val[x]<val[y])
            swap(x,y);
        ch[x][1]=merge(ch[x][1],y);
        if(dis[ch[x][0]]<dis[ch[x][1]])
            swap(ch[x][0],ch[x][1]);
        dis[x]=dis[ch[x][1]]+1;
        return x;
    }
    int&top(int x)
    {
        return val[x];
    }
    void pop(int&x)
    {
        x=merge(ch[x][0],ch[x][1]);
    }
}LT;

void dfs(int x)
{
    root[x]=++rcnt;
    LT.val[rcnt]=c[x];
    size[x]=1;
    sum[x]=c[x];
    for(int i=head[x];i;i=E[i].nx)
    {
        int y=E[i].to;
        dfs(y);
        size[x]+=size[y];
        sum[x]+=sum[y];
        root[x]=LT.merge(root[x],root[y]);
    }
    while(sum[x]>m)
    {
        sum[x]-=LT.top(root[x]);
        LT.pop(root[x]);
        --size[x];
    }
    ans=max(ans,(ll)size[x]*l[x]);
}

int main()
{
//  freopen(".in","r",stdin);
//  freopen(".out","w",stdout);
    read(n);read(m);
    for(int i=1;i<=n;++i)
    {
        int fa;
        read(fa);
        addedge(fa,i);
        read(c[i]);read(l[i]);
    }
    dfs(0);
    printf("%lld\n",ans);
//  fclose(stdin);
//  fclose(stdout);
    return 0;
}

BZOJ2809 [Apio2012]dispatching

原文：https://www.cnblogs.com/autoint/p/9542701.html