CSPS模拟86-87

模拟86

T1，烧水，按位统计贡献，利用某种sao操作避免数位dp

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 const int mod=;
 using namespace std;
 int n,m;
 int dp1[],sum[];
 int bin[];
 inline void get1(int x)
 {
     memset(dp1,,sizeof(dp1));
     if(x<)return;
     for(int i=;~i;--i)
     {
         dp1[i]=(x>>(i+))+;
         if(x&bin[i])dp1[i]=1ll*bin[i]*dp1[i]%mod;
         else{
             dp1[i]=1ll*(x>>(i+))*bin[i]%mod;
             dp1[i]+=(x&(bin[i]-));++dp1[i];
             if(dp1[i]>=mod)dp1[i]-=mod;
         }
     }
 }
 int main()
 {
     for(int i=;i<=;++i)bin[i]=<<i;
     int T;scanf("%d",&T);
     while(T--)
     {
         scanf("%d%d",&m,&n);
         memset(sum,,sizeof(sum));
         get1(n);
         for(int i=;i<=;++i)sum[i]+=dp1[i];
         get1(m-);
         for(int i=;i<=;++i)sum[i]-=dp1[i];
         int ans=;const int num=n-m+;
         for(int i=;i<=;++i)
         {
             ans+=2ll*sum[i]%mod*(num-sum[i])%mod*bin[i]%mod;
             if(ans>=mod)ans-=mod;
         }
         ans=((ans%mod)+mod)%mod;
         cout<<ans<<endl;

     }
 }

T2，博弈，考场上推出了最小为0时的答案，以为能找出规律，连暴力都没打，kuku

正解为用必败状态筛必胜状态来保证复杂度。%%%脸哥压表，处理出不合法状态hash掉，最后在数组里lower_bound即可。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define re register
 using namespace std;
 int n,m;
 int a[];
 char dp[][][];
 int main()
 {
     for(re short i=;i<=;++i)
     {
         for(re short j=;j<=;++j)
         {
             for(re short k=;k<=;++k)
             {
                 if(dp[i][j][k])continue;
                 for(re short o=;o+i<=;++o)dp[i+o][j][k]=;
                 for(re short o=;o+j<=;++o)dp[i][j+o][k]=;
                 for(re short o=;o+k<=;++o)dp[i][j][k+o]=;
                 for(re short o=;o+i<=&&o+j<=;++o)dp[i+o][j+o][k]=;
                 for(re short o=;o+i<=&&o+k<=;++o)dp[i+o][j][k+o]=;
                 for(re short o=;o+k<=&&o+j<=;++o)dp[i][j+o][k+o]=;
                 for(re short o=;o+i<=&&o+k<=&&o+j<=;++o)dp[i+o][j+o][k+o]=;
             }
         }
     }
     int T;scanf("%d",&T);
     while(T--)
     {
         scanf("%d%d%d",&a[],&a[],&a[]);
         if(dp[a[]][a[]][a[]])puts("Yes");
         else puts("No");
     }
 }

T3，dp，对前缀和取max优化。考场上想出了第三维表示四个状态（顶峰，底端，上升，下降），然而没想到转移。

在最外层枚举区间数，对四种状态用4个变量分别维护最优点转移即可。%%%WWB_star，rnb，milk_feng让我认识到自己的错误

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define N 30040
 using namespace std;
 int n,K,ans;
 int a[N],sum[N],dp[][N][];
 const int inf=0x3f3f3f3f;
 int main()
 {
     memset(dp,-0x3f,sizeof(dp));
     scanf("%d%d",&n,&K);
     for(int i=;i<=n;++i)
         scanf("%d",&a[i]),sum[i]=sum[i-]+a[i];
     int mi=,ma=,mi2=,ma2=;
     for(int i=;i<=n;++i){
         dp[][i][]=sum[i]-mi;
         dp[][i][]=ma-sum[i];
         dp[][i][]=dp[][i][];
         dp[][i][]=dp[][i][];
         mi=min(mi,sum[i]);ma=max(ma,sum[i]);
     }
     for(int j=;j<K;++j){
         mi=ma=mi2=ma2=-inf;
         for(int i=j-;i<=n;++i)
         {
             dp[j][i][]=max(dp[j][i][],ma+*sum[i]);
             dp[j][i][]=max(dp[j][i][],mi-*sum[i]);

             dp[j][i][]=max(dp[j][i][],mi2);
             dp[j][i][]=max(dp[j][i][],ma2);
             mi=max(mi,dp[j-][i][]+sum[i]*);
             mi=max(mi,dp[j-][i][]+sum[i]*);

             ma=max(ma,dp[j-][i][]-sum[i]*);
             ma=max(ma,dp[j-][i][]-sum[i]*);

             ma2=max(ma2,dp[j-][i][]);
             ma2=max(ma2,dp[j-][i][]);

             mi2=max(mi2,dp[j-][i][]);
             mi2=max(mi2,dp[j-][i][]);
         }
     }
     mi=ma=mi2=ma2=-inf;
     for(int i=K-;i<=n;++i)
     {
         dp[K][i][]=max(dp[K][i][],ma+sum[i]);
         dp[K][i][]=max(dp[K][i][],mi-sum[i]);

         dp[K][i][]=max(dp[K][i][],mi2);
         dp[K][i][]=max(dp[K][i][],ma2);

         mi=max(mi,dp[K-][i][]+sum[i]);
         mi=max(mi,dp[K-][i][]+sum[i]);

         ma=max(ma,dp[K-][i][]-sum[i]);
         ma=max(ma,dp[K-][i][]-sum[i]);

         ma2=max(ma2,dp[K-][i][]);
         ma2=max(ma2,dp[K-][i][]);

         mi2=max(mi2,dp[K-][i][]);
         mi2=max(mi2,dp[K-][i][]);

         ans=max(ans,dp[K][i][]);
         ans=max(ans,dp[K][i][]);
     }
     printf("%d\n",ans);
 }

300

145

120

50

110

220

122

160

130

这个故事告诉我们：rp是个好东西（别败光了）

模拟87，新的开始，勉强苟住位置（抢到Dybala的第八）

T1，（妹子）maze

考场上想了半天才想到是二分答案。然后就疯狂码码码，打了个代码测时长，发现极限数据甚至会达到十几秒，然后疯狂卡常

最后当我手打堆打到一半，发现我的结构体重载运算符重载反了，赶紧改过来，发现还剩1分钟，慌的一比。。。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<bitset>
 #include<vector>
 #include<cmath>
 #include<queue>
 #define N 105
 using namespace std;
 const double eps=1e-;
 const int dx[]={,-,,};
 const int dy[]={,,,-};
 int n,m,sx,sy,tx,ty;
 bool vst[N][N];
 double dis[N][N],s;
 int a[N][N];
 struct node{
     int x;
     int y;
     double z;
     friend bool operator <(const node &a,const node &b)
     {return a.z>b.z;}
 };
 /*
 struct QAQ{
     node a[100500];
     int tot;
     inline int size(){return tot;}
     inline void clear(){tot=0;}
     inline node top(){return a[1];}
     inline void pop()
     {
         a[1]=a[tot++];int i=1,j;
         while(1)
         {
             j=i<<1;
             if(j>tot)return;
             if(a[j+1]<a[j])
         }
     }

 }
 */
 priority_queue<node>q;
 inline void init()
 {
     for(register int i=;i<=n;++i)
         for(register int j=;j<=m;++j)
             dis[i][j]=1000000.0;
 }
 inline node mknd(int x,int y,double z)
 {
     node a;a.x=x,a.y=y,a.z=z;return a;
 }
 inline void dijk(double val)
 {
     while(q.size())q.pop();init();
     dis[sx][sy]=0.0;
     q.push(mknd(sx,sy,0.0));
     int xx,yy,x,y;double z;
     while(q.size())
     {
         x=q.top().x;y=q.top().y;z=q.top().z;q.pop();
         if(z!=dis[x][y])continue;if(x==tx&&y==ty)return;
         for(register int i=;~i;--i)
         {
             xx=x+dx[i];yy=y+dy[i];
             if(a[xx][yy])continue;
             if(dx[i])
             {
                 if(dis[xx][yy]>z+val)
                 {
                     dis[xx][yy]=z+val;
                     q.push(mknd(xx,yy,dis[xx][yy]));
                 }
             }
             else
             {
                 if(dis[xx][yy]>z+1.0)
                 {
                     dis[xx][yy]=z+1.0;
                     q.push(mknd(xx,yy,dis[xx][yy]));
                 }
             }
         }
     }
 }
 inline void work()
 {
     double l=0.0,r=s,mid;
     while(r-l>3e-){
         mid=(l+r)*0.5;dijk(mid);
         if(dis[tx][ty]-s>0.0)r=mid;
         else l=mid;
         if(fabs(dis[tx][ty]-s)<5e-){l=mid;break;}
 //        printf("%.10lf %.10lf\n",l,r);
     }
     printf("%.3lf\n",l);
 }
 int main()
 {
 //    freopen("da.in","r",stdin);//freopen("my.out","w",stdout);
     scanf("%d%d%d%d%d%d",&n,&m,&sx,&sy,&tx,&ty);
     for(int i=;i<=n;++i)
         for(int j=,x;j<=m;++j)
             scanf("%d",&x),a[i][j]=x;

     a[sx][sy]=a[tx][ty]=;
     dijk(1.0);if(dis[tx][ty]>100000.0)return ;
     for(int i=;i<=n;++i)a[i][]=a[i][m+]=;
     for(int i=;i<=m;++i)a[][i]=a[n+][i]=;
     scanf("%lf",&s);work();return ;
 }
 /*
 4 4
 1 1 4 4
 0 0 1 1
 1 0 0 0
 0 0 1 0
 0 0 0 0
 5
 */

T2，bird

线段树稍显然，考虑去除重复贡献，用到了一些差分的思想，在左端点加入区间，右点存左点，dp值单点插入时暂且不加当前贡献，扫到右端点再加，保证不重复

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<bitset>
 #include<vector>
 #include<queue>
 #define N 500050
 using namespace std;
 int n,m;
 vector<int>v[N];
 int sum[N],dp[N];
 struct node{
     int l,r;
 }q[];
 int A,ans;
 int ma[N<<],tag[N<<];
 inline void upd(int g){ma[g]=max(ma[g<<],ma[g<<|]);}
 inline void down(int g)
 {
     tag[g<<]+=tag[g];
     ma[g<<]+=tag[g];
     tag[g<<|]+=tag[g];
     ma[g<<|]+=tag[g];
     tag[g]=;
 }
 inline void add(int g,int l,int r,int x,int y,int v)
 {
     if(l>y||r<x)return;
     if(l>=x&&r<=y){ma[g]+=v;tag[g]+=v;return;}
     if(tag[g])down(g);
     const int m=l+r>>;
     add(g<<,l,m,x,y,v);add(g<<|,m+,r,x,y,v);
     upd(g);
 }
 inline int ask(int g,int l,int r,int x,int y)
 {
     if(l>y||r<x)return ;
     if(l>=x&&r<=y)return ma[g];
     if(tag[g])down(g);
     const int m=l+r>>;
     const int a1=ask(g<<,l,m,x,y),a2=ask(g<<|,m+,r,x,y);
     if(a1>a2)return a1;return a2;
 }
 int main()
 {
     scanf("%d%d",&n,&m);
     for(int i=,l,r;i<=n;++i)
     {
         scanf("%d%d",&l,&r);
         if(r<)continue;
         if(l<)l=;
         v[r+].push_back(l);
         if(r>A)A=r;
         ++sum[l];
     }
     ++A;int al=;
     for(int i=;i<=A;++i)
     {
         al+=sum[i];
         for(int j=;j<v[i].size();++j)
             add(,,A,v[i][j],i-,),--al;
         dp[i]=ask(,,A,,i-m);
         ans=max(ans,dp[i]+al);
         add(,,A,i,i,dp[i]);
     }
     cout<<ans<<endl;
     return ;
 }

T3，%%%脸哥

话说脸哥是不是把推荐和反对放反了啊？