赤壁情：dp

首先这道题用到的3个新关键字大概讲一下：

（我刚学会仅仅会瞎搞做题，欢迎大神补充）

static：声明一个变量并清空。（不知道用不用时间，求解答）

具体用法：static 变量类型 变量名。如：static int a[1005];

百度了一下。static在第一次声明时是0，但是下次进入这个函数时它不会再次清空而是保持原状。

讲的不错的博客。

class：和其它的变量类型差不多，只不过class存的是一个变量类型，常与template连用

具体用法：class 变量名。不能赋值。如：class s=bool;是编译不过的，但是class s;可以

template：特殊的函数传参方法，可以传class类型的变量（至少我是这么理解的）

具体用法：template<变量类型 变量名，变量类型 变量名...>函数类型 函数名（函数传参）{}

在函数定义时前面加<>,里面加上任意多个变量类型及变量名，和在小括号里的传参类似。

如：template<class nd,int N,int M>void work(int p){nd a[1005];return;}

然后这题虽然看了题解发了std之后AC一片一片的，但是其实真的没有那么好想。

首先dp定义是dp[i][j][k][l]表示已经填了i位，目前累计的“赤壁之意”为j，已经分成了k段，序列的端点已经被用上了l个。

第一维可滚动。数组大小为2*7500*50*3。空间可接受。100*7500*50*3时间可接受。(7500怎么来的等会讲)

这里的段的内部次序已经确定，段之间的先后关系也已经确定，但是它们在原序列上的具体位置和间隔距离并不确定。

假设目前的状态dp[i][j][k][l]=DP，i从0开始枚举，从小往大填。

dp[i&1^1][j-2-i*2][k+1][l]+=DP*(k+1-l),表示你新开了一个段只有i+1这个数，在目前已有k个段的情况下一共有k+1种位置可插入，插入后“赤壁之意“累加-2i-2

因为你这个数左右两边都没有值，以后填的值都比这个值大，所以abs就是两边的和分别减去i+1，所以填i+1的贡献就是-2i-2。

但是如果已经有一个端点确定了，那么这个新段就不能加在最前面了，两个端点都确定的话同理，所以可选择位置要减去l。

dp[i&1^1][j][k][l]+=DP*(2*k-l),表示你在某一个段的一个端点上加上了i+1这个数，k个段每个都有2个端点，但是整个序列已经确定的端点上不能加数，所以就是2k-l。

这样的贡献是0，对于已经填上的数它一定比i+1小那么会产生i+1的贡献，另一端还没有填的一定比它大会产生-i-1的贡献抵消了。

dp[i&1^1][j+2+2*i][k-1][l]+=DP*( k-1 ),表示你把两个段合并，k个段之间有k-1个位置来合并。合并操作并不受端点是否已经确定的影响。

dp[i&1^1][j-1-i][k+1][l+1]+=DP*( 2-l ),表示在端点处新建一个段。

dp[i&1^1][j+1+i][k][l+1]+=DP*( 2-l ),表示把一个段的端点延伸并设为整个序列的端点。

至于7500是怎么来的，就是最后的答案不会超过n(n+1)/2这比较显然，开大更好，大约是5000。

然而上来一直建新段的话会导致过程中你的积分是负的，最多u会负n(n+1)/4，大约是-2500。

和起来就是7500。对于float128的n=50的测试点相应的小4倍。

Lockey提出了倒着扫回去先放大数，这样的话就不用担心过程中分数会出负数了。

 #include<cstdio>
 #include<cstring>
 __float128 ans;int n,m,k;
 #define DP dp[i&1][j][k][l]
 int floor(__float128 x){
     for(int i=;i>=;--i)if(x>=i)return i;
 }
 void print__float128(__float128 x,int ws){
     int sta[];sta[]=;
     for(int i=;i<=ws;++i)x*=,sta[i]=floor(x),x-=floor(x);
     x*=;if(floor(x)>=)sta[k]++;
     for(int i=ws;i;--i)if(sta[i]==)sta[i]=,sta[i-]++;
     printf("%d.",sta[]);
     for(int i=;i<=ws;++i)printf("%d",sta[i]);
     puts("");
 }
 int main(){
     scanf("%d%d%d",&n,&m,&k);
     if(k<=){
         static double dp[][][][];
         #define $ 12345
         dp[][$][][]=;
         for(int i=;i<n;++i){
             std::memset(dp[i&^],,sizeof dp[]);
             for(int j=;j<=$+(n+)*n/;++j)for(int k=;k<=;++k)for(int l=;l<=;++l)if(DP>=0.998){
                 dp[i&^][j--i*][k+][ l ]+=DP*(k+-l);
                 dp[i&^][   j   ][ k ][ l ]+=DP*(*k-l);
                 dp[i&^][j++*i][k-][ l ]+=DP*(k-);
                 dp[i&^][ j--i ][k+][l+]+=DP*(-l);
                 dp[i&^][ j++i ][ k ][l+]+=DP*(-l);
             }
         }
         for(int j=m+$;j<=$+(n+)*n/;++j)ans+=dp[n&][j][][];
     }else{
         static __float128 dp[][][][];
         #define $ 3000
         dp[][$][][]=;
         for(int i=;i<n;++i){
             std::memset(dp[i&^],,sizeof dp[]);
             for(int j=;j<=$+(n+)*n/;++j)for(int k=;k<=;++k)for(int l=;l<=;++l)if(DP>=0.998){
                 dp[i&^][j--i*][k+][ l ]+=DP*(k+-l);
                 dp[i&^][   j   ][ k ][ l ]+=DP*(*k-l);
                 dp[i&^][j++*i][k-][ l ]+=DP*(k-);
                 dp[i&^][ j--i ][k+][l+]+=DP*(-l);
                 dp[i&^][ j++i ][ k ][l+]+=DP*(-l);
             }
         }
         for(int j=m+$;j<=$+(n+)*n/;++j)ans+=dp[n&][j][][];
     }
     for(int i=;i<=n;++i)ans/=i;
     print__float128(ans,k);
 }

未用tmeplate。1.6k

 #include<cstdio>
 __float128 ans;int n,m,k;
 #define DP dp[i&1][j][k][l]
 int floor(__float128 x){for(int i=;i>=;--i)if(x>=i)return i;}
 void print__float128(__float128 x,int ws){
     int sta[];sta[]=;
     for(int i=;i<=ws;++i)x*=,sta[i]=floor(x),x-=floor(x);
     if(floor(x*)>=)sta[k]++;
     for(int i=ws;i;--i)if(sta[i]==)sta[i]=,sta[i-]++;
     printf("%d.",sta[]);for(int i=;i<=ws;++i)printf("%d",sta[i]);
 }
 int P(int a){return a<?:a;}
 template<class nd,int N,int M>void work(){
     static nd dp[][N][][];
     dp[][M][][]=;
     for(int i=;i<n;++i)for(int j=;j<=M+(n+)*n/;++j)for(int k=i?:;k<=;++k)for(int l=;l<=;++l)if(DP>=0.998)
             dp[i&^][P(j--i*)][k+][ l ]+=DP*(k+-l),
             dp[i&^][     j    ][ k ][ l ]+=DP*(*k-l),
             dp[i&^][ j++*i  ][k-][ l ]+=DP*( k- ),
             dp[i&^][ P(j--i) ][k+][l+]+=DP*( -l ),
             dp[i&^][  j++i   ][ k ][l+]+=DP*( -l ),
             DP=;
     for(int j=m+M;j<=M+(n+)*n/;++j)ans+=dp[n&][j][][];
     for(int i=;i<=n;++i)ans/=i;
     print__float128(ans,k);
 }
 int main(){
     scanf("%d%d%d",&n,&m,&k);
     if(k<=)work<double,,>();else work<__float128,,>();
 }

加template，1.1k

 #include<cstdio>
 __float128 ans;int n,m,k;
 #define DP dp[i&1][j][k][l]
 int floor(__float128 x){for(int i=;i>=;--i)if(x>=i)return i;}
 void print__float128(__float128 x,int ws){
     int sta[];sta[]=;
     for(int i=;i<=ws;++i)x*=,sta[i]=floor(x),x-=floor(x);
     if(floor(x*)>=)sta[k]++;
     for(int i=ws;i;--i)if(sta[i]==)sta[i]=,sta[i-]++;
     printf("%d.",sta[]);for(int i=;i<=ws;++i)printf("%d",sta[i]);
 }
 template<class nd>void work(){
     static nd dp[][][][];
     dp[n&][][][]=;
     for(int i=n;i;--i)for(int j=;j<=(n+)*n*/;++j)for(int k=;k<=;++k)for(int l=;l<=;++l)if(DP>=0.998){
             dp[i&^][j+*i][k+][ l ]+=DP*(k+-l);
             dp[i&^][  j  ][ k ][ l ]+=DP*(*k-l);
 if(k&&j>=*i)dp[i&^][j-*i][k-][ l ]+=DP*( k- );
             dp[i&^][ j+i ][k+][l+]+=DP*( -l );
 if(j>=i)    dp[i&^][ j-i ][ k ][l+]+=DP*( -l );
             DP=;
     }
     for(int j=m;j<=(n+)*n/;++j)ans+=dp[][j][][];
     for(int i=;i<=n;++i)ans/=i;
     print__float128(ans,k);
 }
 int main(){
     scanf("%d%d%d",&n,&m,&k);
     if(k<=)work<double>();else work<__float128>();
 }

加Lockey优化，1.0k

时间复杂度倒是差不多。