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,,sizeof(field));
     cin>>n>>m;
     int temp;
     for(int i=;i<n;i++)
     {
         for(int j=;j<m;j++)
         {
             cin>>temp;
             field[i]<<=;
             field[i]|=(!temp);
         }
     }
     field[n]=(<<m)-;
 }

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

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

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

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