HDU 6199 gems gems gems 2017沈阳网络赛 1006

->原文链接

博弈的背景，关键点在于，每个人的决策都是对自己最优的，也就是 A在pos的位置上，选择只有两个，k与k+1，此时的决策只和后面的相关，而前面对后面的影响只有K.

进一步分析K,发现K并不会很大，考虑K的最大值，也就是决策始终选择K+1，可见最大的k满足  K(K+1)/2<=N.N最大20000，对应K最大只有200.

dif[ i ][ pos ][ k ] 表示当前状态下的差，即Alice-Bob.

i为0/1分别代表当前决策者是Alice/Bob。

pos为当前决策者的位置。

k为当前决策者的决策。

状态转移：

对于决策者Alice，dif越大越好，对于Bob，dif越小越好。

dif[ 0 ][ pos ][ k ]=min( dif[ 1 ][ pos+k ][ k ], dif[ 1 ][ pos+k ][ k+1 ] )+sum{ a[pos]  to a[pos+k-1] }

这里的min是因为这取决于Bob的决策，Bob自然是越小越开心

同理可得 dif[ 1 ][ pos ][ k ]的转移方程。

然而，这题卡你空间，于是数组不能那么天真的 dif[ 2 ][ 20001 ][ 201 ],大约超了10%

所以考虑到 k 受限于 pos, 即当前的决策最大，也只有  sqrt(  2 * pos ) + 2  //分析见上面K的最大值分析 ，会比实际大1 or 2，大一点保平安。

于是用三级指针动态分配

AC代码：

#include<bits/stdc++.h>
using namespace std;
int ***dif;
int sum[200001];
int total(int l,int len){return sum[l+len-1]-sum[l-1];}

int main(){
    dif=new int**[2];
    for(int i=0;i<2;i++){
        dif[i]=new int*[20001];
        for(int j=1;j<=20000;j++){
            dif[i][j]=new int[int(sqrt(2*j)+1)+1];
        }
    }
    int T;
    scanf("%d",&T);
    for(int kase=1;kase<=T;kase++){
        int n;
        scanf("%d",&n);
        sum[0]=0;
        for(int i=1;i<=n;i++){
            int a;
            scanf("%d",&a);
            sum[i]=sum[i-1]+a;
        }
        for(int pos=n;pos>=1;pos--){
            int maxk=int( sqrt(2*pos)+1 );
            int remain=n-pos+1;
            for(int k=1;k<=min(remain,maxk);k++ ){
                if(k==remain){
                    dif[0][pos][k]=total(pos,k);
                    dif[1][pos][k]=-total(pos,k);
                }
                else{
                    dif[0][pos][k]=dif[1][pos][k]=0;
                    if(pos+k+k-1<=n){
                        dif[0][pos][k]=dif[1][pos+k][k];
                        if(pos+k+k+1-1<=n)
                            dif[0][pos][k]=min(dif[0][pos][k],dif[1][pos+k][k+1]);
                    }
                    dif[0][pos][k]+=total(pos,k);

                    if(pos+k+k-1<=n){
                        dif[1][pos][k]=dif[0][pos+k][k];
                        if(pos+k+k+1-1<=n)
                            dif[1][pos][k]=max(dif[1][pos][k],dif[0][pos+k][k+1]);
                    }
                    dif[1][pos][k]-=total(pos,k);
                }
            }
        }
        int tmp=0;
        if(n>=1){
            tmp=dif[0][1][1];
            if(n>=2) tmp=max(tmp,dif[0][1][2]);
        }
        printf("%d\n",tmp);
    }
    return 0;
}

进一步优化，考虑状态转移的跨度不超过K的最大值，也就是200左右，所以可以将pos取模，涉及当前状态转移的变量在>K的剩余系中一定不会重复，所以就可以将第二维，即pos用滚动数组优化

AC代码：

#include<bits/stdc++.h>
using namespace std;
const int mod=255;
int dif[2][mod+1][201];
int sum[200001];
int total(int l,int len){return sum[l+len-1]-sum[l-1];}

int main(){
    int T;
    scanf("%d",&T);
    for(int kase=1;kase<=T;kase++){
        int n;
        scanf("%d",&n);
        sum[0]=0;
        for(int i=1;i<=n;i++){
            int a;
            scanf("%d",&a);
            sum[i]=sum[i-1]+a;
        }
        for(int pos=n;pos>=1;pos--){
            int maxk=int( sqrt(2*pos)+1 );
            int remain=n-pos+1;
            for(int k=1;k<=min(remain,maxk);k++ ){
                if(k==remain){
                    dif[0][pos%mod][k]=total(pos,k);
                    dif[1][pos%mod][k]=-total(pos,k);
                }
                else{
                    dif[0][pos%mod][k]=dif[1][pos%mod][k]=0;
                    if(pos+k+k-1<=n){
                        dif[0][pos%mod][k]=dif[1][(pos+k)%mod][k];
                        if(pos+k+k+1-1<=n)
                            dif[0][pos%mod][k]=min(dif[0][pos%mod][k],dif[1][(pos+k)%mod][k+1]);
                    }
                    dif[0][pos%mod][k]+=total(pos,k);

                    if(pos+k+k-1<=n){
                        dif[1][pos%mod][k]=dif[0][(pos+k)%mod][k];
                        if(pos+k+k+1-1<=n)
                            dif[1][pos%mod][k]=max(dif[1][pos%mod][k],dif[0][(pos+k)%mod][k+1]);
                    }
                    dif[1][pos%mod][k]-=total(pos,k);
                }
            }
        }
        int tmp=0;
        if(n>=1){
            tmp=dif[0][1][1];
            if(n>=2) tmp=max(tmp,dif[0][1][2]);
        }
        printf("%d\n",tmp);
    }
    return 0;
}