poj 3254 && 2411

状态压缩dp，感觉还是不清晰，虽说就两种状态 0 1，但是感觉变化太多了，而且状态转移也不好想

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

题意：给出 N * M的图，上面只有 0 或者 1两种情况，如果是 1 表示这里可以放牛，如果是 0 表示不可以放牛，而且牛是不可以相邻的，问在这片区域内最多有多少种放牛的方案

很简单的一个状态压缩 按给出的样例来说

先看第一行 （1 表示该位置有牛，0 表示该位置没有牛）可以用二进制串来表示牛的放置情况

0 0 0 （0）   0 0 1（1）  0 1 0 （2） 1 0 0（4）  1 0 1（5） 也就是题目中给的第一行最多有这五种情况，分别对应的十进制数 为 0 1 2 4 5

第二行 

0 0 0 （0） 0 1 0 （2）只有这两种情况，对应的数为 0 2 。当是 0 这种情况时，于第一行的每一种情况都不冲突，所以有 5种，当是第二种情况是，那么与第一行的 2 这种情况有冲突（两头牛不可一相邻）所以是四种情况，所以一共有 9种 放牛的方案

所以预处理每一行可以放牛的情况总数，然后计算每一行时判断与上一行是否有冲突

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#define N 100
#define mod 100000000
#define _clr(a,val) (memset(a,val,sizeof(a)))

using namespace std;

int n,m;
vector<int>num[13];
int dp[20][3000]; // dp [i][j] 表示 第 i 行取第 j 种方案时可行的方案数
void cal(int x,int y)
{
    for(int i = 0; i < (1 << m); i++)
    {
        if((i >> 1) & i || (i << 1) & i) continue; 
        if(i & y) continue; 
        num[x].push_back(i);
    }
}
int main()
{
    int i,j,k;
    int x;
    //freopen("data.txt","r",stdin);
    while(scanf("%d%d",&n,&m) != EOF)
    {
        //_clr(num,0);
        for(i = 1; i <= n; i++)
        {
            num[i].clear();
            int tem = 0;
            for(j = 1; j <= m; j++)
            {
                scanf("%d",&x);
                x = 1 - x;
                tem = tem * 2 + x;
            }
            cal(i,tem); // 计算 第 i 行可以放牛的各种情况
        }
        _clr(dp,0);
        for(i = 0; i < num[1].size(); i++)
        dp[1][i] = 1;
        for(i = 2; i <= n; i++)
        {
            for(j = 0; j < num[i].size(); j++)
            {
                for(k = 0; k < num[i - 1].size(); k++)
                {
                    if(num[i][j] & num[i - 1][k]) // 不为零，说明放牛有冲突，跳过
                    {
                        continue;
                    }
                    dp[i][j] += dp[i - 1][k];
                }
            }
        }
        int ans = 0;
        for(i = 0; i < num[n].size(); i++)
        {
            ans = (ans + dp[n][i]) % mod;
        }
        printf("%d\n",ans);
    }
    return 0;
}

题目：http://poj.org/problem?id=2411

题意：棋盘覆盖问题，给出一个 h * w 的棋盘，让你用 2 * 1的方块或横或竖的去覆盖棋盘，问有多少种方案数

0：表示该格是横放或是由上一层的竖放恰好填上了

1：表示该格竖放并且对下一行有影响

该行的状态可以用一个2进制数来表示，如果是 1，那么下行该格一定为零，但如果为零，那么下行该格可以是 1 也可以是 0

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#define N 20
#define mod 100000000
#define _clr(a,val) (memset(a,val,sizeof(a)))

using namespace std;

typedef long long ll;
ll dp[N][3000];
int h,w;
int i,j;
void dfs(int x,int s)  // 下层的第 x 个位置，s 为下一层的状态
{
    if(x == w + 1) // 如果 x 是边界时，直接求出下层为状态s 的方案数，返回
    {
        dp[i + 1][s] += dp[i][j];
        return ;
    }
    else
    {
        if((j >> (x - 1) & 1) == 1)  // 上层为 1，下层为 0
        dfs(x + 1,s);
        else  // 上层 为 0
        {
            if(x + 1 <= w && (j >> x & 1) == 0) // 下层为 0
            dfs(x + 2,s);
            dfs(x + 1,s | (1 << (x - 1))); // 将下层该位置改为 1
        }
    }
}
int main()
{
    //freopen("data.txt","r",stdin);
    while(scanf("%d%d",&h,&w) != EOF)
    {
        if(h == 0 && w == 0) break;
        if(h * w % 2)
        {
            cout<<"0\n";
            continue;
        }
        _clr(dp,0);
        dp[0][0] = 1;
        int temp = 1 << w;
        for(i = 0; i <= h; i++)
        {
            for(j = 0; j < temp; j++)
            {
                if(dp[i][j])
                dfs(1,0);
            }
        }
        printf("%I64d\n",dp[h][0]);
    }
    return 0;
}