POJ 3254 Corn Fields：网格密铺类 状压dp

题目链接：http://poj.org/problem?id=3254

题意：

　　给你一片n*m的耕地，你可以在上面种玉米。但是其中有一些地方是荒芜的，不能种植。并且种植玉米的地方不能相邻。问你在这片地上有多少种种植方案。

 

题解：

　　思路：一行一行种

　　状态表示：

　　　　dp[state][i] = num of ways at ith row

　　　　（1）当前种到了第i行

　　　　（2）第i行有哪些地方种了玉米，状态为state

　　如何转移：

　　　　约束条件：

　　　　　　（1）对于当前行，已经在某些地方种过了玉米，那么在下一行的对应位置就不能再种。

　　　　　　（2）在每一行内部，种植玉米不能相邻。

　　　　　　所以可以预处理（dfs）出在一行上每一种state对应的下一行可以种的方案nex。

　　　　转移条件：

　　　　　　（1）state在当前第i行合法。

　　　　　　（2）state对应的nex在i+1行合法。

　　　　　　所以在读入的时候，就可以预处理出每一行土地的情况field[i]。二进制下每一位0代表可以种，1代表不能种。

　　　　　　以上两个条件就变成了：(state&field[i])==0 和 (nex&field[i+1])==0

　　　　转移：

　　　　　　三重for循环，枚举种到第i行、当前行的种植方案state、state对应的下一行的种植方案nex。

　　　　　　dp[state|nex][i+1] += dp[state][i]

 

AC Code：

// optimizations:
// 1) a state is legal at a row only if: state&field == 0
// 2) preprocess the states can be transfered from another state

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
#define MAX_N 15
#define MAX_S (1<<14)
#define MOD 100000000

using namespace std;

int n,m;
int ans;
int field[MAX_N];
int dp[MAX_S][MAX_N];
vector<int> transfer[MAX_S];

void read()
{
    memset(field,0,sizeof(field));
    cin>>n>>m;
    int temp;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            cin>>temp;
            field[i]<<=1;
            field[i]|=(!temp);
        }
    }
    field[n]=(1<<m)-1;
}

void dfs(int col,int state,int nex)
{
    if(col>=m)
    {
        transfer[state].push_back(nex);
        return;
    }
    if(!((state>>col)&1)) dfs(col+2,state,nex|(1<<col));
    dfs(col+1,state,nex);
}

void solve()
{
    for(int state=0;state<(1<<m);state++)
    {
        dfs(0,state,0);
    }
    memset(dp,0,sizeof(dp));
    for(int i=0;i<transfer[0].size();i++)
    {
        int state=transfer[0][i];
        if(!(field[0]&state)) dp[state][0]=1;
    }
    for(int i=0;i<n;i++)
    {
        for(int state=0;state<(1<<m);state++)
        {
            if(dp[state][i]!=0 && !(field[i]&state))
            {
                for(int j=0;j<transfer[state].size();j++)
                {
                    int nex=transfer[state][j];
                    if(!(field[i+1]&nex))
                    {
                        dp[nex][i+1]+=dp[state][i];
                        dp[nex][i+1]%=MOD;
                    }
                }
            }
        }
    }
}

void print()
{
    cout<<dp[0][n]<<endl;
}

int main()
{
    read();
    solve();
    print();
}