CSPS模拟88-91

感觉自己好菜啊，考得一次不如一次了。。。压力好大，++滚粗感。

模拟88。

T1，sbt，发现离散化后数据范围变为6000，直接跑暴力即可。%%%机房众神斜率优化。

T2，大模拟，考场上只会乱搞骗分。本人菜鸡，只会大力分类讨论。。。

  1 #include
  2 using namespace std;
  3 const double eps=5e-5;
  4 double f[100][100],f1[100][100],f2[100][100];
  5 double dp[110][10][10][10][10];
  6 double ans[6][10];
  7 int a[6][10],tt[10];
  8 int n;
  9 char s1[20],s2[20],s3[20];
 10 double gg;
 11 inline void prans(int id)
 12 {
 13     double gg=1.0;
 14     memset(ans,0,sizeof(ans));
 15     for(int j=1;j<=8;++j)
 16         for(int k=1;k<=8;++k)
 17             for(int o=1;o<=8;++o)
 18                 for(int l=1;l<=8;++l)
 19                 {
 20                     gg-=dp[id][j][k][o][l];
 21                     ans[1][a[1][j]]+=dp[id][j][k][o][l];
 22                     ans[2][a[2][k]]+=dp[id][j][k][o][l];
 23                     ans[3][a[3][o]]+=dp[id][j][k][o][l];
 24                     ans[4][a[4][l]]+=dp[id][j][k][o][l];
 25                 }
 26     printf("%.2lf\n",gg*100);
 27     for(int i=1;i<=4;++i)
 28     {
 29         for(int j=1;j<=8;++j)
 30         {
 31             printf("%.2lf ",ans[i][j]*100);
 32         }
 33         puts("");
 34     }
 35 }
 36 inline void init()
 37 {
 38     f[1][0]=f[1][1]=f[1][2]=1.0/3;
 39     for(int i=1;i<=80;++i){
 40         for(int j=0;j<=80;++j){
 41             if(j)f1[i][j]=f1[i][j-1];
 42             f1[i][j]+=f[i][j];
 43             f[i+1][j]+=f[i][j]*f[1][0];
 44             f[i+1][j+1]+=f[i][j]*f[1][1];
 45             f[i+1][j+2]+=f[i][j]*f[1][2];
 46         }
 47         for(int j=80;~j;--j)f2[i][j]=f2[i][j+1]+f[i][j];
 48     }
 49 }
 50 void work1(int m,int i,int num,int isw,double g=1.0,int fj=1,int fk=1,int fo=1,int fl=1,int jj=8,int kk=8,int oo=8,int ll=8)
 51 {
 52     if(m==1)
 53     {
 54         if(isw)
 55         {
 56             for(int j=fj;j<=jj;++j)
 57                 for(int k=fk;k<=kk;++k)
 58                     for(int o=fo;o<=oo;++o)
 59                         for(int l=fl;l<=ll;++l)
 60                             for(int t=0;t<=2*num;++t)
 61                                 dp[i+1][min(j+t,8)][k][o][l]+=dp[i][j][k][o][l]*f[num][t]*g;
 62         }
 63         else
 64         {
 65             for(int j=fj;j<=jj;++j)
 66                 for(int k=fk;k<=kk;++k)
 67                     for(int o=fo;o<=oo;++o)
 68                         for(int l=fl;l<=ll;++l)
 69                             dp[i+1][min(j+num,8)][k][o][l]+=dp[i][j][k][o][l]*g;
 70         }
 71     }
 72     else if(m==2)
 73     {
 74         if(isw)
 75         {
 76             for(int j=fj;j<=jj;++j)
 77                 for(int k=fk;k<=kk;++k)
 78                     for(int o=fo;o<=oo;++o)
 79                         for(int l=fl;l<=ll;++l)
 80                             for(int t=0;t<=2*num;++t)
 81                                 dp[i+1][j][min(k+t,8)][o][l]+=dp[i][j][k][o][l]*f[num][t]*g;
 82         }
 83         else
 84         {
 85             for(int j=fj;j<=jj;++j)
 86                 for(int k=fk;k<=kk;++k)
 87                     for(int o=fo;o<=oo;++o)
 88                         for(int l=fl;l<=ll;++l)
 89                             dp[i+1][j][min(k+num,8)][o][l]+=dp[i][j][k][o][l]*g;
 90         }
 91     }
 92     else if(m==3)
 93     {
 94         if(isw)
 95         {
 96             for(int j=fj;j<=jj;++j)
 97                 for(int k=fk;k<=kk;++k)
 98                     for(int o=fo;o<=oo;++o)
 99                         for(int l=fl;l<=ll;++l)
100                             for(int t=0;t<=2*num;++t)
101                                 dp[i+1][j][k][min(o+t,8)][l]+=dp[i][j][k][o][l]*f[num][t]*g;
102         }
103         else
104         {
105             for(int j=fj;j<=jj;++j)
106                 for(int k=fk;k<=kk;++k)
107                     for(int o=fo;o<=oo;++o)
108                         for(int l=fl;l<=ll;++l)
109                             dp[i+1][j][k][min(o+num,8)][l]+=dp[i][j][k][o][l]*g;
110         }
111     }
112     else
113     {
114         if(isw)
115         {
116             for(int j=fj;j<=jj;++j)
117                 for(int k=fk;k<=kk;++k)
118                     for(int o=fo;o<=oo;++o)
119                         for(int l=fl;l<=ll;++l)
120                             for(int t=0;t<=2*num;++t)
121                                 dp[i+1][j][k][o][min(l+t,8)]+=dp[i][j][k][o][l]*f[num][t]*g;
122         }
123         else
124         {
125             for(int j=fj;j<=jj;++j)
126                 for(int k=fk;k<=kk;++k)
127                     for(int o=fo;o<=oo;++o)
128                         for(int l=fl;l<=ll;++l)
129                             dp[i+1][j][k][o][min(l+num,8)]+=dp[i][j][k][o][l]*g;
130         }
131     }
132 }
133 //////////////////////////////////////////////////分界线work1&2///////////////////////////////////////////////////////////////
134 void work2(int m,int i,int num,int isw,double g=1.0,int fj=1,int fk=1,int fo=1,int fl=1,int jj=8,int kk=8,int oo=8,int ll=8)
135 {
136     if(m==1)
137     {
138         if(isw)
139         {
140             for(int j=fj;j<=jj;++j)
141                 for(int k=fk;k<=kk;++k)
142                     for(int o=fo;o<=oo;++o)
143                         for(int l=fl;l<=ll;++l)
144                             for(int t=0;t<=2*num;++t)
145                                 dp[i+1][max(j-t,0)][k][o][l]+=dp[i][j][k][o][l]*f[num][t]*g;
146         }
147         else
148         {
149             for(int j=fj;j<=jj;++j)
150                 for(int k=fk;k<=kk;++k)
151                     for(int o=fo;o<=oo;++o)
152                         for(int l=fl;l<=ll;++l)
153                             dp[i+1][max(j-num,0)][k][o][l]+=dp[i][j][k][o][l]*g;
154         }
155     }
156     else if(m==2)
157     {
158         if(isw)
159         {
160             for(int j=fj;j<=jj;++j)
161                 for(int k=fk;k<=kk;++k)
162                     for(int o=fo;o<=oo;++o)
163                         for(int l=fl;l<=ll;++l)
164                             for(int t=0;t<=2*num;++t)
165                                 dp[i+1][j][max(k-t,0)][o][l]+=dp[i][j][k][o][l]*f[num][t]*g;
166         }
167         else
168         {
169             for(int j=fj;j<=jj;++j)
170                 for(int k=fk;k<=kk;++k)
171                     for(int o=fo;o<=oo;++o)
172                         for(int l=fl;l<=ll;++l)
173                             dp[i+1][j][max(k-num,0)][o][l]+=dp[i][j][k][o][l]*g;
174         }
175     }
176     else if(m==3)
177     {
178         if(isw)
179         {
180             for(int j=fj;j<=jj;++j)
181                 for(int k=fk;k<=kk;++k)
182                     for(int o=fo;o<=oo;++o)
183                         for(int l=fl;l<=ll;++l)
184                             for(int t=0;t<=2*num;++t)
185                                 dp[i+1][j][k][max(o-t,0)][l]+=dp[i][j][k][o][l]*f[num][t]*g;
186         }
187         else
188         {
189             for(int j=fj;j<=jj;++j)
190                 for(int k=fk;k<=kk;++k)
191                     for(int o=fo;o<=oo;++o)
192                         for(int l=fl;l<=ll;++l)
193                             dp[i+1][j][k][max(o-num,0)][l]+=dp[i][j][k][o][l]*g;
194         }
195     }
196     else
197     {
198         if(isw)
199         {
200             for(int j=fj;j<=jj;++j)
201                 for(int k=fk;k<=kk;++k)
202                     for(int o=fo;o<=oo;++o)
203                         for(int l=fl;l<=ll;++l)
204                             for(int t=0;t<=2*num;++t)
205                                 dp[i+1][j][k][o][max(l-t,0)]+=dp[i][j][k][o][l]*f[num][t]*g;
206         }
207         else
208         {
209             for(int j=fj;j<=jj;++j)
210                 for(int k=fk;k<=kk;++k)
211                     for(int o=fo;o<=oo;++o)
212                         for(int l=fl;l<=ll;++l)
213                             dp[i+1][j][k][o][max(l-num,0)]+=dp[i][j][k][o][l]*g;
214         }
215     }
216 }
217 
218 int main()
219 {
220 //    freopen("da.in","r",stdin);
221     init();
222     for(int i=1,x;i<=4;++i){
223         scanf("%d%d",&a[i][8],&tt[i]);
224         for(int j=8;j;--j){a[i][j-1]=a[i][j]/10;a[i][j]%=10;}
225     }
226     dp[1][tt[1]][tt[2]][tt[3]][tt[4]]=1.0;
227     scanf("%d",&n);
228     /*
229     t1:当前处理点
230     t2:受影响点
231     i:当前处理的操作
232     l2:数字串长度，对？处理
233     tag:标记是否有问号
234     tg2:标记是否有=
235     */
236     for(int i=1,t1,t2,l2,num,tag,tg2;i<=n;++i)//work2(int m,int i,int num,int isw)
237     {
238 //        if(i==5)prans(i);
239         t1=l2=tag=num=tg2=0;
240         scanf("%s%s",s1,s2+1);
241         l2=strlen(s2+1);
242         if(s1[1]=='i')t1=1;
243         else if(s1[1]=='p')t1=2;
244         else if(s1[1]=='a')t1=3;
245         else t1=4;
246         switch(s2[1])
247         {
248             case '<':
249             {
250                 scanf("%d",&tg2);
251                 if(l2==2)++tg2;
252                 scanf("%s%s",s1,s2+1);
253                 if(s1[1]=='i')t2=1;
254                 else if(s1[1]=='p')t2=2;
255                 else if(s1[1]=='a')t2=3;
256                 else t2=4;
257 
258                 l2=strlen(s2+1);
259                 for(int j=2;j10+s2[j]-'0';
260                 if(s2[l2]=='?')tag=1;
261                 else num=num*10+s2[l2]-'0';
262                 for(int j=1;j<=8;++j)
263                     for(int k=1;k<=8;++k)
264                         for(int o=1;o<=8;++o)
265                             for(int l=1;l<=8;++l){
266                                 if(t1==1)
267                                 {
268                                     for(int tmd=0;tmd<=2*a[1][j];++tmd)
269                                     {
270                                         if(tmd>=tg2)
271                                         {
272                                             dp[i+1][j][k][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
273                                             continue;
274                                         }
275                                         if(t2==1)
276                                         {
277                                             if(tag){
278                                                 for(int t=0;t<=num*2;++t){
279                                                     if(s2[1]=='+')dp[i+1][min(j+t,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
280                                                     else dp[i+1][max(j-t,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
281                                                 }
282                                             }
283                                             else
284                                             {
285                                                 if(s2[1]=='+')dp[i+1][min(j+num,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
286                                                 else dp[i+1][max(j-num,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
287                                             }
288                                         }
289                                         else if(t2==2)
290                                         {
291                                             if(tag){
292                                                 for(int t=0;t<=num*2;++t){
293                                                     if(s2[1]=='+')dp[i+1][j][min(k+t,8)][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
294                                                     else dp[i+1][j][max(k-t,0)][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
295                                                 }
296                                             }
297                                             else
298                                             {
299                                                 if(s2[1]=='+')dp[i+1][j][min(k+num,8)][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
300                                                 else dp[i+1][j][max(k-num,0)][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
301                                             }
302                                         }
303                                         else if(t2==3)
304                                         {
305                                             if(tag){
306                                                 for(int t=0;t<=num*2;++t){
307                                                     if(s2[1]=='+')dp[i+1][j][k][min(o+t,8)][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
308                                                     else dp[i+1][j][k][max(o-t,0)][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
309                                                 }
310                                             }
311                                             else
312                                             {
313                                                 if(s2[1]=='+')dp[i+1][j][k][min(o+num,8)][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
314                                                 else dp[i+1][j][k][max(o-num,0)][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
315                                             }
316                                         }
317                                         else
318                                         {
319                                             if(tag){
320                                                 for(int t=0;t<=num*2;++t){
321                                                     if(s2[1]=='+')dp[i+1][j][k][o][min(l+t,8)]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
322                                                     else dp[i+1][j][k][o][max(l-t,0)]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
323                                                 }
324                                             }
325                                             else
326                                             {
327                                                 if(s2[1]=='+')dp[i+1][j][k][o][min(l+num,8)]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
328                                                 else dp[i+1][j][k][o][max(l-num,0)]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
329                                             }
330                                         }
331                                     }
332                                 }
333                                 else if(t1==2)
334                                 {
335                                     for(int tmd=0;tmd<=2*a[2][k];++tmd)
336                                     {
337                                         if(tmd>=tg2)
338                                         {
339                                             dp[i+1][j][k][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
340                                             continue;
341                                         }
342                                         if(t2==1)
343                                         {
344                                             if(tag){
345                                                 for(int t=0;t<=num*2;++t){
346                                                     if(s2[1]=='+')dp[i+1][min(j+t,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
347                                                     else dp[i+1][max(j-t,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
348                                                 }
349                                             }
350                                             else
351                                             {
352                                                 if(s2[1]=='+')dp[i+1][min(j+num,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
353                                                 else dp[i+1][max(j-num,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
354                                             }
355                                         }
356                                         else if(t2==2)
357                                         {
358                                             if(tag){
359                                                 for(int t=0;t<=num*2;++t){
360                                                     if(s2[1]=='+')dp[i+1][j][min(k+t,8)][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
361                                                     else dp[i+1][j][max(k-t,0)][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
362                                                 }
363                                             }
364                                             else
365                                             {
366                                                 if(s2[1]=='+')dp[i+1][j][min(k+num,8)][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
367                                                 else dp[i+1][j][max(k-num,0)][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
368                                             }
369                                         }
370                                         else if(t2==3)
371                                         {
372                                             if(tag){
373                                                 for(int t=0;t<=num*2;++t){
374                                                     if(s2[1]=='+')dp[i+1][j][k][min(o+t,8)][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
375                                                     else dp[i+1][j][k][max(o-t,0)][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
376                                                 }
377                                             }
378                                             else
379                                             {
380                                                 if(s2[1]=='+')dp[i+1][j][k][min(o+num,8)][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
381                                                 else dp[i+1][j][k][max(o-num,0)][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
382                                             }
383                                         }
384                                         else
385                                         {
386                                             if(tag){
387                                                 for(int t=0;t<=num*2;++t){
388                                                     if(s2[1]=='+')dp[i+1][j][k][o][min(l+t,8)]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
389                                                     else dp[i+1][j][k][o][max(l-t,0)]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
390                                                 }
391                                             }
392                                             else
393                                             {
394                                                 if(s2[1]=='+')dp[i+1][j][k][o][min(l+num,8)]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
395                                                 else dp[i+1][j][k][o][max(l-num,0)]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
396                                             }
397                                         }
398                                     }
399                                 }
400                                 else if(t1==3)
401                                 {
402                                     for(int tmd=0;tmd<=2*a[3][o];++tmd)
403                                     {
404                                         if(tmd>=tg2)
405                                         {
406                                             dp[i+1][j][k][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
407                                             continue;
408                                         }
409                                         if(t2==1)
410                                         {
411                                             if(tag){
412                                                 for(int t=0;t<=num*2;++t){
413                                                     if(s2[1]=='+')dp[i+1][min(j+t,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
414                                                     else dp[i+1][max(j-t,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
415                                                 }
416                                             }
417                                             else
418                                             {
419                                                 if(s2[1]=='+')dp[i+1][min(j+num,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
420                                                 else dp[i+1][max(j-num,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
421                                             }
422                                         }
423                                         else if(t2==2)
424                                         {
425                                             if(tag){
426                                                 for(int t=0;t<=num*2;++t){
427                                                     if(s2[1]=='+')dp[i+1][j][min(k+t,8)][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
428                                                     else dp[i+1][j][max(k-t,0)][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
429                                                 }
430                                             }
431                                             else
432                                             {
433                                                 if(s2[1]=='+')dp[i+1][j][min(k+num,8)][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
434                                                 else dp[i+1][j][max(k-num,0)][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
435                                             }
436                                         }
437                                         else if(t2==3)
438                                         {
439                                             if(tag){
440                                                 for(int t=0;t<=num*2;++t){
441                                                     if(s2[1]=='+')dp[i+1][j][k][min(o+t,8)][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
442                                                     else dp[i+1][j][k][max(o-t,0)][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
443                                                 }
444                                             }
445                                             else
446                                             {
447                                                 if(s2[1]=='+')dp[i+1][j][k][min(o+num,8)][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
448                                                 else dp[i+1][j][k][max(o-num,0)][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
449                                             }
450                                         }
451                                         else/////////////////////////////////////////////////////////////////here
452                                         {
453                                             if(tag){
454                                                 for(int t=0;t<=num*2;++t){
455                                             //        cout<
456                                                     if(s2[1]=='+')dp[i+1][j][k][o][min(l+t,8)]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
457                                                     else dp[i+1][j][k][o][max(l-t,0)]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
458                                                 }
459                                             }
460                                             else
461                                             {
462                                                 if(s2[1]=='+')dp[i+1][j][k][o][min(l+num,8)]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
463                                                 else dp[i+1][j][k][o][max(l-num,0)]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
464                                             }
465                                         }
466                                     }
467                                 }
468                                 else
469                                 {
470                                     for(int tmd=0;tmd<=2*a[4][l];++tmd)
471                                     {
472                                         if(tmd>=tg2)
473                                         {
474                                             dp[i+1][j][k][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
475                                             continue;
476                                         }
477                                         if(t2==1)
478                                         {
479                                             if(tag){
480                                                 for(int t=0;t<=num*2;++t){
481                                                     if(s2[1]=='+')dp[i+1][min(j+t,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
482                                                     else dp[i+1][max(j-t,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
483                                                 }
484                                             }
485                                             else
486                                             {
487                                                 if(s2[1]=='+')dp[i+1][min(j+num,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
488                                                 else dp[i+1][max(j-num,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
489                                             }
490                                         }
491                                         else if(t2==2)
492                                         {
493                                             if(tag){
494                                                 for(int t=0;t<=num*2;++t){
495                                                     if(s2[1]=='+')dp[i+1][j][min(k+t,8)][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
496                                                     else dp[i+1][j][max(k-t,0)][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
497                                                 }
498                                             }
499                                             else
500                                             {
501                                                 if(s2[1]=='+')dp[i+1][j][min(k+num,8)][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
502                                                 else dp[i+1][j][max(k-num,0)][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
503                                             }
504                                         }
505                                         else if(t2==3)
506                                         {
507                                             if(tag){
508                                                 for(int t=0;t<=num*2;++t){
509                                                     if(s2[1]=='+')dp[i+1][j][k][min(o+t,8)][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
510                                                     else dp[i+1][j][k][max(o-t,0)][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
511                                                 }
512                                             }
513                                             else
514                                             {
515                                                 if(s2[1]=='+')dp[i+1][j][k][min(o+num,8)][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
516                                                 else dp[i+1][j][k][max(o-num,0)][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
517                                             }
518                                         }
519                                         else
520                                         {
521                                             if(tag){
522                                                 for(int t=0;t<=num*2;++t){
523                                                     if(s2[1]=='+')dp[i+1][j][k][o][min(l+t,8)]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
524                                                     else dp[i+1][j][k][o][max(l-t,0)]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
525                                                 }
526                                             }
527                                             else
528                                             {
529                                                 if(s2[1]=='+')dp[i+1][j][k][o][min(l+num,8)]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
530                                                 else dp[i+1][j][k][o][max(l-num,0)]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
531                                             }
532                                         }
533                                     }
534                                 }
535                             }
536                 break;
537             }
538             case '>':
539             {
540                 scanf("%d",&tg2);
541                 if(l2==2)--tg2;
542                 scanf("%s%s",s1,s2+1);
543                 if(s1[1]=='i')t2=1;
544                 else if(s1[1]=='p')t2=2;
545                 else if(s1[1]=='a')t2=3;
546                 else t2=4;
547 
548                 l2=strlen(s2+1);
549                 for(int j=2;j10+s2[j]-'0';
550                 if(s2[l2]=='?')tag=1;
551                 else num=num*10+s2[l2]-'0';
552 
553                 for(int j=1;j<=8;++j)
554                     for(int k=1;k<=8;++k)
555                         for(int o=1;o<=8;++o)
556                             for(int l=1;l<=8;++l)
557                                 if(t1==1)
558                                 {
559                                     for(int tmd=0;tmd<=2*a[1][j];++tmd)
560                                     {
561                                         if(tmd<=tg2)
562                                         {
563                                             dp[i+1][j][k][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
564                                             continue;
565                                         }
566                                         if(t2==1)
567                                         {
568                                             if(tag){
569                                                 for(int t=0;t<=num*2;++t){
570                                                     if(s2[1]=='+')dp[i+1][min(j+t,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
571                                                     else dp[i+1][max(j-t,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
572                                                 }
573                                             }
574                                             else
575                                             {
576                                                 if(s2[1]=='+')dp[i+1][min(j+num,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
577                                                 else dp[i+1][max(j-num,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
578                                             }
579                                         }
580                                         else if(t2==2)
581                                         {
582                                             if(tag){
583                                                 for(int t=0;t<=num*2;++t){
584                                                     if(s2[1]=='+')dp[i+1][j][min(k+t,8)][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
585                                                     else dp[i+1][j][max(k-t,0)][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
586                                                 }
587                                             }
588                                             else
589                                             {
590                                                 if(s2[1]=='+')dp[i+1][j][min(k+num,8)][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
591                                                 else dp[i+1][j][max(k-num,0)][o][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
592                                             }
593                                         }
594                                         else if(t2==3)
595                                         {
596                                             if(tag){
597                                                 for(int t=0;t<=num*2;++t){
598                                                     if(s2[1]=='+')dp[i+1][j][k][min(o+t,8)][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
599                                                     else dp[i+1][j][k][max(o-t,0)][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
600                                                 }
601                                             }
602                                             else
603                                             {
604                                                 if(s2[1]=='+')dp[i+1][j][k][min(o+num,8)][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
605                                                 else dp[i+1][j][k][max(o-num,0)][l]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
606                                             }
607                                         }
608                                         else
609                                         {
610                                             if(tag){
611                                                 for(int t=0;t<=num*2;++t){
612                                                     if(s2[1]=='+')dp[i+1][j][k][o][min(l+t,8)]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
613                                                     else dp[i+1][j][k][o][max(l-t,0)]+=dp[i][j][k][o][l]*f[a[1][j]][tmd]*f[num][t];
614                                                 }
615                                             }
616                                             else
617                                             {
618                                                 if(s2[1]=='+')dp[i+1][j][k][o][min(l+num,8)]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
619                                                 else dp[i+1][j][k][o][max(l-num,0)]+=dp[i][j][k][o][l]*f[a[1][j]][tmd];
620                                             }
621                                         }
622                                     }
623                                 }
624                                 else if(t1==2)
625                                 {
626                                     for(int tmd=0;tmd<=2*a[2][k];++tmd)
627                                     {
628                                         if(tmd<=tg2)
629                                         {
630                                             dp[i+1][j][k][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
631                                             continue;
632                                         }
633                                         if(t2==1)
634                                         {
635                                             if(tag){
636                                                 for(int t=0;t<=num*2;++t){
637                                                     if(s2[1]=='+')dp[i+1][min(j+t,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
638                                                     else dp[i+1][max(j-t,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
639                                                 }
640                                             }
641                                             else
642                                             {
643                                                 if(s2[1]=='+')dp[i+1][min(j+num,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
644                                                 else dp[i+1][max(j-num,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
645                                             }
646                                         }
647                                         else if(t2==2)
648                                         {
649                                             if(tag){
650                                                 for(int t=0;t<=num*2;++t){
651                                                     if(s2[1]=='+')dp[i+1][j][min(k+t,8)][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
652                                                     else dp[i+1][j][max(k-t,0)][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
653                                                 }
654                                             }
655                                             else
656                                             {
657                                                 if(s2[1]=='+')dp[i+1][j][min(k+num,8)][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
658                                                 else dp[i+1][j][max(k-num,0)][o][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
659                                             }
660                                         }
661                                         else if(t2==3)
662                                         {
663                                             if(tag){
664                                                 for(int t=0;t<=num*2;++t){
665                                                     if(s2[1]=='+')dp[i+1][j][k][min(o+t,8)][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
666                                                     else dp[i+1][j][k][max(o-t,0)][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
667                                                 }
668                                             }
669                                             else
670                                             {
671                                                 if(s2[1]=='+')dp[i+1][j][k][min(o+num,8)][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
672                                                 else dp[i+1][j][k][max(o-num,0)][l]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
673                                             }
674                                         }
675                                         else
676                                         {
677                                             if(tag){
678                                                 for(int t=0;t<=num*2;++t){
679                                                     if(s2[1]=='+')dp[i+1][j][k][o][min(l+t,8)]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
680                                                     else dp[i+1][j][k][o][max(l-t,0)]+=dp[i][j][k][o][l]*f[a[2][k]][tmd]*f[num][t];
681                                                 }
682                                             }
683                                             else
684                                             {
685                                                 if(s2[1]=='+')dp[i+1][j][k][o][min(l+num,8)]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
686                                                 else dp[i+1][j][k][o][max(l-num,0)]+=dp[i][j][k][o][l]*f[a[2][k]][tmd];
687                                             }
688                                         }
689                                     }
690                                 }
691                                 else if(t1==3)
692                                 {
693                                     for(int tmd=0;tmd<=2*a[3][o];++tmd)
694                                     {
695                                         if(tmd<=tg2)
696                                         {
697                                             dp[i+1][j][k][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
698                                             continue;
699                                         }
700                                         if(t2==1)
701                                         {
702                                             if(tag){
703                                                 for(int t=0;t<=num*2;++t){
704                                                     if(s2[1]=='+')dp[i+1][min(j+t,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
705                                                     else dp[i+1][max(j-t,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
706                                                 }
707                                             }
708                                             else
709                                             {
710                                                 if(s2[1]=='+')dp[i+1][min(j+num,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
711                                                 else dp[i+1][max(j-num,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
712                                             }
713                                         }
714                                         else if(t2==2)
715                                         {
716                                             if(tag){
717                                                 for(int t=0;t<=num*2;++t){
718                                                     if(s2[1]=='+')dp[i+1][j][min(k+t,8)][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
719                                                     else dp[i+1][j][max(k-t,0)][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
720                                                 }
721                                             }
722                                             else
723                                             {
724                                                 if(s2[1]=='+')dp[i+1][j][min(k+num,8)][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
725                                                 else dp[i+1][j][max(k-num,0)][o][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
726                                             }
727                                         }
728                                         else if(t2==3)
729                                         {
730                                             if(tag){
731                                                 for(int t=0;t<=num*2;++t){
732                                                     if(s2[1]=='+')dp[i+1][j][k][min(o+t,8)][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
733                                                     else dp[i+1][j][k][max(o-t,0)][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
734                                                 }
735                                             }
736                                             else
737                                             {
738                                                 if(s2[1]=='+')dp[i+1][j][k][min(o+num,8)][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
739                                                 else dp[i+1][j][k][max(o-num,0)][l]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
740                                             }
741                                         }
742                                         else
743                                         {
744 
745                                             if(tag){
746                                                 for(int t=0;t<=num*2;++t){
747                                                     if(s2[1]=='+')dp[i+1][j][k][o][min(l+t,8)]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
748                                                     else dp[i+1][j][k][o][max(l-t,0)]+=dp[i][j][k][o][l]*f[a[3][o]][tmd]*f[num][t];
749                                                 }
750                                             }
751                                             else
752                                             {
753                                                 if(s2[1]=='+')dp[i+1][j][k][o][min(l+num,8)]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
754                                                 else dp[i+1][j][k][o][max(l-num,0)]+=dp[i][j][k][o][l]*f[a[3][o]][tmd];
755                                             }
756                                         }
757                                     }
758                                 }
759                                 else
760                                 {
761                                     for(int tmd=0;tmd<=2*a[4][l];++tmd)
762                                     {
763                                         if(tmd<=tg2)
764                                         {
765                                             dp[i+1][j][k][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
766                                             continue;
767                                         }
768                                         if(t2==1)
769                                         {
770                                             if(tag){
771                                                 for(int t=0;t<=num*2;++t){
772                                                     if(s2[1]=='+')dp[i+1][min(j+t,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
773                                                     else dp[i+1][max(j-t,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
774                                                 }
775                                             }
776                                             else
777                                             {
778                                                 if(s2[1]=='+')dp[i+1][min(j+num,8)][k][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
779                                                 else dp[i+1][max(j-num,0)][k][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
780                                             }
781                                         }
782                                         else if(t2==2)
783                                         {
784                                             if(tag){
785                                                 for(int t=0;t<=num*2;++t){
786                                                     if(s2[1]=='+')dp[i+1][j][min(k+t,8)][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
787                                                     else dp[i+1][j][max(k-t,0)][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
788                                                 }
789                                             }
790                                             else
791                                             {
792                                                 if(s2[1]=='+')dp[i+1][j][min(k+num,8)][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
793                                                 else dp[i+1][j][max(k-num,0)][o][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
794                                             }
795                                         }
796                                         else if(t2==3)
797                                         {
798                                             if(tag){
799                                                 for(int t=0;t<=num*2;++t){
800                                                     if(s2[1]=='+')dp[i+1][j][k][min(o+t,8)][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
801                                                     else dp[i+1][j][k][max(o-t,0)][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
802                                                 }
803                                             }
804                                             else
805                                             {
806                                                 if(s2[1]=='+')dp[i+1][j][k][min(o+num,8)][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
807                                                 else dp[i+1][j][k][max(o-num,0)][l]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
808                                             }
809                                         }
810                                         else
811                                         {
812                                             if(tag){
813                                                 for(int t=0;t<=num*2;++t){
814                                                     if(s2[1]=='+')dp[i+1][j][k][o][min(l+t,8)]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
815                                                     else dp[i+1][j][k][o][max(l-t,0)]+=dp[i][j][k][o][l]*f[a[4][l]][tmd]*f[num][t];
816                                                 }
817                                             }
818                                             else
819                                             {
820                                                 if(s2[1]=='+')dp[i+1][j][k][o][min(l+num,8)]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
821                                                 else dp[i+1][j][k][o][max(l-num,0)]+=dp[i][j][k][o][l]*f[a[4][l]][tmd];
822                                             }
823                                         }
824                                     }
825                                 }
826                 break;
827             }
828             case '+':
829             {
830                 for(int j=2;j10+s2[j]-'0';
831                 if(s2[l2]=='?')tag=1;
832                 else num=num*10+s2[l2]-'0';
833                 work1(t1,i,num,tag);
834                 break;
835             }
836             case '-':
837             {
838                 for(int j=2;j10+s2[j]-'0';
839                 if(s2[l2]=='?')tag=1;
840                 else num=num*10+s2[l2]-'0';
841                 work2(t1,i,num,tag);
842                 break;
843             }
844         }
845     }
846     prans(n+1);
847 }

40K超清代码

T3，dp or 记搜，考场上像一个sb一样打了状压，其实值域只有0，1，2，3。记录每一种有多少个以及上一次的操作即可。注意打高精

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 #define N 13
 7 using namespace std;
 8 int n,a[N],sta;
 9 int bk[N];
10 struct Big_int{
11     int a[60];
12     inline void init(int x){while(x){a[++a[0]]=x%10;x/=10;}}
13     inline bool empty(){return !a[0];}
14 
15     inline void print()
16     {
17         for(int i=a[0];i;--i)printf("%d",a[i]);
18         puts("");
19     }
20 }dp[40][N][N][N][4];
21 inline void add( Big_int &c,const Big_int &x,const int y)
22 {
23     if(!y)return;
24     c.a[0]=max(c.a[0],x.a[0]);int t=0;
25     for(int i=1;i<=c.a[0];++i){
26         c.a[i]+=x.a[i]*y+t;
27         t=c.a[i]/10;c.a[i]%=10;
28     }
29     while(t)c.a[++c.a[0]]=t%10,t/=10;
30     return;
31 }
32 inline void work2()
33 {
34     int al=0,cnt=0;
35     for(int i=1;i<=n;++i)al+=a[i];
36     dp[1][bk[1]][bk[2]+1][bk[3]-1][2].init(bk[3]);
37     dp[1][bk[1]+1][bk[2]-1][bk[3]][1].init(bk[2]);
38     dp[1][bk[1]-1][bk[2]][bk[3]][0].init(bk[1]);
39     for(int o=1;oo)
40         for(int i=0;i<=n;++i)
41             for(int j=0;j<=n;++j)
42                 for(int k=0;k<=n;++k)
43                     for(int p=0;p<=2;++p){
44                         if(dp[o][i][j][k][p].empty())continue;
45 //                        printf("dp[%d][%d][%d][%d][%d]=",o,i,j,k,p);dp[o][i][j][k][p].print();
46                         if(k)add(dp[o+1][i][j+1][k-1][2],dp[o][i][j][k][p],k);
47                         if(j)add(dp[o+1][i+1][j-1][k][1],dp[o][i][j][k][p],j-(p==2));
48                         if(i)add(dp[o+1][i-1][j][k][0],dp[o][i][j][k][p],i-(p==1));
49                     }
50     dp[al][0][0][0][0].print();
51 }
52 int main()
53 {
54     cin>>n;
55     for(int i=1;i<=n;++i)cin>>a[i],++bk[a[i]];
56     work2();return 0;
57 }

View Code

 

模拟89。

T1，正解为图论，然而被各种乱搞*爆，%%%cbx大神打表发现用2，3，5，7筛即可。

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 #define N 1000050
 7 using namespace std;
 8 int ans[N];
 9 int n;
10 bool zhi[N];
11 int pri[N],tot;
12 inline int Min(int x,int y){if(x>y)return y;return x;}
13 int main()
14 {
15 //    freopen("da.in","r",stdin);
16 //    freopen("my.out","w",stdout);
17     ans[0]=1;ans[1]=0;
18     for(int i=2;i<=1000049;++i)ans[i]=i;
19     for(int i=2;i<=1000000;++i){
20         for(int j=i+1;j<=i+4;++j)ans[i]=Min(ans[i],ans[j]+j-i);
21         if(!zhi[i])pri[++tot]=i;
22         for(int j=1;j<=tot&&1ll*i*pri[j]<=1000000;++j)
23         {
24             ans[i*pri[j]]=Min(ans[i*pri[j]],ans[i]+pri[j]);
25             zhi[i*pri[j]]=1;
26         }
27     }
28     scanf("%d",&n);
29     printf("%d\n",ans[n]);
30     return 0;
31 }

本代码各种玄学操作均可用打表or枚举证明

T2，杜教筛and整除分块，考场上打线筛莫比乌斯能拿到40。

 1 #include
 2 #define N 30000500
 3 using namespace std;
 4 long long n,ans;
 5 bool zhi[N];
 6 int pri[N],tot;
 7 char mu[N];
 8 int sum[N];
 9 unordered_map<int,int>H;
10 inline void init(int n)
11 {
12     mu[1]=sum[1]=1;
13     for(int i=2;i<=n;++i){
14         if(!zhi[i])pri[++tot]=i,mu[i]=-1;
15         sum[i]=sum[i-1]+mu[i];
16         for(int j=1;j<=tot&&1ll*i*pri[j]<=n;++j)
17         {
18             zhi[i*pri[j]]=1;
19             if(i%pri[j])mu[i*pri[j]]=-mu[i];
20             else {mu[i*pri[j]]=0;break;}
21         }
22     }
23 }
24 inline int getsm(int x)
25 {
26     if(x<=30000000)return sum[x];
27     if(H.find(x)!=H.end())return H[x];
28     int ret=1;
29     for(int l=2,r;l<=x;l=r+1)
30     {
31         r=x/(x/l);
32         ret-=getsm(x/l)*(r-l+1);
33     }
34     return H[x]=ret;
35 }
36 inline void fenkuai()
37 {
38     int p=sqrt(n);
39     for(int l=2,r;l<=p;l=r+1){
40         r=sqrt(n/(n/l/l));
41         ans+=(getsm(r)-getsm(l-1))*(n/l/l);
42     }
43 }
44 int main()
45 {
46     cin>>n;ans=n;
47     init(30000000);
48     fenkuai();
49     cout<endl;
50     return 0;
51 }

View Code

T3，正解为线段树维护单调栈，按题意模拟打treap可以拿到60（然而考场上删除函数打炸了，只有15分）

  1 #include
  2 #define N 200050
  3 using namespace std;
  4 int n,m,A,lim,w;
  5 int lsh[N];
  6 int a[N];
  7 struct node{int op,x,y;}q[N];
  8 inline int py(int x){return A-x+1;}
  9 struct Segment_tree{
 10     int ma[N<<2],len[N<<2],mi[N<<2],po[N<<2];
 11     void build(int g,int l,int r)
 12     {
 13         len[g]=r-l+1;
 14         if(l==r)return;
 15         const int m=l+r>>1;
 16         build(g<<1,l,m);build(g<<1|1,m+1,r);
 17     }
 18     inline void upd(int g)
 19     {
 20         if(ma[g<<1]>ma[g<<1|1]){ma[g]=ma[g<<1];po[g]=po[g<<1];}
 21         else{ma[g]=ma[g<<1|1];po[g]=po[g<<1|1];}mi[g]=mi[g<<1];
 22     }
 23     inline int ask(int g,int l,int r)
 24     {
 25         if(ma[g]<=w||r<=lim)return 0;
 26         if(l>lim)
 27         {
 28             if(mi[g]>w){w=ma[g];return len[g];}
 29             const int m=l+r>>1;
 30             if(ma[g<<1]>w){
 31                 int ret=ask(g<<1,l,m);if(ma[g<<1|1]>ma[g<<1])w=ma[g<<1|1];
 32                 return ret+len[g]-len[g<<1];
 33             }
 34             else return ask(g<<1|1,m+1,r);
 35         }
 36         const int m=l+r>>1;
 37         if(m<=lim){return ask(g<<1|1,m+1,r);}
 38         else{
 39             if(ma[g<<1]<=w)return ask(g<<1|1,m+1,r);
 40             int ret=ask(g<<1,l,m);
 41             if(w==ma[g<<1]){
 42                 if(ma[g<<1|1]>ma[g<<1])w=ma[g<<1|1];
 43                 return ret+len[g]-len[g<<1];
 44             }
 45             else{return ret+ask(g<<1|1,m+1,r);}
 46         }
 47     }
 48     inline int getma(int g,int l,int r,int x,int y)
 49     {
 50         if(l>y||rreturn 0;
 51         if(l>=x&&r<=y)return po[g];
 52         const int m=l+r>>1;
 53         const int a1=getma(g<<1,l,m,x,y),a2=getma(g<<1|1,m+1,r,x,y);
 54         if(a[a1]>a[a2])return a1;return a2;
 55         
 56     }
 57     void change(int g,int l,int r,int pos,int ww)
 58     {
 59         if(l==r){
 60             mi[g]=ma[g]=ww;po[g]=l;
 61             if(w){len[g]=1,po[g]=l;}
 62             else len[g]=po[g]=0;
 63             return;
 64         }
 65         const int m=l+r>>1;
 66         if(pos<=m)
 67         {
 68             change(g<<1,l,m,pos,ww);upd(g);
 69             lim=m;w=ma[g<<1];
 70             len[g]=len[g<<1]+ask(g<<1|1,m+1,r);
 71         }
 72         else
 73         {
 74             change(g<<1|1,m+1,r,pos,ww);upd(g);
 75             lim=m;w=ma[g<<1];
 76             len[g]=len[g<<1]+ask(g<<1|1,m+1,r);
 77         }
 78     }
 79 }tr1,tr2;
 80 inline void init(){
 81     sort(lsh+1,lsh+A+1);
 82     A=unique(lsh+1,lsh+A+1)-lsh-1;
 83 }
 84 inline int getd(int x)
 85 {
 86     lim=x;w=a[x];
 87     int ret=tr1.ask(1,1,A);
 88     lim=py(x);w=a[x];
 89     return ret+tr2.ask(1,1,A);
 90     
 91 }
 92 int main()
 93 {
 94 
 95     scanf("%d",&n);
 96     for(int i=1;i<=n;++i)
 97     {
 98         scanf("%d",&q[i].op);
 99         if(q[i].op==0){
100             scanf("%d%d",&q[i].x,&q[i].y);
101             lsh[++A]=q[i].x;
102         }
103         else if(q[i].op==1)scanf("%d",&q[i].x);
104         else scanf("%d%d",&q[i].x,&q[i].y);
105     }
106     init();
107     for(int i=1,op,x,y,t;i<=n;++i)
108     {
109 //        printf("\n\n\ni:%d\n",i);
110         op=q[i].op;
111         x=lower_bound(lsh+1,lsh+A+1,q[i].x)-lsh;
112         if(op==0){
113             a[x]=q[i].y;
114             tr1.change(1,1,A,x,a[x]);
115             tr2.change(1,1,A,py(x),a[x]);
116         }
117         else if(q[i].op==1)
118         {
119             a[x]=0;
120             tr1.change(1,1,A,x,a[x]);
121             tr2.change(1,1,A,py(x),a[x]);
122         }
123         else
124         {
125             y=lower_bound(lsh+1,lsh+A+1,q[i].y)-lsh;
126             if(x>y)swap(x,y);t=tr1.getma(1,1,A,x,y);
127             printf("%d\n",getd(x)+getd(y)-2*getd(t));
128         }
129     }
130 }

将坐标翻转减少码量

 

模拟90。

T1：luode dijkstra

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 #define N 505
 7 using namespace std;
 8 const int dx[]={1,-1,0,0};
 9 const int dy[]={0,0,1,-1};
10 int a[N][N],b[N][N],n,m;
11 int sx,sy,tx,ty;
12 priority_queueint,int> >q;
13 inline void bfs(int x,int y)
14 {
15     q.push(make_pair(b[sx][sy],x*N+y));
16     int d,xx,yy;
17     while(q.size())
18     {
19         x=q.top().second;d=q.top().first;q.pop();
20         y=x%N;x/=N;if(d!=b[x][y])continue;
21         for(int i=0;i<=3;++i)
22         {
23             xx=x+dx[i];yy=y+dy[i];
24             if(xx<=0||xx>n||yy<=0||yy>m)continue;
25             if(d<=a[xx][yy]+b[xx][yy])continue;
26             b[xx][yy]=d-a[xx][yy];
27             q.push(make_pair(b[xx][yy],xx*N+yy));
28         }
29     }
30 }
31 inline void pr()
32 {
33     for(int i=1;i<=n;++i)
34     {
35         for(int j=1;j<=m;++j)
36         {
37             printf("%d ",b[i][j]);
38         }
39         puts("");
40     }
41 }
42 int main()
43 {
44     scanf("%d%d",&n,&m);
45     for(int i=1;i<=n;++i)
46         for(int j=1;j<=m;++j)
47             scanf("%d",&a[i][j]);
48     scanf("%d%d",&sx,&sy);
49     scanf("%d%d%d",&b[sx][sy],&tx,&ty);
50     bfs(sx,sy);
51     printf("%d\n",b[tx][ty]);
52 //    pr();
53 }

View Code

T2：状压dp，怎么压都行，然而考场上打sb了，WA30，kuku。。

题解状压的思路还是不错的，积累一下。

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 #define N 105
 7 using namespace std;
 8 const int inf=1000000007;
 9 int n,m,bin[40],dp[N][1<<16],ct[1<<16],sta[N],ans=inf;
10 inline void init(int n)
11 {
12     for(int i=1;i<=bin[n];++i)
13         ct[i]=ct[i-(i&-i)]+1;
14 }
15 int main()
16 {
17     for(int i=0;i<=20;++i)bin[i]=1<<i;
18     memset(dp,0x3f,sizeof(dp));
19     scanf("%d%d",&n,&m);
20     for(int i=1;i<=n;++i)
21         for(int j=0,x;jj){
22             scanf("%d",&x);
23             if(x)sta[i]|=bin[j];
24         }
25     init(m);dp[0][0]=0;
26     for(int j=0;jj)
27     {
28         for(int i=0,cnt,ok;ii)
29         {
30             if(dp[j][i]>=inf)continue;
31             if(!sta[j+1]){dp[j+1][0]=min(dp[j+1][0],dp[j][i]);continue;}
32             for(int st=sta[j+1],ok;st;st=(st-1)&sta[j+1]){
33                 ok=1;cnt=ct[st];
34                 if((sta[j+1]&bin[0])&&!(st&bin[0]))continue;
35                 for(int k=0;k1;++k){
36                     if(sta[j+1]&bin[k])continue;
37                     if((sta[j+1]&bin[k+1])&&!(st&bin[k+1])){ok=0;break;}
38                 }
39                 if(!ok)continue;
40                 for(int k=0,s1,s2;kk){
41                     if((i&bin[k])&&(st&bin[k]))
42                     {
43                         for(s1=k+1;s1if(!(sta[j]&bin[s1])||(i&bin[s1]))break;
44                         for(s2=k+1;s2if(!(sta[j+1]&bin[s2])||(st&bin[s2]))break;
45                         if(s1==s2)--cnt;
46                     }
47                 }
48                 dp[j+1][st]=min(dp[j+1][st],dp[j][i]+cnt);
49             }
50         }
51     }
52     for(int i=0,cnt,ok;imin(ans,dp[n][i]);
53     printf("%d\n",ans);
54 }

View Code

T3：%%%kx

对所有斜率进行离散化，对矩形的左边界和下边界分别维护一棵线段树，下标为斜率离散化后的下标。然后标记永久化一下就可以了。

注意各种各样的特判（y==0和x==0）。

  1 #include
  2 #define N 100050
  3 using namespace std;
  4 int n,m,ls;
  5 const double eps=1e-9;
  6 const int inf=1000000007;
  7 double lsh[N<<2];
  8 struct PA{
  9     double first;
 10     int second;
 11     friend bool operator <(const PA &a,const PA &b)
 12     {
 13         if(a.first==b.first)return a.second<b.second;
 14         return a.first<b.first;
 15     }
 16 };
 17 inline PA mmp(int x,int y){PA a;a.first=x;a.second=y;return a;}
 18 PA kkk;
 19 struct node{double x,xx,y,yy;int op;}q[N];
 20 struct Segment_tree{
 21     PA mi[N<<2];
 22     inline void build(int g,int l,int r)
 23     {
 24         mi[g]=mmp(inf,0);if(l==r)return;
 25         const int m=l+r>>1;
 26         build(g<<1,l,m);build(g<<1|1,m+1,r);
 27     }
 28     inline PA getmi(int g,int l,int r,int pos)
 29     {
 30         if(l==r)return mi[g];
 31         const int m=l+r>>1;
 32         PA ret;
 33         if(pos<=m)ret=getmi(g<<1,l,m,pos);
 34         else ret=getmi(g<<1|1,m+1,r,pos);
 35         return min(ret,mi[g]);
 36     }
 37     inline void add(int g,int l,int r,int x,int y)
 38     {
 39         if(l>y||rreturn;
 40         if(l>=x&&r<=y){mi[g]=min(mi[g],kkk);return;}
 41         const int m=l+r>>1;
 42         add(g<<1,l,m,x,y);add(g<<1|1,m+1,r,x,y);
 43     }
 44 }T1,T2;
 45 int main(){
 46     scanf("%d",&n);
 47     for(int i=1;i<=n;++i)
 48     {
 49         scanf("%d",&q[i].op);
 50         if(q[i].op==1){
 51             scanf("%lf%lf%lf%lf",&q[i].x,&q[i].y,&q[i].xx,&q[i].yy);
 52             if(q[i].x)lsh[++ls]=q[i].y/q[i].x,lsh[++ls]=q[i].yy/q[i].x;
 53             if(q[i].xx)lsh[++ls]=q[i].y/q[i].xx;
 54         }
 55         else{
 56             scanf("%lf%lf",&q[i].x,&q[i].y);
 57             if(q[i].x)lsh[++ls]=q[i].y/q[i].x;
 58         }
 59     }
 60     sort(lsh+1,lsh+ls+1);ls=unique(lsh+1,lsh+ls+1)-lsh-1;
 61     double x,y,xx,yy;int t1,t2;
 62     PA k1,k2,spj=mmp(inf,0),spj2=mmp(inf,0);
 63     T1.build(1,1,ls);T2.build(1,1,ls);
 64     q[0].x=inf;q[0].y=inf;
 65     for(int i=1,op;i<=n;++i)
 66     {
 67         op=q[i].op;x=q[i].x;y=q[i].y;xx=q[i].xx;yy=q[i].yy;
 68         if(op==1)
 69         {
 70             kkk=mmp(x,-i);
 71             if(!y)spj2=min(spj2,mmp(x,-i));
 72             if(x)
 73             {
 74                 t1=lower_bound(lsh+1,lsh+ls+1,y/x-eps)-lsh;
 75                 t2=lower_bound(lsh+1,lsh+ls+1,yy/x-eps)-lsh;
 76             }
 77             else
 78             {
 79                 spj=min(spj,mmp(y,-i));
 80                 t1=t2=ls;
 81             }
 82             T1.add(1,1,ls,t1,t2);
 83             kkk=mmp(y,-i);
 84             if(xx)t2=lower_bound(lsh+1,lsh+ls+1,y/xx-eps)-lsh;
 85             else t2=ls;
 86             T2.add(1,1,ls,t2,t1);
 87         }
 88         else
 89         {
 90             if(!q[i].y){printf("%d\n",-spj2.second);continue;}
 91             if(!q[i].x){printf("%d\n",-spj.second);continue;}
 92             t1=lower_bound(lsh+1,lsh+ls+1,y/x-eps)-lsh;
 93             k1=T1.getmi(1,1,ls,t1);k2=T2.getmi(1,1,ls,t1);
 94             yy=max(q[-k1.second].x*y/x,q[-k1.second].y);xx=max(q[-k2.second].x*y/x,q[-k2.second].y);
 95             if(fabs(yy-xx)<1e-8){printf("%d\n",-min(k1.second,k2.second));}
 96             else if(yy>xx)printf("%d\n",-k2.second);
 97             else printf("%d\n",-k1.second);
 98         }
 99     }
100 }

View Code

 

模拟91。

T1，下面说一下心态问题，我当时秒切

发现不同的数在根号级别，然后它就成了sbt。开链表维护存在的权值，每次暴扫即可。

 1 #include
 2 #include
 3 #include
 4 #include
 5 #define N 300050
 6 using namespace std;
 7 int n,m,tot;
 8 int fa[N],sz[N];
 9 int pd[N];
10 
11 struct node{int pre,ne,cnt,sum;}a[N];
12 int getfa(int x){return x==fa[x]?x:fa[x]=getfa(fa[x]);}
13 
14 inline void del(int id)
15 {
16     pd[id]=0;
17     a[a[id].pre].ne=a[id].ne;
18     a[a[id].ne].pre=a[id].pre;
19 }
20 inline void ins2(int x,int id)
21 {
22     a[x].pre=a[id].pre;
23     a[a[id].pre].ne=x;
24     a[id].pre=x;a[x].ne=id;
25     pd[x]=1;
26 }
27 inline void ins(int x)
28 {
29     for(int i=a[0].ne;i<=n+1;i=a[i].ne)
30         if(i>x){ins2(x,i);return;}
31 }
32 
33 int main()
34 {
35 //    freopen("cards105.in","r",stdin);//diff -b -B cards105.out my.out
36 //    freopen("my.out","w",stdout);
37     scanf("%d%d",&n,&m);tot=1;
38     for(int i=1;i<=n;++i)fa[i]=i,sz[i]=1;
39     
40     a[0].ne=a[n+1].pre=1;
41     a[1].pre=0;a[1].ne=n+1;
42     a[1].cnt=n;pd[1]=1;
43     
44     int op,x,y,sum;
45     long long ans;
46     while(m--)
47     {
48         scanf("%d",&op);
49         if(op==1)
50         {
51             scanf("%d%d",&x,&y);
52             if(getfa(x)==getfa(y))continue;
53             x=getfa(x);y=getfa(y);
54             --a[sz[x]].cnt;
55             if(!a[sz[x]].cnt)del(sz[x]);
56             --a[sz[y]].cnt;
57             if(!a[sz[y]].cnt)del(sz[y]);
58             
59             fa[y]=x;sz[x]+=sz[y];
60             ++a[sz[x]].cnt;
61             if(!pd[sz[x]])ins(sz[x]);
62         }
63         else
64         {
65             scanf("%d",&x);
66             for(int i=a[0].ne;i<=n;i=a[i].ne)
67             {
68                 a[i].sum=a[i].cnt+a[a[i].pre].sum;                
69             }
70             ans=0;
71             if(!x){
72                 ans=1ll*a[a[n+1].pre].sum*(a[a[n+1].pre].sum-1);ans>>=1;
73             }
74             else
75             {
76                 for(int i=a[n+1].pre,j=a[n+1].pre;i>x;i=a[i].pre)
77                 {
78                     while(i-ja[j].pre;
79                     ans+=1ll*a[j].sum*a[i].cnt;
80                 }
81             }
82             printf("%lld\n",ans);
83         }
84     }
85 }

竟然花了我一个小时？？？

T2，考场上大部分时间都扔给了T2，然而还是爆0了。

其实还是挺难的，考虑按概率dp，最后用概率乘位置得到期望。

考虑如何归并相同的数。

设dp[dep][i][j]，表示在归并的第dep层，原数组中位置为i的值在当前归并的区间内排名为j的概率，在l==r时显然有dp[dep][l][1]=1。

对于非叶子

首先，已有两个子区间各自的排名，考虑预处理一些东西辅助转移。

设f[i][j]表示某点在原区间排名为j，在新区间排名为i的概率，

f数组可以递推转移（考虑前一个位置来自相同区间or不同区间，具体细节看代码）

但我们发现只有一个f数组还不够。因为不能确定另一个子区间是否已为空

设h[i][j]表示某点在原区间排名为j，在新区间排名为i，且另一个子区间的数全部在当前数之前的概率。

转移与f数组类似（同样考虑前一个位置来自相同区间or不同区间，具体细节看代码）

然后就可以kx地转移了。

 1 #include
 2 #define N 550
 3 #define pb push_back
 4 #define int long long
 5 const int mod=998244353;
 6 const int inv2=499122177;
 7 using namespace std;
 8 int n,a[N],dp[12][N][N],f[N][N],h[N][N],pd[5500],ans[N];
 9 vector<int>v[N<<2];
10 inline void init(int n)
11 {
12     f[1][1]=inv2;h[1][1]=1;
13     for(int i=2;i<=n;++i)
14         for(int j=1;j<=i;++j){
15             f[i][j]=(f[i-1][j-1]+f[i-1][i-j])%mod;
16             f[i][j]=1ll*inv2*f[i][j]%mod;
17             h[i][j]=(h[i-1][j-1]+f[i-1][i-j])%mod;
18         }
19 }
20 inline void merge(int g,int l,int r,int dep,int val)
21 {
22     v[g].clear();
23     if(l==r){if(a[l]==val)dp[dep][l][1]=1,v[g].pb(l);return;}
24     const int m=l+r>>1,lc=g<<1,rc=g<<1|1;;
25     merge(lc,l,m,dep+1,val);merge(rc,m+1,r,dep+1,val);
26     for(int i=0;ii)v[g].pb(v[lc][i]);
27     for(int j=0;jj)v[g].pb(v[rc][j]);
28     for(int o=0,t;ov[lc][o];
29         for(int i=1;i<=v[lc].size();++i)
30             for(int j=0;j<=v[rc].size();++j)
31                 if(j==v[rc].size())(dp[dep][t][i+j]+=1ll*dp[dep+1][t][i]*h[i+j][i]%mod)%=mod;
32                 else (dp[dep][t][i+j]+=1ll*dp[dep+1][t][i]*f[i+j][i]%mod)%=mod;
33     }
34     for(int o=0,t;ov[rc][o];
35         for(int i=1;i<=v[rc].size();++i)
36             for(int j=0;j<=v[lc].size();++j)
37                 if(j==v[lc].size())(dp[dep][t][i+j]+=1ll*dp[dep+1][t][i]*h[i+j][i]%mod)%=mod;
38                 else (dp[dep][t][i+j]+=dp[dep+1][t][i]*f[i+j][i]%mod)%=mod;
39     }
40     v[lc].clear();v[rc].clear();
41 }
42 signed main()
43 {
44     scanf("%lld",&n);init(n);
45     for(int i=1;i<=n;++i)scanf("%lld",&a[i]);
46     for(int i=1;i<=n;++i)
47         if(!pd[a[i]])pd[a[i]]=1,merge(1,1,n,1,a[i]);
48     for(int k=0;k<=1000;++k)v[k].clear();
49     for(int i=1;i<=n;++i)v[a[i]].push_back(i);
50     for(int k=0,t=1;k<=1000;++k){
51         for(int i=0,p;iv[k][i];
52             for(int j=1;j<=v[k].size();++j)(ans[p]+=1ll*dp[1][p][j]*(j+t-1)%mod)%=mod;
53         }
54         t+=v[k].size();
55     }
56     for(int i=1;i<=n;++i)printf("%lld ",ans[i]);
57     puts("");
58 }

View Code

 1 #include
 2 #define N 550
 3 #define pb push_back
 4 const int mod=998244353;
 5 const double inv2=0.5;
 6 using namespace std;
 7 int n;
 8 int a[N],b[N],c[N];
 9 double dp[12][N][N];
10 double f[N][N];
11 double h[N][N];
12 double ans[N];
13 vector<int>v[N<<2];
14 inline void init(int n)
15 {
16     f[1][1]=inv2;h[1][1]=1;
17     for(int i=2;i<=n;++i){
18         for(int j=1;j<=i;++j){
19             f[i][j]=f[i-1][j-1]+f[i-1][i-j];
20             f[i][j]=  inv2*f[i][j] ;
21             h[i][j]=(  h[i-1][j-1]+  f[i-1][i-j]);
22         }
23     }
24 //    for(int i=1;i<=n;++i,puts(""))
25 //        for(int j=1;j<=i;++j)printf("%.2lf ",f[i][j]);
26 }
27 int pd[1050];
28 inline void merge(int g,int l,int r,int dep,int val)
29 {
30     v[g].clear();
31     if(l==r){
32         if(a[l]==val){
33             dp[dep][l][1]=1;
34             v[g].pb(l);
35         }return;
36     }
37     const int m=l+r>>1,lc=g<<1,rc=g<<1|1;;
38     merge(lc,l,m,dep+1,val);merge(rc,m+1,r,dep+1,val);
39     for(int i=0;ii)v[g].pb(v[lc][i]);
40     for(int j=0;jj)v[g].pb(v[rc][j]);
41     for(int o=0,t;ov[lc][o];
42         for(int i=1;i<=v[lc].size();++i)
43             for(int j=0;j<=v[rc].size();++j)
44                 if(j==v[rc].size())dp[dep][t][i+j]+=dp[dep+1][t][i]*h[i+j][i];
45                 else dp[dep][t][i+j]+=dp[dep+1][t][i]*f[i+j][i];
46     }
47     for(int o=0,t;ov[rc][o];
48         for(int i=1;i<=v[rc].size();++i)
49             for(int j=0;j<=v[lc].size();++j)
50                 if(j==v[lc].size())dp[dep][t][i+j]+=dp[dep+1][t][i]*h[i+j][i];
51                 else dp[dep][t][i+j]+=dp[dep+1][t][i]*f[i+j][i];
52     }v[lc].clear();v[rc].clear();
53 }
54 int main()
55 {
56     scanf("%d",&n);init(n);
57     for(int i=1;i<=n;++i)scanf("%d",&a[i]),b[i]=a[i];
58     for(int i=1;i<=n;++i){
59         if(!pd[a[i]]){pd[a[i]]=1;
60             merge(1,1,n,1,a[i]);
61         }
62     }
63     for(int k=0;k<=1000;++k)v[k].clear();
64     for(int i=1;i<=n;++i)v[a[i]].push_back(i);
65     int t=1;
66     for(int k=0;k<=1000;++k){
67         for(int i=0,p;iv[k][i];
68             for(int j=1;j<=v[k].size();++j)ans[p]+=dp[1][p][j]*(j+t-1);
69         }
70         t+=v[k].size();
71     }
72     for(int i=1;i<=n;++i)printf("%lf ",ans[i]);
73     puts("");
74 }

double版本，调试专用

T3，直接粘题接&代码，此题给我的启示：学习暴力，学习卡常，++前置，加fread，重载max或直接用if，学会乱搞，减小枚举上界，然后就可以卡常AC此题

 1 #include
 2 #define N 1000050
 3 char xch,xB[1<<15],*xS=xB,*xTT=xB;
 4 #define getc() (xS==xTT&&(xTT=(xS=xB)+fread(xB,1,1<<15,stdin),xS==xTT)?0:*xS++)
 5 inline int read()
 6 {
 7     int x=0,f=1;char ch=getc();
 8     while(ch<'0'|ch>'9'){if(ch=='-')f=-1;ch=getc();}
 9     while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getc();}
10     return x*f;
11 }
12 using namespace std;
13 int n,K;
14 int a[N];
15 int ans[N];
16 int an2[N];
17 inline void work1()
18 {
19     for(int i=1;i<=n;++i)ans[i]=-1;
20     int ma,mi,an,o;
21     for(int i=n;i>=1;--i){
22         ma=mi=an=o=a[i];
23         for(int k=i+1;k<=n;++k){
24             if(a[k]>ma)ma=a[k];
25             if(a[k]a[k];
26             an&=a[k];o|=a[k];
27             if(o+mi-ma-an>=K)ans[i]=k-i+1;
28         }
29         for(int k=min(n,i+ans[i]-1);k>i;--k)if(ans[k]ans[i];
30     }
31     for(int i=1;i<=n;++i)printf("%d ",ans[i]);
32     puts("");
33 }
34 inline void work2()
35 {
36     for(int i=1;i<=n;++i)ans[i]=-1;
37     int ma,mi,an,o;
38     for(int i=n;i>=1;--i){
39         ma=mi=an=o=a[i];
40         const int lim=min(n,i+700);
41         for(int k=i+1;k<=lim;++k){
42             if(a[k]>ma)ma=a[k];
43             if(a[k]a[k];
44             an&=a[k];o|=a[k];
45             if(o+mi-ma-an>=K)ans[i]=k-i+1;
46         }
47         for(int k=min(n,i+ans[i]-1);k>i;--k)if(ans[k]ans[i];
48     }
49     for(int i=1;i<=n;++i)printf("%d ",ans[i]);
50     puts("");
51 }
52 int main()
53 {
54     scanf("%d%d",&n,&K);
55     for(int i=1;i<=n;++i)a[i]=read();
56     if(n>30000){work2();return 0;}
57     work1();return 0;
58 }

底层优化，13365 ms

以下是正解：

正解代码：

 1 #include
 2 #define N 1000050
 3 char xch,xB[1<<15],*xS=xB,*xTT=xB;
 4 #define getc() (xS==xTT&&(xTT=(xS=xB)+fread(xB,1,1<<15,stdin),xS==xTT)?0:*xS++)
 5 inline int read()
 6 {
 7     int x=0,f=1;char ch=getc();
 8     while(ch<'0'|ch>'9'){if(ch=='-')f=-1;ch=getc();}
 9     while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getc();}
10     return x*f;
11 }
12 using namespace std;
13 int n,K,a[N],ans[N],bin[35],lg[N];
14 int st1[21][N],st2[21][N],st3[21][N],st4[21][N];//min max and or
15 inline void init()
16 {
17     for(int i=0;i<=30;++i)bin[i]=1<1]=0;
18     for(int i=2;i<=n;++i)lg[i]=lg[i>>1]+1;
19     for(int i=1;i<=n;++i)st1[0][i]=st2[0][i]=st3[0][i]=st4[0][i]=a[i];
20     for(int j=1;j<=20;++j)
21         for(int i=1;i<=n;++i){
22             st1[j][i]=min(st1[j-1][i],st1[j-1][i+bin[j-1]]);
23             st2[j][i]=max(st2[j-1][i],st2[j-1][i+bin[j-1]]);
24             st3[j][i]=st3[j-1][i]&st3[j-1][i+bin[j-1]];
25             st4[j][i]=st4[j-1][i]|st4[j-1][i+bin[j-1]];
26         }
27 }
28 inline int Min(int l,int r){return min(st1[lg[r-l+1]][l],st1[lg[r-l+1]][r-bin[lg[r-l+1]]+1]);}
29 inline int Max(int l,int r){return max(st2[lg[r-l+1]][l],st2[lg[r-l+1]][r-bin[lg[r-l+1]]+1]);}
30 inline int And(int l,int r){return st3[lg[r-l+1]][l]&st3[lg[r-l+1]][r-bin[lg[r-l+1]]+1];}
31 inline int Or(int l,int r){return st4[lg[r-l+1]][l]|st4[lg[r-l+1]][r-bin[lg[r-l+1]]+1];}
32 inline int getval(int l,int r){return Or(l,r)-And(l,r);}
33 struct list{int ne,pre,l,r;}li[N];int tot=1,kkk;
34 inline void del(int id){
35     int a1=li[id].pre,a2=li[id].ne;
36     li[a1].ne=a2;li[a2].pre=a1;li[a2].l=li[id].l;
37 }
38 inline bool check(int l,int r){
39 //    printf("you checked:%d %d returned :%d\n",l,r,Or(l,r)+Min(l,r)-And(l,r)-Max(l,r));
40     return Or(l,r)+Min(l,r)-And(l,r)-Max(l,r)>=K;
41 }
42 int ma[N<<2];
43 inline void add(int g,int l,int r,int x,int y,int w){
44     if(l>y||rreturn;
45     if(l>=x&&r<=y){ma[g]=max(ma[g],w);return;}
46     const int m=l+r>>1;
47     add(g<<1,l,m,x,y,w);add(g<<1|1,m+1,r,x,y,w);
48 }
49 inline void bl(int g,int l,int r)
50 {
51     ma[g]=max(ma[g],ma[g>>1]);
52     if(l==r){printf("%d ",ma[g]);return;}
53     const int m=l+r>>1;
54     bl(g<<1,l,m);bl(g<<1|1,m+1,r);
55 }
56 inline void erfen(int l,int r,const int alr)
57 {
58 //    printf("l:%d r:%d\n",l,r);
59     int mid;
60     while(l+1<r)
61     {
62         mid=l+r>>1;
63         if(check(mid,alr))r=mid;
64         else l=mid;
65     }
66     add(1,1,n,r,alr,alr-r+1);
67 }
68 int main()
69 {
70     scanf("%d%d",&n,&K);memset(ma,0xFF,sizeof(ma));
71     for(int i=1;i<=n;++i)a[i]=read();
72     init();li[0].l=li[0].r=0;
73     for(int i=1;i<=n;++i)
74     {
75 //        printf("now:%d \n",i);
76         li[kkk].ne=++tot;li[tot].pre=kkk;kkk=tot;
77         li[kkk].l=li[kkk].r=i;
78         for(int j=li[kkk].pre;j;j=li[j].pre)
79             if(getval(li[j].l,i)==getval(li[li[j].ne].l,i))del(j);
80         for(int j=li[0].ne;j;j=li[j].ne)
81             if(check(li[j].r,i)){erfen(li[j].l-1,li[j].r,i);break;}
82     }
83     bl(1,1,n);
84     puts("");
85 }

链表维护，3263ms

革命尚未成功，吾辈仍需努力