csp-s模拟99题解

题面：https://www.cnblogs.com/Juve/articles/11791219.html

上来先看T1，发现和之前做过的treap一样，是线段树维护单调栈，然后打了一个小时，然后它挂了

于是看后面的题，然后T2：woc它说的是什么？怎么这么多变量？貌似k=2可以大力分类讨论？

写了半个小时，发现恶心至极，然后puts("-1")就跑了

T3好像有暴力？打了个搜索，一遍过样例，应该有40分了吧，在加上T1暴力就60分了

突然发现T1可以分块直接艹过，果断分块，然后过样例，对拍出锅，

对拍发现了4出错误，然后改完了发现我的分块会被卡成n方？

如果是一个单增的序列，然后他要修改一个特别靠前的位置，我就成n²了，但是这种数据倒也跑的挺快，只是对拍不过

最后半个小时，检查了一下文件名，然后T3本着骗分的原则我按a+b排序从大到小输出

然后改了改T1，发现它过拍了，然后就这样了，一直到考试结束，感觉T1可能会被卡

期望得分：80+10+30=120

实际得分：100+10+100=210！！？？

T3不是正解居然A了。。。我rp估计要掉光了，然后T1没有被卡？？！！

其实$nlog^2n$和$n\sqrt{n}$复杂度差不多，卡我时间还是挺难的，虽说正解只有一个log，但是常数没有分块优秀

T1：

说是分块其实就是优化的暴力

预处理原序列的前缀答案，前缀最大值，块内最值，

那么每次修改对于前面的答案没有影响，直接接过来，然后在本块中跑暴力，把修改位置所在块的贡献加上，同时记录到当前块的最大值

然后扫后面的块，如果块内最大值比当前最大值小，那么这个块没有用，反之就暴力更新块内的答案

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #define re register
 using namespace std;
 const int MAXN=1e5+;
 inline int read(){
     re int x=,f=;re char ch=getchar();
     while(ch<''||ch>''){
         if(ch=='-') f=-;
         ch=getchar();
     }
     while(ch>=''&&ch<=''){
         x=(x<<)+(x<<)+ch-'';
         ch=getchar();
     }
     return x*f;
 }
 int n,m,a[MAXN],pos[MAXN],b[MAXN],d[MAXN],maxx=;
 int blo,bel[MAXN],l[MAXN],r[MAXN],tot,mx[MAXN],len[MAXN],fmx[MAXN],smx[MAXN],p[MAXN];
 signed main(){
     freopen("TaoPApp.in","r",stdin);
     freopen("TaoPApp.out","w",stdout);
     n=read(),m=read();
     blo=sqrt(n)+;
     tot=n/blo;
     if(n%blo) ++tot;
     for(re int i=;i<=n;++i){
         a[i]=read();
         bel[i]=(i-)/blo+;
     }
     for(re int i=;i<=tot;++i){
         l[i]=r[i-]+;
         r[i]=i*blo;
     }
     r[tot]=min(r[tot],n);
     for(re int i=;i<=tot;++i){
         for(re int j=l[i];j<=r[i];++j){
             if(fmx[i]<=a[j]){
                 fmx[i]=a[j];
                 p[i]=j;
             }
         }
         for(re int j=l[i];j<=r[i];++j){
             if(j!=p[i]&&smx[i]<=a[j]){
                 smx[i]=a[j];
             }
         }
     }
     for(re int i=;i<=n;++i){
         mx[i]=max(mx[i-],a[i]);
         len[i]=len[i-];
         if(maxx<a[i]){
             maxx=a[i];
             ++len[i];
         }
     }
     for(re int i=;i<=m;++i){
         pos[i]=read(),b[i]=read();
         re int tmp=a[pos[i]];
         a[pos[i]]=b[i];
         re int c=bel[pos[i]];//当前块
         re int res=len[l[c]-];//当前块前的答案
         re int zd=mx[l[c]-];//上一个块前的最大值
         for(re int j=l[c];j<=r[c];++j){
             if(zd<a[j]){
                 zd=a[j];
                 ++res;
             }
         }
         if(pos[i]!=p[c]){
             for(re int j=c+;j<=tot;++j){
                 if(mx[r[j]]<=zd) continue;
                 for(re int k=l[j];k<=r[j];++k){
                     //++tot;
                     if(zd<a[k]){
                         zd=a[k];
                         ++res;
                     }
                 }
                 res+=len[n]-len[r[j]];
                 break;
             }
             printf("%d\n",res);
             a[pos[i]]=tmp;
         }else{
             re int tmpp=max(zd,smx[c]);
             tmpp=max(tmpp,b[i]);
             for(re int j=c+;j<=tot;++j){
                 if(fmx[j]<=tmpp) continue;
                 for(re int k=l[j];k<=r[j];++k){
                     if(tmpp<a[k]){
                         tmpp=a[k];
                         ++res;
                     }
                 }
             }
             printf("%d\n",res);
             a[pos[i]]=tmp;
         }
     }
     return ;
 }
 /*
 5 3
 1 2 3 4 4
 1 5
 5 5
 2 3
 */

T2：

贪心+模拟

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<set>
 #define int long long
 using namespace std;
 const int MAXN=5e4+;
 inline int read(){
     int x=,f=;char ch=getchar();
     while(ch<''||ch>''){if(ch=='-') f=-;ch=getchar();}
     while(ch>=''&&ch<=''){x=(x<<)+(x<<)+ch-'';ch=getchar();}
     return x*f;
 }
 int k,c[MAXN],d[MAXN],m[MAXN],p[MAXN],e[MAXN],r[MAXN],E[MAXN],cst,tot=,ans=;
 struct node{
     int num,cost;
     friend bool operator < (node a,node b){
         return a.cost<b.cost;
     }
 };
 multiset<node>s1,s2;
 signed main(){
     freopen("happy.in","r",stdin);
     freopen("happy.out","w",stdout);
     k=read();
     for(int i=;i<=k;++i) c[i]=read(),d[i]=read(),m[i]=read(),p[i]=read();
     for(int i=;i<k;++i) e[i]=read(),r[i]=read(),E[i]=read();
     cst=c[];
     for(int i=;i<=k;++i){
         if(p[i]) s1.insert((node){p[i],m[i]+cst});
         tot+=p[i];
         while(d[i]){
             if(s1.empty()){
                 puts("-1");
                 return ;
             }
             node x=*s1.begin();
             int num=min(d[i],x.num);
             s1.erase(s1.begin());
             ans+=x.cost*num;
             x.num-=num,tot-=num,d[i]-=num;
             if(x.num) s1.insert(x);
         }
         if(i!=k){
             cst=min(cst+r[i],c[i+]);
             while(tot>e[i]){
                 node x=*--s1.end();
                 int num=min(tot-e[i],x.num);
                 s1.erase(--s1.end());
                 tot-=num,x.num-=num;
                 if(x.num) s1.insert(x);
             }
             for(multiset<node>::iterator it=s1.begin();it!=s1.end();++it){
                 s2.insert((node){(*it).num,(*it).cost+E[i]});
             }
             swap(s1,s2),s2.clear();
         }
     }
     printf("%lld\n",ans);
     return ;
 }

T3：

按a排序，保留最大的A，然后在剩下的里面两两分组，组内取b较大的

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define int long long
 using namespace std;
 const int MAXN=4e5+;
 int n;
 struct node{
     int a,b,id;
     friend bool operator < (node aa,node bb){
         return aa.a==bb.a?aa.b>bb.b:aa.a>bb.a;
     }
 }p[MAXN];
 signed main(){
     freopen("grandmaster.in","r",stdin);
     freopen("grandmaster.out","w",stdout);
     scanf("%lld",&n);
     for(int i=;i<=*n+;++i){
         scanf("%lld%lld",&p[i].a,&p[i].b);
         p[i].id=i;
     }
     sort(p+,p+*n++);
     printf("%lld\n",p[].id);
     for(int i=;i<=*n+;i+=){
         if(p[i].b>p[i+].b){
             printf("%lld\n",p[i].id);
         }
         else printf("%lld\n",p[i+].id);
     }
     return ;
 }