ZOJ:3802 Easy 2048 Again （状态压缩）

题意：1维的2048。

思路：很好的一道DP。

可以观察如4、16、8这样的组合，其中的4就永远都不会被合并，因为以后的结果只能是越来越大。所以可以被合并的数列特征是递减序的，如32、16、4。这样我们可以以当前组合中的末尾递减序列为状态进行DP。这里的状态大小不是非常明显，仔细想想极限情况，有500个16，每2个16形成32，每2个32形成64…如此合并,至多就是16*500的状态，因此开8000+的数组作为状态就行了。

转移这里比较好想，用刷表法更方便，考虑下一个数字要不要加入到当前的序列状态中。如果加入的话，考虑与当前状态的递减序数列的最小数字的大小关系，这里都很好想。注意如果加入的数字与递减序数列最后一个数相同，即可以合并时，要一口气合并到最终状态，如16、8、4，这时候再加入一个4，应该转移到32，至于得到的分数也要额外计算。

另外刷表法得整体初始化状态，所以滚动数组，否则容易超时。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn=505;
const int maxm=8000;
int a[maxn];
int dp[2][maxm+5];

int getState(int S,int v,int &val)
{
    val=0;
    while(S&(-S))
    {
        int last=S&(-S);
        if(last==v)
        {
            val+=v;
            v=v<<1;
            S-=last;
        }
        else
            break;
    }
    val+=v;
    return S+v;
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;++i)
        {
               scanf("%d",&a[i]);
        }
        memset(dp,-1,sizeof(dp));
        dp[0][0]=0;
        for(int i=0;i<n;++i)
        {
            for(int j=0;j<=maxm;++j)
            {
                if(dp[i&1][j]==-1) continue;
                int last=j&(-j);
                if(j==0||a[i+1]>last)
                    dp[(i+1)&1][a[i+1]]=max(dp[(i+1)&1][a[i+1]],dp[i&1][j]+a[i+1]);
                 if(a[i+1]<last)
                    dp[(i+1)&1][j+a[i+1]]=max(dp[(i+1)&1][j+a[i+1]],dp[i&1][j]+a[i+1]);
                 if(a[i+1]==last)
                {
                    int val;
                    int newstate=getState(j,a[i+1],val);
                    dp[(i+1)&1][newstate]=max(dp[(i+1)&1][newstate],dp[i&1][j]+val);
                }
                dp[(i+1)&1][j]=max(dp[(i+1)&1][j],dp[i&1][j]);
                dp[i&1][j]=-1;
            }
        }
        int ans=0;
        for(int i=0;i<=maxm;++i)
            ans=max(ans,dp[n&1][i]);
        printf("%d\n",ans );
    }
    return 0;
}