poj 1038 状态压缩dp 四进制压缩

黑书上的牛逼题

状态压缩，每个格子有0，1，2三种状态。0表示这个格子为空，1表示这个格子到下一行为空。2表示这个格子到下下一行为空。

如果以(x,y)这个格子为左上角放2*3的矩形，则(x,y)=(x,y+1)=(x+1,y)=(x+1,y+1)=(x+2,y)=(x+2,y+1)=2。

如果以(x,y)这个格子为左上角放3*2的矩形，则(x,y)=(x,y+1)=(x,y+2)=(x+1,y)=(x+1,y+1)=(x+1,y+2)=1。

从x行转到x+1行后，(x,1..m)上的值都得减一，除非(x,y)=1。

具体实现时，用四进制表示三进制，采用位运算加速。但这样状态总数为1048576个，比3^10=59049大了不少。考虑到状态是离散的，可以使用vector记录状态。

注意点：使用vector记录状态，会有重复的状态值，所以要用sort来去除那些重复的，保留最优值。

【代码】

#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

struct node
{
    int st,ss;
    node(int sst=0,int sss=0)
    {
        st=sst;ss=sss;
    }
};

vector<node> dp[2];
bool v[153][13];
int i,j,ans,kk,n,m,x,y,cc;

inline int get(int st,int c)
{
    return (st>>(c*2-2))&3;
}

inline void set(int& st,int c,int d)
{
    int d1=(st>>(c*2-2))&3;
    st-=d1<<(c*2-2);
    st|=d<<(c*2-2);
}

void dfs(int c,int st,int ss)
{
    if (c>m)
    {
        dp[x].push_back(node(st,ss));
        return;
    }
    int nst;
    if (i+2<=n && c+1<=m && !v[i][c] && !v[i][c+1] &&!v[i+1][c] && !v[i+1][c+1]
    && !v[i+2][c] && !v[i+2][c+1] && get(st,c)==0 && get(st,c+1)==0)
    {
        nst=st;
        set(nst,c,2);set(nst,c+1,2);
        dfs(c+2,nst,ss+1);
    }
    if (c+2<=m && !v[i][c] && !v[i][c+1] && !v[i][c+2] && !v[i+1][c] &&
    !v[i+1][c+1] && !v[i+1][c+2] && get(st,c)==0 && get(st,c+1)==0 && get(st,c+2)==0)
    {
        nst=st;
        set(nst,c,1);set(nst,c+1,1);set(nst,c+2,1);
        dfs(c+3,nst,ss+1);
    }
    nst=st;
    set(nst,c,max(get(nst,c)-1,0));
    dfs(c+1,nst,ss);
}

bool cmp(node a,node b)
{
    return a.st<b.st || a.st==b.st && a.ss>b.ss;
}

int main()
{
    freopen("in3","r",stdin);
    scanf("%d",&cc);
    while (cc--)
    {
        memset(v,0,sizeof(v));
        scanf("%d%d%d",&n,&m,&kk);
        for (i=1;i<=kk;i++)
        {
            scanf("%d%d",&x,&y);
            v[x][y]=true;
        }
        x=0;
        dp[x].clear();
        dp[x].push_back(node(0,0));
        for (i=1;i<n;i++)
        {
            x^=1;
            dp[x].clear();
            sort(dp[x^1].begin(),dp[x^1].end(),cmp);
            for (j=0;j<dp[x^1].size();j++)
            if (j==0 || dp[x^1][j-1].st!=dp[x^1][j].st)
                dfs(1,dp[x^1][j].st,dp[x^1][j].ss);
        }
        ans=0;
        for (i=0;i<dp[x].size();i++)
            ans=max(ans,dp[x][i].ss);
        printf("%d\n",ans);
    }
}