poj2411 状态压缩dp

一道经典状态压缩dp题目。

题意很明确，让用1*2或2*1的小方格铺满地板。根据状态压缩的惯用思路，当前行的地板状态是由当前行和上一行共同决定的，肯定要用一个二进制数表示一行的状态，然后再用状态转移方程转移求解。

这道题可以这么想，对于每个状态，如果是1*2的横着放，将两个位置都标记为1，如果是2*1的竖着放，那么将上面位置标记成0，下面位置标记成1，这样的话，就能保证，如果最后一行铺满且没有2*1的起始方块，最后一行的状态肯定全是1，这样便确定了结果状态。起始状态也很明显，由于第一行上面肯定不存在放砖块的位置，故除了将第一行全部标记成1的状态的种数设置成1外，第一行其他状态全部设为0。然后就是状态转移了

状态转移有两种思路：

1）：求出所有状态及该状态的上一行状态，构成一个状态组，相当于预处理两行的状态，然后进行状态转移，具体看代码。

#include <iostream>
#include <cstring>
#include <cstdio>

using namespace std;

int h,w;
int l,now,pre,cnt;      //l为当前处理的长度，now表示当前的行状态，pre表示当前的上一行状态，cnt记录状态数
int status[20000][2];   //0表示上一行状态，1表示当前行状态，数组第一维表示一个两行的状态组
long long int dp[15][20000];

void dfs(int l,int now,int pre)
{
    if (l>w)    //如果处理超过当前宽度，返回
        return ;
    if (l==w)   //如果长度相等，则该dfs路径构成一组可行的状态组，记录
    {
        cnt++;
        status[cnt][0]=pre;
        status[cnt][1]=now;
    }
    dfs(l+2,(now<<2)|3,(pre<<2)|3); //当前行横放一个1*2的砖块，那么上一行要么是横放一个1*2的砖块，要么是2*1的下面，总之肯定是1
    dfs(l+1,(now<<1)|1,pre<<1); //当前行放2*1的下面部分，那么上一行肯定是2*1的上面部分，表示为0
    dfs(l+1,now<<1,(pre<<1)|1); //当前行放2*1的起始部分，那么上一行肯定不是2*1的起始部分，也就是说不为0
    //这样得到的任意一个01字串组，肯定都能用砖块来铺满，不必担心没有铺满的问题
}

int main()
{
    while (cin>>h>>w&&h+w)
    {
        l=now=pre=cnt=0;
        dfs(l,now,pre);
        memset(dp,0,sizeof(dp));
        dp[0][(1<<w)-1]=1;//将铺满1的状态设为1
        for (int i=1;i<=h;i++)
        {
            for (int t=1;t<=cnt;t++)
            {
                dp[i][status[t][1]]+=dp[i-1][status[t][0]];//直接进行状态转移
            }
        }
        cout<<dp[h][(1<<w)-1]<<endl;//输出最后一行铺满的状态
    }
}

 

2）：枚举当前行的所有状态和上一行的所有状态，判断两者是否冲突，不冲突就进行状态转移，具体看代码。

这个代码将起始状态设为全为0，横铺两个为00，竖铺上为1下为0，这样合法的末状态就是全为0的状态，合法的初状态较多，需要枚举（读者可以想想为什么上一种表示方法初状态只有一个，而这个表示方法初状态却有多个，跟表示的方法有关）

#include <iostream>
#include <cstring>
#include <cstdio>

using namespace std;

int n,m;
long long int dp[15][2500];

bool ok(int s1,int s2)
{
    if (s1&s2)  //如果两个状态有重合的1，则说明都为2*1的上部，状态冲突
        return false;
    int s=s1|s2;//否则将两个状态合并取或
    for (int i=0;i<m;i++)
    {
        int j=s&(1<<i); //判断当前位置是否为0
        if (j==0)   //如果当前位置为0，则表示两个状态的当前位置都为0，故当前位置不可能为一个竖着的2*1，只能为两个横着的1*2
        {
            if (i==m-1) //如果到了最后一个位置，则这种状态肯定不合法
                return false;
            i++;        //否则看下一个位置
            if (s&(1<<i))   //如果下一个位置是1，则肯定不合法，不存在能生成这种情况的组合
                return false;
        }
    }
    //如果两个状态不存在冲突，则两者兼容，返回true
    return true;
}

int main()
{
    while (cin>>n>>m&&n+m)
    {
        if (n*m%2==1)
        {
            cout<<0<<endl;
            continue ;
        }

        if (n<m)
        {
            int a=n;
            n=m;
            m=a;
        }
        memset(dp,0,sizeof(dp));
        int cnt=(1<<m)-1;
        for (int i=0;i<=cnt;i++)    //初始化初始状态，读者想想为什么这里要用循环初始化而上一个代码只用一个等式初始化
        {
            if (ok(0,i))
            {
                dp[1][i]=1;
            }
        }
        for (int i=2;i<=n;i++)      //状态转移
        {
            for (int t=0;t<=cnt;t++)
            {
                for (int k=0;k<=cnt;k++)
                {
                    if (ok(t,k))
                    {
                        dp[i][k]+=dp[i-1][t];
                    }
                }
            }
        }
        cout<<dp[n][0]<<endl;   //输出结果
    }
}