[状态压缩DP] Poj 3254, Poj 1185

    状态压缩DP一般适合的题型的特征为：一个矩阵，行数较大，列数较小，每个点的状态只有两种。正好用一个整型数int来表示每行的一种状态（其实是其二进制形式，每bit的0和1表示每点的状态）。不同的是各题的状态dp的定义，状态间的限制，状态的转换方程。

第一道（Poj 3254）：

/**
题意：在一片M行N列的草地上（用0和1矩阵表示），1表示能放牛，0表示不能放。
在草地上放牛并且牛不能相邻，问有多少种放法（一头牛都不放也算一种）。

题解：对于每一行来说，放牛的可能数有2^N种，但是根据以下限制条件就能排除很多：
1.每行中的牛不能相邻，经计算当N=12时，满足条件的状态只有377个
2.每行中放牛要满足草地的硬件条件，只有1处可放，排除一些
3.上一行中与本行对应的位置处不能放牛，排除一些

由于N值最大为12，所以可以用一个二进制数来表示一行的状态，这就是“状态压缩”了。
定义dp[i][j]:第i行的状态为state[j]时，前i行能放牛方法的总数.
*/

#include <cstdio>
#include <queue>
#include <algorithm>
#include <iostream>
#include <cstring>

using namespace std;

#define MOD 100000000

int n, m, row[12];
int nState, state[1000];
int dp[14][1000];

void init()
{
int k = 1 << n;
nState = 0;
for (int i = 0; i < k; i++)
if ( (i & (i<<1)) == 0 )
state[nState++] = i;
}

int main()
{
int k;

scanf("%d %d", &m, &n);
init();
for (int i = 0; i < m; i++)
{
row[i] = 0;
for (int j = n-1; j >= 0; j--)
{
scanf("%d", &k);
row[i] += k << j;
}
}

// 求dp[0]，若state[j]满足第0行草地的硬件条件，则dp[0][j]=1
for (int j = 0; j < nState; j++)
{
dp[0][j] = ( (row[0] & state[j]) == state[j] ) ? 1 : 0;
}

// 求dp[i]，如果state[j]和第i-1行的状态state[k]不冲突，则dp[i][j]=Σ(dp[i-1][k])
for (int i = 1; i < m; i++)
{
for (int j = 0; j < nState; j++)
{
if ( (row[i] & state[j]) != state[j] )  //判断是否满足草地硬件条件
continue;
for (int k = 0; k < nState; k++)
{
if ( dp[i-1][k] && (state[k]&state[j]) == 0 )
dp[i][j] = (dp[i][j] + dp[i-1][k]) % MOD;
}
}
}

int res = 0;
for (int j = 0; j < nState; j++)
{
if ( dp[m-1][j] )
res = (res + dp[m-1][j]) % MOD;
}
printf("%d\n", res);

return 0;
}

第二道（Poj 1185）：

/**
题意：在一个n行m列的矩阵中，字符'P'处能放炮兵，字符'H'处不能放炮兵。
并且如果两个炮兵在一条（水平或垂直）直线上时，它们的距离不能小于2，问最多放多少个兵。

由于在求第i行时，它的状态要收到第i-1行和i-2行的影响，所以定义一个三维dp:
dp[i][j][k]表示第i行的状态为state[j]，第i-1行的状态为state[k]时，前i行能放炮兵的最大数量。

for ( ... i < n ...)
{
for ( ... j < nState ... )
{
如果状态j和第i行的地形不冲突，那么：
for ( ... k < nState ... )
{
如果第i行状态j和第i-1行状态k不冲突，那么：
for ( ... h < nState ... )
{
如果第i行状态j和第i-2行状态h不冲突，那么：
在dp[i-1][k][h]中找最大的一个赋值给dp[i][j][k]，再加上state[j]中1的个数
}
}
}
}

*/

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

int n, m, dp[105][80][80];      //dp[i][j][k]表示第i行的状态为j，第i-1行的状态为k时能放炮兵的最大数量

int nState, state[80], num[80]; //10位二进制位中各个1之间的距离不小于2，这样的数只有60个。
//依次存放在state[]中，num[i]表示state[i]中1的个数

//在小于2^m的数中找1之间的距离不小于2的数，保存在state[]中
void init()
{
int k = 1 << m;
nState = 0;
for (int i = 0; i < k; i++)
if ( (i&(i<<1)) == 0 && (i&(i<<2)) == 0 )
{
state[nState] = i;
num[nState] = 0;
int j = i;
while (j)
{
num[nState] += j % 2;
j /= 2;
}
nState++;
}
}

int main()
{
int  row[105];
char str[15];

while ( cin >> n >> m )
{
init();
for (int i = 0; i < n; i++)
{
row[i] = 0;
scanf("%s", str);
for (int j = 0; j < m; j++)
if (str[j] == 'P')
row[i] += 1 << j;
}

memset(dp, 0, sizeof(dp));

// 计算dp[0]
for (int j = 0; j < nState; j++)
{
if ( (state[j] & row[0]) != state[j] )
continue;
for (int k = 0; k < nState; k++)
dp[0][j][k] = num[j];
}

// 计算dp[1]
if (n > 1)
for (int j = 0; j < nState; j++)
{
if ( (state[j] & row[1]) != state[j] )
continue;
for (int k = 0; k < nState; k++)
{
if ( (state[j] & state[k]) == 0 )
dp[1][j][k] = dp[0][k][0] + num[j];
}
}

// 计算dp[>1]
for (int i = 2; i < n; i++)
{
for (int j = 0; j < nState; j++)
{
if ( (state[j] & row[i]) != state[j] )
continue;
for (int k = 0; k < nState; k++)
{
if ( state[j] & state[k] )
continue;
for (int h = 0; h < nState; h++)
{
if ( state[j] & state[h] )
continue;
if ( dp[i-1][k][h] > dp[i][j][k] )
dp[i][j][k] = dp[i-1][k][h];
}
dp[i][j][k] += num[j];
}
}
}

// 在dp[n-1]中找最大值
int max = 0;
for (int j = 0; j < nState; j++)
{
for (int k = 0; k < nState; k++)
if (max < dp[n-1][j][k])
max = dp[n-1][j][k];
}

printf("%d\n", max);
}
}

---------------------- 更多“状态压缩DP”题目... ------------------------