[状态压缩]poj3254 Corn Fields

A - Corn Fields

Time Limit:2000MS     Memory Limit:65536KB     64bit IO Format:%lld & %llu

Submit  Status  Practice  POJ 3254

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.

题意：

1代表可以放，0不可以，不能有临边，求放置的方案数

思路：

跟poj1185炮兵阵地是一类题，但是统计的不是最大值，而是方案数

状态转移方程：f[s][i] += f[s-1][j];//f[s][i] 对于前s行，第s行采取i状态的方案数 = 第(s-1)行采取j状态的方案数的总和（前提是地形Map和方案cur不冲突）

我们需要注意一点，求放置的方案数时，一个都不放也是一种可行的状态，所以我们将给的地图反着存，即是1存0，是0存1，在最后的“反思”中我会纤细解释；

开Map数组来存储地形，可以放的为0，不可以放的为0；

开cur数组来储存每行不考虑地形在1*n的范围内没有临边的放置分布，可以放的为1，不可以放的为0（这个放置原则与地形相反），这样这个cur数组就考虑的左右的临边问题，上下的临边问题我们在写题的过程中利用当前行和上行的状态不能有1重合为标准；

Map和cur数组和炮兵阵地的储存意义完全一样；

还是以样例为例：

/*
2 3
1 1 1
0 1 0
------
9
*/

Map数组：

	二进制	十进制
0	000	0
1	101	5

cur数组：

cur	二进制	十进制
0	0	0
1	1	1
2	10	2
3	100	4
4	101	5

下面是和炮兵阵地那道题不一样的地方，也是本题关键，就是我们怎么来统计方案个数，这个挺迷的，迷糊了挺久；

for(s = 1; s < n; s++)
    for(i = 0; i < p; i++)
    {
        //f[s][0] += f[s-1][i];//因为i=0状态时什么也不放，上一行所有状态都可以取
        if(!(Map[s] & cur[i]))
            for(j = 0; j < p; j++)
            {
                if(!(Map[s-1] & cur[j]))
                if(!(cur[i] & cur[j]))
                    f[s][i] = (f[s][i] + f[s-1][j]) % mod;
            }
    }

s枚举当前行，i枚举第s行状态，如果满足当前行地形和i方案不冲突的条件 -》 进入下一循环；

j枚举第(s-1)上一行，如果满足上一行地形和j方案不冲突，且i方案和j方案不冲突的条件 -> 状态转移方程；

给 f 数组的表格

f[0][0~4]的cur都满足Map，所以f[0][0~4]的方案数都是1；

f[1][0~4]的只有f[1][0]和f[1][2]的cur[0]和cur[2]满足Map[1]，cur[0]是不放置任何的状态，所以上一行的所有方案f[0][0-4]都满足，所以f[1][0] += f[0][0~4] = 5；

而f[1][2]，上一行只有cur[0/1/3/4]符合，所以f[1][0] += f[0][0/1/3/4] = 4；

当前行采取某一状态的方案数，要加上所有的上一行采取的不与当前行这一状态相冲突的状态的方案数的和，就是这样；

最后把f[n-1][0~m-1]加起来，即n行的满足地形的放置方案数；

代码：

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
/*
f[s][i] += f[s-1][j]
*/
const int mod = 100000000;
int f[13][1<<12];//f[s][i] 对于前s行，第s行采取i状态的方案数
int Map[13];//储存地形
int cur[1<<12];//储存没有临边的方案//wa了很多次，就是这个cur的数组范围！要开大一点，13不行的亲
int n, m;

bool judge(int x)
{
    if(x & (x<<1))
        return false;
    return true;
}
int main()
{
    int s, i, j, a;

    scanf("%d%d", &n, &m);
    //Map记录地形，01倒着存
    for(i = 0; i < n; i++)
        for(j = 0; j < m; j++)
        {
            scanf("%d", &a);
            if(a == 0)
                Map[i] += 1<<(m-j-1);
        }
    //记录状态
    int p = 0;
    for(i = 0; i < (1<<m)-1; i++)
        if(judge(i))
            cur[p++] = i;
    //边界条件：第一行
    for(i = 0; i < p; i++)
        if(!(Map[0] & cur[i]))
            f[0][i] = 1;
    //f[0][0] = 1;
    for(s = 1; s < n; s++)
    for(i = 0; i < p; i++)
    {
        //f[s][0] += f[s-1][i];//因为i=0状态时什么也不放，上一行所有状态都可以取
        if(!(Map[s] & cur[i]))
            for(j = 0; j < p; j++)
            {
                if(!(Map[s-1] & cur[j]))
                if(!(cur[i] & cur[j]))
                    f[s][i] = (f[s][i] + f[s-1][j]) % mod;
            }
    }
    __int64 sum = 0;
    for(i = 0; i < p; i++)
        sum = (sum + f[n-1][i]) % mod;
    printf("%I64d", sum);

    return 0;
}
/*
2 3
1 1 1
0 1 0
------
9
*/

反思：

为什么将给的地图反着存，即是1存0，是0存1呢，先放上错误代码：

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
/*
f[s][i] += f[s-1][j]
*/
const int mod = 100000000;
int f[13][1<<12];//f[s][i] 对于前s行，第s行采取i状态的方案数
int Map[13];//储存地形
int cur[13];//储存没有临边的状态
int n, m;

bool judge(int x)
{
    if(x & (x<<1))
        return false;
    return true;
}
int main()
{
    int s, i, j, a;

    scanf("%d%d", &n, &m);
    //Map记录地形
    for(i = 0; i < n; i++)
        for(j = 0; j < m; j++)
        {
            scanf("%d", &a);
            if(a == 1)
                Map[i] += 1<<(m-j-1);
        }
    //记录状态
    int p = 0;
    for(i = 0; i < (1<<m)-1; i++)
        if(judge(i))
            cur[p++] = i;
    //边界条件：第一行
    for(i = 0; i < p; i++)
        if(Map[0] & cur[i])
            f[0][i] = 1;
    f[0][0] = 1;
    for(s = 1; s < n; s++)
    for(i = 0; i < p; i++)
    {
        //f[s][0] += f[s-1][i];//因为i=0状态时什么也不放，上一行所有状态都可以取
        if(Map[s] & cur[i] || cur[i]==0)
            for(j = 0; j < p; j++)
            {

                if(Map[s-1] & cur[j] || cur[j]==0)
                if(!(cur[i] & cur[j]))
                    f[s][i] += f[s-1][j];
            }
    }
    int sum = 0;
    for(i = 0; i < p; i++)
        sum += f[n-1][i] % mod;
    printf("%d", sum);

    return 0;
}

在这个代码中，数组cur和AC代码一样，Map有不同，Map是正着存的，以样例为例：

/*
2 3
1 1 1
0 1 0
------
9
*/

Map数组：

Map	二进制	十进制
0	111	7
1	010	2

这样存是很方便，但是有一个很严重的问题，前面有写“可以一个也不放”，这点很重要；

如果正着存，那我们就不能写if(!(Map[s] & cur[i]))了，得写成if(Map[s] & cur[i])，当这就出现一个问题：

当s=1，i=0时，也就是第s行一个也不放的情况，这种情况!(Map[1] & cur[0] = !(010 & 0) = !0 = 1返回正值，而(Map[1] & cur[0]) = (101 & 0) = 0，返回0，显然不对。

我还做了个补充

f[s][0] += f[s-1][i];//因为i=0状态时什么也不放，上一行所有状态都可以取

没半毛钱卵用，只在当前行为s的f[s][0]时对i = 0的情况有作用，但是对上行j=0的状态不起作用

if(Map[s-1] & cur[j])

在 j=0 时没用，与其这么麻烦的考虑，不如直接把地图反着存吧