zoukankan      html  css  js  c++  java
  • CSPS模拟88-91

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

    模拟88。

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

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

      1 #include<bits/stdc++.h>
      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
    ",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;j<l2;++j)num=num*10+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<<t<<endl;
    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;j<l2;++j)num=num*10+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;j<l2;++j)num=num*10+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;j<l2;++j)num=num*10+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<iostream>
     2 #include<cstdio>
     3 #include<cstring>
     4 #include<algorithm>
     5 #include<vector>
     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;o<al;++o)
    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<iostream>
     2 #include<cstdio>
     3 #include<cstring>
     4 #include<vector>
     5 #include<algorithm>
     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
    ",ans[n]);
    30     return 0;
    31 }
    本代码各种玄学操作均可用打表or枚举证明

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

     1 #include<bits/stdc++.h>
     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<<ans<<endl;
    50     return 0;
    51 }
    View Code

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

      1 #include<bits/stdc++.h>
      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||r<x)return 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("
    
    
    i:%d
    ",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
    ",getd(x)+getd(y)-2*getd(t));
    128         }
    129     }
    130 }
    将坐标翻转减少码量

    模拟90。

    T1:luode dijkstra

     1 #include<iostream>
     2 #include<cstdio>
     3 #include<cstring>
     4 #include<algorithm>
     5 #include<queue>
     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_queue<pair<int,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
    ",b[tx][ty]);
    52 //    pr();
    53 }
    View Code

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

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

     1 #include<iostream>
     2 #include<cstdio>
     3 #include<cstring>
     4 #include<algorithm>
     5 #include<queue>
     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;j<m;++j){
    22             scanf("%d",&x);
    23             if(x)sta[i]|=bin[j];
    24         }
    25     init(m);dp[0][0]=0;
    26     for(int j=0;j<n;++j)
    27     {
    28         for(int i=0,cnt,ok;i<bin[m];++i)
    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;k<m-1;++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;k<m;++k){
    41                     if((i&bin[k])&&(st&bin[k]))
    42                     {
    43                         for(s1=k+1;s1<m;++s1)if(!(sta[j]&bin[s1])||(i&bin[s1]))break;
    44                         for(s2=k+1;s2<m;++s2)if(!(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;i<bin[m];++i)ans=min(ans,dp[n][i]);
    53     printf("%d
    ",ans);
    54 }
    View Code

    T3:%%%kx

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

    注意各种各样的特判(y==0和x==0)。

      1 #include<bits/stdc++.h>
      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||r<x)return;
     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
    ",-spj2.second);continue;}
     91             if(!q[i].x){printf("%d
    ",-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
    ",-min(k1.second,k2.second));}
     96             else if(yy>xx)printf("%d
    ",-k2.second);
     97             else printf("%d
    ",-k1.second);
     98         }
     99     }
    100 }
    View Code

    模拟91。

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

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

     1 #include<iostream>
     2 #include<cstdio>
     3 #include<cstring>
     4 #include<algorithm>
     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-j<x)j=a[j].pre;
    79                     ans+=1ll*a[j].sum*a[i].cnt;
    80                 }
    81             }
    82             printf("%lld
    ",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<bits/stdc++.h>
     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;i<v[lc].size();++i)v[g].pb(v[lc][i]);
    27     for(int j=0;j<v[rc].size();++j)v[g].pb(v[rc][j]);
    28     for(int o=0,t;o<v[lc].size();++o){t=v[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;o<v[rc].size();++o){t=v[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;i<v[k].size();++i){p=v[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<bits/stdc++.h>
     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;i<v[lc].size();++i)v[g].pb(v[lc][i]);
    40     for(int j=0;j<v[rc].size();++j)v[g].pb(v[rc][j]);
    41     for(int o=0,t;o<v[lc].size();++o){t=v[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;o<v[rc].size();++o){t=v[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;i<v[k].size();++i){p=v[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<bits/stdc++.h>
     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]<mi)mi=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])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]<mi)mi=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])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<bits/stdc++.h>
     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<<i;lg[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
    ",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||r<x)return;
    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
    ",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 
    ",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

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

  • 相关阅读:
    linux 相关( 随时更新)
    django admin 修改批量操作内容
    区块链
    关于读取excel 和 写excel
    git基本用法
    服务器与本地的控制工具unison
    爬虫框架 Scrapy
    爬虫高性能 asyncio库 twisted库 tornado库
    爬虫请求库之selenium模块
    爬虫请求库
  • 原文地址:https://www.cnblogs.com/loadingkkk/p/11755573.html
Copyright © 2011-2022 走看看