[luogu P1552] [APIO2012]派遣

最新推荐文章于 2021-07-26 17:54:12 发布

a8233821

最新推荐文章于 2021-07-26 17:54:12 发布

阅读量109

点赞数

原文链接：http://www.cnblogs.com/whc200305/p/7616108.html

版权

[luogu P1552] [APIO2012]派遣

题目背景

在一个忍者的帮派里，一些忍者们被选中派遣给顾客，然后依据自己的工作获取报偿。

题目描述

在这个帮派里，有一名忍者被称之为Master。除了Master以外，每名忍者都有且仅有一个上级。为保密，同时增强忍者们的领导力，所有与他们工作相关的指令总是由上级发送给他的直接下属，而不允许通过其他的方式发送。

现在你要招募一批忍者，并把它们派遣给顾客。你需要为每个被派遣的忍者支付一定的薪水，同时使得支付的薪水总额不超过你的预算。另外，为了发送指令，你需要选择一名忍者作为管理者，要求这个管理者可以向所有被派遣的忍者发送指令，在发送指令时，任何忍者（不管是否被派遣）都可以作为消息的传递人。管理者自己可以被派遣，也可以不被派遣。当然，如果管理者没有被排遣，你就不需要支付管理者的薪水。

你的目标是在预算内使顾客的满意度最大。这里定义顾客的满意度为派遣的忍者总数乘以管理者的领导力水平，其中每个忍者的领导力水平也是一定的。

写一个程序，给定每一个忍者i的上级Bi，薪水Ci，领导力Li，以及支付给忍者们的薪水总预算M，输出在预算内满足上述要求时顾客满意度的最大值。

输入输出格式

输入格式：

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

接下来N行描述忍者们的上级、薪水以及领导力。其中的第i行包含三个整数Bi,Ci,Li分别表示第i个忍者的上级，薪水以及领导力。Master满足Bi=0，并且每一个忍者的老板的编号一定小于自己的编号Bi<i。

输出格式：

输出一个数，表示在预算内顾客的满意度的最大值。

输入输出样例

输入样例#1：

输出样例#1：

说明

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

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

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

1 ≤ Ci ≤ M 忍者的薪水；

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

对于 30%的数据，N ≤ 3000。

想了较长时间（其实是脑子坏了）。

我最初的想法就是，我们可以定住一个点x，将它当做是管理者，然后那些被派遣的人从以其为根的子树中找。

然后ans=max(ans,lead[x]*calc(x))。显然，这是正确的吧。因为管理者需要能到达所有的被派遣者，及管理者是被选出子树的根节点。

这样方便了我们calc（其实就是运用了一点点的动规思想和贪心思想）。

那么，calc怎么办？也就是说，我们要在x的几棵子树中（包括自己）找到最多的点代价和不超过m。

想到了什么？左偏树好像可以。

就是说，对于每一个点x，都连着好几棵处理好的左偏树，然后我们可以用log的时间合并。

但是，我们还要删掉一些点使满足条件。我选择了用大根堆，这样删除方便。

但是这个操作具体的复杂度是多少呢？由于删除的点不会重新被加入，所以每个点最多被删除一次，复杂度为nlogn。

加上上面的一系列操作nlogn的复杂度，总复杂度依然是nlogn。

code：

 1 %:pragma GCC optimize(2)
 2 #include<bits/stdc++.h>
 3 #define LL long long
 4 using namespace std;
 5 const int N=100005;
 6 vector <int> son[N];
 7 int n,m,ro[N]; LL s[N],c[N],f[N],ans;
 8 struct lft {int l,r,d,w; void cl() {l=r=d=0;}}a[N];
 9 inline int read() {
10     int x=0; char ch=getchar();
11     while (ch<'0'||ch>'9') ch=getchar();
12     while (ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
13     return x;
14 }
15 int merge(int x,int y) {
16     if (!x||!y) return x+y; if (a[x].w<a[y].w) swap(x,y);
17     a[x].r=merge(a[x].r,y); int l=a[x].l,r=a[x].r;
18     if (a[l].d<a[r].d) swap(a[x].l,a[x].r);
19     a[x].d=a[a[x].r].d+1;
20     return x;
21 }
22 int main() {
23     n=read(),m=read(),ans=0,a[0].d=-1;
24     for (int i=1; i<=n; i++) {
25         a[i].cl(),ro[i]=i,son[read()].push_back(i);
26         s[i]=a[i].w=read(),c[i]=1,f[i]=read();
27     }
28     for (int i=n,siz; i>=1; i--) {
29         siz=son[i].size();
30         for (int k=0,j; k<siz; k++) {
31             j=son[i][k],ro[i]=merge(ro[i],ro[j]);
32             s[i]+=s[j],c[i]+=c[j];
33         }
34         for (; s[i]>m;) {
35             s[i]-=a[ro[i]].w,c[i]--;
36             ro[i]=merge(a[ro[i]].l,a[ro[i]].r);
37         }
38         ans=max(ans,f[i]*c[i]);
39     }
40     printf("%lld\n",ans);
41     return 0;
42 }

View Code

11.4 upd (复习，码风突变版)

  1 #include<cstdio>
  2 #include<cstring>
  3 #include<algorithm>
  4 typedef long long LL;
  5 namespace fastIO {
  6     inline LL read() {
  7         LL x=0,f=1; char ch=getchar();
  8         while (ch<'0'||ch>'9') {
  9             if (ch=='-') f=-f;
 10             ch=getchar();
 11         }
 12         while (ch>='0'&&ch<='9') {
 13             x=(x<<3)+(x<<1)+ch-'0';
 14             ch=getchar();
 15         }
 16         return x*f;
 17     }
 18     int cnt,w[20];
 19     inline void write(LL x) {
 20         if (x==0) {
 21             putchar('0');
 22             return;
 23         }
 24         if (x<0) {
 25             x=-x;
 26             putchar('-');
 27         }
 28         for (cnt=0; x; x/=10) w[++cnt]=x%10;
 29         for (; cnt; --cnt) putchar(w[cnt]+48);
 30     }
 31     inline void newline() {
 32         putchar('\n');
 33     }
 34 }
 35 namespace OJ{
 36     void Online_Judge() {
 37         #ifndef ONLINE_JUDGE
 38             freopen("in.txt","r",stdin);
 39             freopen("out.txt","w",stdout);
 40         #endif
 41     }
 42 }
 43 const int N=100005;
 44 int n,m,bos[N];
 45 LL cnt,ans,cos[N],lea[N],s[N],c[N];
 46 class node {
 47     private:
 48         int d; LL w; node *l,*r;
 49     public:
 50         node() {
 51             w=d=0,l=r=0;
 52         }
 53         inline void newnode(node* &c,LL w) {
 54             c=new node;
 55             c->w=w;
 56         }
 57         inline int dis(node* c) {
 58             return c==0?0:c->d;
 59         }
 60         inline void upd(node* c) {
 61             if (dis(c->l)<dis(c->r)) {
 62                 std::swap(c->l,c->r);
 63             }
 64             c->d=dis(c->l)+1;
 65         }
 66         inline node* merge(node* a,node* b) {
 67             if (a==0) return b;
 68             if (b==0) return a;
 69             if (a->w<b->w) std::swap(a,b);
 70             a->r=merge(a->r,b);
 71             return upd(a),a;
 72         }
 73         inline node* remove(node* c) {
 74             node* t=c; delete t;
 75             c=merge(c->l,c->r);
 76             return c;
 77         }
 78         inline LL top(node* c) {
 79             return c->w;
 80         }
 81 }*ro[N],t;
 82 int main() {
 83     OJ::Online_Judge();
 84     using namespace fastIO;
 85     using std::max;
 86     n=read(),m=read(),ans=0;
 87     for (int i=1; i<=n; ++i) {
 88         bos[i]=read(),cos[i]=read(),lea[i]=read();
 89         s[i]=cos[i],c[i]=1;
 90         t.newnode(ro[i],cos[i]);
 91     }
 92     for (int i=n,x,y; i>=1; --i) {
 93         while (s[i]>m) {
 94             s[i]-=t.top(ro[i]);
 95             --c[i];
 96             ro[i]=t.remove(ro[i]);
 97         }
 98         ans=max(ans,lea[i]*c[i]);
 99         s[bos[i]]+=s[i],c[bos[i]]+=c[i];
100         ro[bos[i]]=t.merge(ro[bos[i]],ro[i]);
101     }
102     write(ans);
103     newline();
104     return 0;
105 }

View Code

转载于:https://www.cnblogs.com/whc200305/p/7616108.html

a8233821

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[luogu P1552] [APIO2012]派遣

[luogu P1552] [APIO2012]派遣题目背景在一个忍者的帮派里，一些忍者们被选中派遣给顾客，然后依据自己的工作获取报偿。题目描述在这个帮派里，有一名忍者被称之为Master。除了Master以外，每名忍者都有且仅有一个上级。为保密，同时增强忍者们的领导力，所有与他们工作相关的指令总是由上级发送给他的直接下属，而不允许通过其他的方式发送。现在你要招募一批...
复制链接

扫一扫