[考试反思]1103csp-s模拟测试99： 美梦

可能这次考得好的原因就是熬夜颓废到不算太晚？（啪）

但是是真心困。

考前跟akt说：我希望今天考一点那种不用动脑子，就是一直码的题。

然后开门T1一道线段树维护单调栈的板子我就。。。了

当时调了一上午啊，我就觉得考场上不可能调出来，但是T2和T3都不会做，所以回去调板子。

说是“调”其实很不严谨，因为我其实就是一直在写，连编译都没有编译过。

一个半小时之后差不多要写完了（但是还没有写完）。感觉心累，并不觉得自己写的是对的（模板爆零专家）

于是没打完就弃了。

T3感觉数据很难造而可行方案很多，于是乱打了一个。

然后觉得T2的题目有7个参数很难写，就想都没想打了一个非常蠢的$O(n^3log n)$的暴力。（可以非常简单的优化到$O(n^2 log n)$）

最后给T1写了一个20分的暴力，把自己写的线段树注释了。离考试结束还有10分钟。

检查完文件闲得无聊。于是去继续在注释里写T1的线段树。

本来就没差多少于是写完了，脑子一抽想试一下。

结果就过样例了，然而我很不放心觉得它过不了，于是还测试点分治了一下。

然后我板子居然没爆炸2333太快乐了。

然后T3乱搞A了2333太快乐了。

然后T2的$O(n^3logn)$过了1000的点2333太快乐了。

然后就莫名其妙地rank1了2333太快乐了。

真的不是在用脑子考试，是在用RP考试。。。

T1：陶陶摘苹果

题目已经说了显然是快速傅丽叶变换再加一个狄利克雷卷积

可以发现这是一个非常裸的线段树优化单调栈，可以去看我《椎》的题解，写的挺详细的。

复杂度是$O(nlog^2n)$的。不是最优的但是也可过。

 #include<bits/stdc++.h>
 using namespace std;
 int cl[],cr[],w[],mx[],mxr,n,m,h[],rv[];
 int ask(int p,int l,int r,int W){
     if(W>=mx[p])return ;
     if(cl[p]==cr[p]){mxr=max(mxr,mx[p]);return ;}
     if(l<=cl[p]&&cr[p]<=r){
         if(W>mx[p<<|])return ask(p<<,l,r,W);
         int re=ask(p<<|,l,r,W)+rv[p];
         mxr=max(mxr,mx[p]);return re;
     }
     int ans=;
     if(r>cr[p<<])ans=ask(p<<|,l,r,W);
     if(l<=cr[p<<])ans+=ask(p<<,l,r,mxr);
     return ans;
 }
 void update(int p){
     mx[p]=max(mx[p<<],mx[p<<|]);
     mxr=;rv[p]=ask(p<<,cl[p<<],cr[p<<],mx[p<<|]);
 }
 void modify(int p,int pos,int H){
     if(cl[p]==cr[p]){mx[p]=H;return;}
     modify(pos<=cr[p<<]?p<<:p<<|,pos,H);
     update(p);
 }
 void build(int p,int l,int r){
     cl[p]=l;cr[p]=r;
     if(l==r){w[p]=;mx[p]=h[l];return;}
     build(p<<,l,l+r>>);
     build(p<<|,(l+r>>)+,r);
     update(p);
 }
 int main(){
     freopen("TaoPApp.in","r",stdin);
     freopen("TaoPApp.out","w",stdout);
     scanf("%d%d",&n,&m);
     for(int i=;i<=n;++i)scanf("%d",&h[n+-i]);
     build(,,n);
     for(int i=;i<=m;++i){
         int p,nw,r,mx=-,cnt=;scanf("%d%d",&p,&nw);p=n+-p;r=h[p];
         if(n<=&&m<=){
             h[p]=nw;
             for(int j=n;j;--j)if(h[j]>mx)mx=h[j],cnt++;
             printf("%d\n",cnt);h[p]=r;
         }
         else modify(,p,nw),mxr=,printf("%d\n",ask(,,n,)),modify(,p,r);
     }
 }

也有其它做法，如分治（像《走路》）。

题解的做法是考虑每个点左右两端，预处理出来它的类似与于单调栈的东西，然后二分位置。也挺麻烦的。

T2：开心的金明

暴力50%：

枚举买进原料的时间，枚举制造电脑的时间，枚举卖出的时间，线段树维护电脑还能存多少（区间减，区间取min），复杂度O(n^3logn)。

 #include<cstdio>
 #define inf 1234567890
 inline int min(int a,int b){return a<b?a:b;}
 int k,bf[],s[],kpn[],kpf[],ksf[],mf[],mn[];long long ans;
 struct Segment_Tree{
     int mn[],lz[],cl[],cr[];
     void build(int p,int l,int r){
         cl[p]=l;cr[p]=r;
         if(l==r)return (void)(mn[p]=kpn[l]);
         build(p<<,l,l+r>>);
         build(p<<|,(l+r>>)+,r);
         mn[p]=min(mn[p<<],mn[p<<|]);
     }
     void down(int p){
         mn[p<<]-=lz[p];mn[p<<|]-=lz[p];
         lz[p<<]+=lz[p];lz[p<<|]+=lz[p];
         lz[p]=;
     }
     void minus(int p,int l,int r,int w){
         if(r<l)return;
         if(l<=cl[p]&&cr[p]<=r)return mn[p]-=w,lz[p]+=w,(void);
         if(lz[p])down(p);
         if(l<=cr[p<<])minus(p<<,l,r,w);
         if(r>cr[p<<])minus(p<<|,l,r,w);
         mn[p]=min(mn[p<<],mn[p<<|]);
     }
     int ask(int p,int l,int r){
         if(r<l)return inf;
         if(l<=cl[p]&&cr[p]<=r)return mn[p];
         if(lz[p])down(p);
         return min(l<=cr[p<<]?ask(p<<,l,r):inf,r>cr[p<<]?ask(p<<|,l,r):inf);
     }
 }T;
 int main(){
     freopen("happy.in","r",stdin);
     freopen("happy.out","w",stdout);
     scanf("%d",&k);
     for(int i=;i<=k;++i)scanf("%d%d%d%d",&bf[i],&s[i],&mf[i],&mn[i]);
     for(int i=;i<k;++i)scanf("%d%d%d",&kpn[i],&ksf[i],&kpf[i]),ksf[i]+=ksf[i-],kpf[i]+=kpf[i-];
     T.build(,,k-);
     for(int sd=;sd<=k;++sd){
         int lft=s[sd];
         while(lft){
             int bbd,bpd,num,cost=inf;
             for(int pd=sd;pd;--pd)for(int bd=pd;bd;--bd){
                 int C=bf[bd]+ksf[pd-]-ksf[bd-]+kpf[sd-]-kpf[pd-]+mf[pd],Num=min(mn[pd],T.ask(,pd,sd-));
                 if(C<cost&&Num)num=Num,cost=C,bbd=bd,bpd=pd;
             }
             if(cost==inf)return puts("-1"),;
             num=min(num,lft);
             lft-=num;T.minus(,bpd,sd-,num);mn[bpd]-=num;
             ans+=num*cost;
         }
     }printf("%lld\n",ans);
 }

因为对材料没有任何的限制，所以可以预处理材料在每一天的价格，就可以降低到$O(n^2log n)$。

直接上正解。

首先正解也用到了这种处理原材料的价格的方法：对于新的一天，要么把昨天单位原材料的价格+昨天到今天存储原材料的价格作为今天的价格，要么直接把今天买入的价格作为真正价格。

然后反正你已经有原料了。用set维护结构体存每一个电脑的费用以及这个费用的电脑的数量。

模拟每一天的过程。

计算今天制造电脑的价格（最小原材料价格+制造费用），放进set里。

卖电脑。从set里取出价格最小的电脑一直到卖够数量，累加答案，卖不够就无解。

屯材料。计算材料留到明天的价格，是min(留到今天的价格+存储费用，明天再买的价格)

屯电脑。如果set里的电脑多于存储上限，那就干掉最贵的，留下的电脑涨价（存储价格）。

没了。就是贪心。

 #include<cstdio>
 #include<set>
 using namespace std;
 struct P{int n,f;friend bool operator<(P a,P b){return a.f<b.f;}};
 multiset<P>S,res;
 int k,bf[],s[],kpn[],kpf[],ksf[],mf[],mn[],sf,totn;
 long long ans;
 main(){
     freopen("happy.in","r",stdin);
     freopen("happy.out","w",stdout);
     scanf("%d",&k);
     for(int i=;i<=k;++i)scanf("%d%d%d%d",&bf[i],&s[i],&mf[i],&mn[i]);
     for(int i=;i<k;++i)scanf("%d%d%d",&kpn[i],&ksf[i],&kpf[i]);
     sf=bf[];
     for(int i=;;++i){
         if(mn[i])S.insert((P){mn[i],mf[i]+sf});totn+=mn[i];
         while(s[i]){
             if(S.empty())return puts("-1"),;
             P x=*S.begin();int num=min(s[i],x.n);S.erase(S.begin());
             ans+=1ll*x.f*num;x.n-=num;totn-=num;s[i]-=num;
             if(x.n)S.insert((P){x.n,x.f});
         }
         if(i==k)break;
         sf=min(sf+ksf[i],bf[i+]);
         while(totn>kpn[i]){
             P x=*S.rbegin();int num=min(totn-kpn[i],x.n);S.erase(--S.end());
             totn-=num;x.n-=num;
             if(x.n)S.insert((P){x.n,x.f});
         }
         for(auto it=S.begin();it!=S.end();++it)res.insert((P){(*it).n,(*it).f+kpf[i]});
         swap(S,res);res.clear();
     }printf("%lld\n",ans);
 }

T3：笨小猴

 #include<cstdio>
 #include<set>
 using namespace std;
 struct A{int a,b,o;friend bool operator<(A x,A y){return x.a<y.a;}};
 struct B{int a,b,o;friend bool operator<(B x,B y){return x.b<y.b;}};
 set<A>as[];set<B>bs[];
 int st[],n;long long ala,alb,tota,totb;
 int main(){
     freopen("grandmaster.in","r",stdin);
     freopen("grandmaster.out","w",stdout);
     scanf("%d",&n);
     for(int i=,a,b;i<=n+;++i){
         scanf("%d%d",&a,&b);
         ala+=a;alb+=b;tota+=a;totb+=b;
         as[].insert((A){a,b,i});
         bs[].insert((B){a,b,i});
     }
     for(int i=,a,b;i<=n;++i){
         scanf("%d%d",&a,&b);
         tota+=a;totb+=b;st[n++i]=;
         as[].insert((A){a,b,n++i});
         bs[].insert((B){a,b,n++i});
     }
     if(ala>tota-ala&&alb>totb-alb){for(int i=;i<=n+;++i)printf("%d\n",i);return ;}
     if(ala<=tota-ala&&alb<=totb-alb){for(int i=n;i<=n+n+;++i)printf("%d\n",i);return ;}
     int nst=;
     while(){
         ala=tota-ala;alb=totb-alb;//printf("%lld %lld\n",ala,alb);
         if(ala<=tota-ala){
             A c=*(--as[nst].end());B d=(B){c.a,c.b,c.o};//printf("--%d %d %d\n",c.a,c.b,c.o);
             as[nst].erase(c);bs[nst].erase(d);
             nst^=;as[nst].insert(c);bs[nst].insert(d);
             ala+=c.a;alb+=c.b;st[c.o]=nst;
         }else{
             B c=*(--bs[nst].end());A d=(A){c.a,c.b,c.o};//printf("--%d %d %d\n",c.a,c.b,c.o);
             bs[nst].erase(c);as[nst].erase(d);
             nst^=;bs[nst].insert(c);as[nst].insert(d);
             ala+=c.a;alb+=c.b;st[c.o]=nst;
         }
         if(ala>tota-ala&&alb>totb-alb){for(int i=;i<=n+n+;++i)if(st[i]==nst)printf("%d\n",i);return ;}
     }
 }

有正确性的。。。乱写

正解很好啊。所有物品按照A排序，选出每一对里B较大的一个。再选出最后一个。

这样的话如果在一对里A大的B也大，那么直接删除这一对就可以继续考虑剩下的问题。

那么到最后你剩下的就是一堆按A排序的牌，它们的每一对你都选了第一张。

然后因为我们还选了最后一张，所以我们其实可以把第一张牌扔掉再次进行配对。

可以发现每一对牌里A大的B也大了。所以决策合法。

题挺好，思路也挺好，就是数据没法造。