Corn Fields——POJ3254状态压缩Dp

Corn Fields

Time Limit: 2000MS	Memory Limit: 65536K

Description

Farmer John has purchased a lush new rectangular pasture composed of M by N (1 ≤ M ≤ 12; 1 ≤ N ≤ 12) square parcels. He wants to grow some yummy corn for the cows on a number of squares. Regrettably, some of the squares are infertile and can’t be planted. Canny FJ knows that the cows dislike eating close to each other, so when choosing which squares to plant, he avoids choosing squares that are adjacent; no two chosen squares share an edge. He has not yet made the final choice as to which squares to plant.

Being a very open-minded man, Farmer John wants to consider all possible options for how to choose the squares for planting. He is so open-minded that he considers choosing no squares as a valid option! Please help Farmer John determine the number of ways he can choose the squares to plant.

Input

Line 1: Two space-separated integers: M and N

Lines 2..M+1: Line i+1 describes row i of the pasture with N space-separated integers indicating whether a square is fertile (1 for fertile, 0 for infertile)

Output

Line 1: One integer: the number of ways that FJ can choose the squares modulo 100,000,000.

Sample Input

2 3

1 1 1

0 1 0

Sample Output

9

Hint

Number the squares as follows:

1	2	3
	4

There are four ways to plant only on one squares (1, 2, 3, or 4), three ways to plant on two squares (13, 14, or 34), 1 way to plant on three squares (134), and one way to plant on no squares. 4+3+1+1=9.

Source

USACO 2006 November Gold

题意：在一个n*m的草场上，每一块草场都可以放一只牛，有的草场是贫瘠的，所以不能放牛。由于这些牛比较孤僻，所以不喜欢在自己吃草的地方周围有其他的牛（上下左右），问总共有多少种放法。

思路：在图上的每一个点都可能放牛（除去荒地），所以搜索的时间复杂度很高。

• 假设我们知道矩阵的n和m，我们用二进制表示在一行的放牛的状态（不考虑荒地），则所有的状态为[0,1 << m),状态是否符合可以根据（x&(x<<1)）,返回值为0表示没有相邻的1，则符合条件，否则不符合条件，这样我们就记录在草场宽为m时的所有可以放的情况，记录在Sta数组中。
• 由于有荒地，所以对于每一行的第j个草地如果为荒地则为1，否则为零，这样就可以每一行有一个数表示他们的草地的状态，存在Map数组中，如果要判断在符合情况的方式中是不是有矛盾的，可以用Map[i]&Sta[j]==0（表示第i行草地与第j种方式），如果等于零则符合，不等于零则不符合（在纸上写写看看为什么）。
• 首先将第一行的所以状态初始化即Dp[1][j]=(Map[1]&Sta[j])==0?1:0,然后根据第一行的所有状态去枚举第二行看是否符合,即

for i=2 -> n
{
    for j=0 -> num
    {
        if Map[i]&Sta[j] == 1
        {
            continue;
        }
        for k=0 -> num
        {
            if Map[i-1]&Sta[k] == 1
            {
                continue;
            }
            if Sta[j]&Sta[k]==0
            {
                Dp[i][j]+=Dp[i-1][k]
            }
        }
    }
}

具体情况见代码

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
const int Max = 1<<13;
const int Mod = 100000000; 
int Dp[15][Max];
int Map[15];
int Sta[Max];
bool Judge(int x)
{
    return (x&(x<<1));
}
bool Dec(int x,int y)
{
    return (Map[x]&Sta[y]);
}
int main()
{
    int n,m;
    while(~scanf("%d %d",&n,&m))
    {
        memset(Map,0,sizeof(Map));
        memset(Dp,0,sizeof(Dp));
        memset(Sta,0,sizeof(Sta));
        int data;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                scanf("%d",&data);
                if(data==0)
                {
                    Map[i]+=(1<<(j-1)); //每一行的情况用一个数来表示
                }
            }
        }
        int num = 0 ;
        for(int i=0;i<(1<<m);i++)//所有符合方式
        {
            if(!Judge(i))
            {
                Sta[num++] = i;
            }
        }
        for(int i=0;i<num;i++)//第一行的所有状态初始化
        {
            if(!Dec(1,i))
            {
                Dp[1][i]=1;
            }
        }
        for(int i=2;i<=n;i++)
        {
            for(int j=0;j<num;j++)
            {
                if(Dec(i,j))// 是否符合
                {
                    continue;
                }
                for(int k=0;k<num;k++)
                {
                    if(Dec(i-1,k))//i-1行是否符合第k种情况
                    {
                        continue;
                    }
                    if(!(Sta[j]&Sta[k])) //上下行之间也互相的满足条件
                    {
                        Dp[i][j]+=Dp[i-1][k];
                    }
                }
            }
        }
        int ans =0;
        for(int i=0;i<num;i++)
        {
            ans+=Dp[n][i];
            ans%=Mod;
        }
        printf("%d\n",ans);
    }
    return 0;
}