注：在涉及到位运算时，一定要注意位运算的优先级。该加的括号一定要加
状压dp是一类比较难理解的dp;
在讲状压dp之前，我们应该清楚所有的dp是解决多阶段决策最优化问题的一种思想方法；
请注意多阶段这三个字：
经过前面三种背包的学习，可以发现如何定义状态是解决动态规划最重要的一步；
状态的定义也就决定了相当于阶段的划分；
在背包问题中，我们通过物品的件数i和背包的容量j来定义状态或者说是划分阶段；
动态规划多阶段一个重要的特性就是无后效性。无后效性就是值对于某个给定的阶段状态，它以前各阶段的状态无法
直接影响它未来的发展，而只能通过当前的这个状态。换句话说影响当前阶段状态只可能是前一阶段的状态；
那么可以看出如何定义状态是至关重要的，因为状态决定了阶段的划分，阶段的划分保证了无后效性。
————————————————————————————————————————————————————
以上讲了一些基本的概念，以下具体用一个例子和一些习题讲一下状压dp；
有时候为了达到最优子结构和无后效性的效果，我们必须要定义好状态。但是有时候状态维度特别多，但是每个状态的
决策又很少，这样我们开多维数组很可能会浪费，并且可能会爆空间。
这时候我们考虑用状态压缩来做，比如每个状态的决策只有两个，但是状态的维度很多。下面我们用01背包来举例。
有n件物品和一个容量为v的背包。放入第i件物品的占的空间为Ci,得到的价值是Wi;求解每种放法的背包价值；
（当然这不是一个典型的动态规划问题，但是用动态规划的思想有助于讲解状压dp）;
想一想之前动态规划框架讲解，解决动态规划问题首先要定义状态；
1.定义状态：因为这个要求每一种放法的背包价值，所以我们状态应该是这n件物品的放与不放的情况。
最容易想到的是开个n维数组，第i个维度的下标如果是1的话代表放第i件物品，0的话代表不放第i件物品；
但是这样很容易造成空间浪费，而且多维数组也不好开；
我们仔细观察就会发现，每件物品有放与不放两种选择；假设我们有5件物品的时候，用1和0代表放和不放
如果这5件物品都不放的话，那就是00000;
如果这5件物品都放的话， 那就是11111；
看到这，我们知道可以用二进制表示所有物品的放与不放的情况；如果这些二进制用十进制表示的话就只有
一个维度了。而且这一个维度能表示所有物品放与不放的情况；这个过程就叫做状态压缩；
细节：观察可以知道在上面的例子中00000 ~ 11111可以代表所有的情况，转化为十进制就是0~(1<<5 - 1);
2.描述不同状态如何转移:
放的状态只能从不放的状态转移过来，所以dp[10000]只能从dp[00000] + W[1] 转移过来；dp[11000]可以从
dp[01000] + W[1]或者dp[10000] + W[2]转移过来.........
3.按一个方向求出该问题的解
该问题并不是一个典型的动态规划问题，所以不用管；
代码如下：
#include<stdio.h>
const int INF = 1 << 15;
int dp[INF + 10];
int dp1[INF+ 10] ; //定义状态
void print1(int num); //打印在状态为num的时候的所有物品放与不放的情况
/*
3 6
2 5
3 8
4 9 //一组样例
0 0 0
1 5 2
01 8 3
11 13 5
001 9 4
101 14 6
011 17 7
111 22 9
*/
int main()
{
int n,m;
while(~scanf("%d%d",&n,&m))
{
int W[20],C[20];
for(int i = 0; i < n; i++)
scanf("%d %d",&C[i],&W[i]) ;
int res = -1;
for(int i = 0; i < (1 << n); i++)
{
for(int j = 0; j < n; j++)
{
if(!(i&(1 << j))) //状态转移
{
int temp = i | (1<<j);
dp[temp] = dp[i] + W[j];
dp1[temp] = dp1[i] + C[j];
}
}
}
for(int i = 0; i < (1 << n); i++)
{
print1(i);
printf("\t%d\t%d\n",dp[i],dp1[i]); //打印出每种方案的情况，价值 和耗费的空间
}
}
return 0;
}
void print1(int num)
{
int k= 0;
if(num == 0)
printf("0");
for(;(1 << k) <= num; k++)
{
if(num & (1<<k))
printf("1");
else
printf("0");
}
}上面涉及到二进制运算的问题可以看另一篇博客位运算及常用功能；
从上面可以看出：状压dp的特点一般是规模比较小，n一般小于15。而且一般只有两种决策
————————————————————————————————————————————————————
例题1：POJ 2411
这个题规模比较小，而且每个方格只有两种状态，分别是被覆盖和未被覆盖；
所以我们考虑用状态压缩dp；
定义状态：
我们首先定义状态：dp[j][state]，表示能到达第j列，且第j列所有方格的覆盖情况为state时的所有方法数；
这样我们通过这个状态把这个问题分为j个阶段(j代表列数),因为第j列放置的情况最多只能影响到j+1列。比如第j列放置
一个或多个1*2的方格。这样一种情况就会影响到j+1列；但是他最多影响到第j+1列，之后就不能再影响了。
这就是无后效性；无后效性是保证能动态规划的关键。
状态转移：
当第i列第j行状态为0时，表示没有覆盖；当为1时，说明被覆盖了；
如果当前格没有被覆盖，说明我们至少可以放一个1*2的方格，如果当前列的下一行也没有被覆盖，那么我们可以放一个
2*1的方格；如果被覆盖， 那么我们继续往当前列的下一行遍历 ，直到把这一列遍历完； 在这个过程中 ，我们能求出
下一列的合法状态(也就是可以到达的状态)，这是一个搜索的过程，至于为什么要搜索，请看下面：
我们把当前列每一种状态都进行搜索，看能不能找到从这种状态到其他状态的一种路径；如果存在，说明其他状态是
可以到达的。所以我们其实并不需要对每一种状态进行搜索，只需要对可以到达的状态进行搜索即可；
按一个方向求出该问题的解：
当前阶段总是影响下一阶段，所以我们应该按照阶段的方向进行求解，在这个题中是按列的方向求解；题目要求全部填
满，所以答案应该是dp[m+1][0];
代码如下：
#include<stdio.h>
#include<string.h>
#define mmset(a,b) memset(a,b,sizeof(a))
const int INF = 1 << 12 + 10;
long long dp[13][2100];
int n,m;
/*
1 2
1 3
1 4
2 2
2 3
2 4
2 11
4 11
0 0
Sample Output
1
0
1
2
3
5
144
51205
*/
/*搜索从第j列的state状态开始，它能到达第j+1列的哪些状态；
i代表第i行，next代表它能到达第j+1列的next状态
*/
void dfs(int i,int j,int state,int next);
int main()
{
while(~scanf("%d%d",&n,&m) && (n+m))
{
if(n > m) //交换两个变量
{
n = n ^ m;
m = n ^ m;
n = n ^ m;
}
mmset(dp,0); //初始化
dp[1][0] = 1;
for(int j = 1; j <= m; j++) //状态转移
{
for(int state = 0; state < (1 << n); state++)
{
//对能达到的状态进行搜索，看该状态能不能达到其他状态；
if(dp[j][state] > 0)
{
dfs(0,j,state,0);
}
}
}
printf("%lld\n",dp[m+1][0]); //输出答案
}
return 0;
}
void dfs(int i,int j,int state, int next)
{
if(i == n)
{
/*
注意dp[i][j]代表的含义，就知道为什么
dp[j+1][next] += dp[j][state]
*/
dp[j+1][next] += dp[j][state];
return;
}
else
{
if((state&(1 << i) )== 0) //当该格子没被覆盖说明可以放一个1*2的木板
{
dfs(i+1,j,state,next | (1<< i));
}
/*
当该格子没被覆盖且它下面的格子也没被覆盖
说明可以当一个2*1的木板
*/
if(i + 1 < n &&(state & (1 << i)) == 0 && (state & (1 << (i+1))) == 0)
{
dfs(i+2,j,state,next);
}
if((state & (1 << i)) > 0) //当该格子被覆盖时，说明这个格子什么都不能放
{
dfs(i+1,j,state,next);
}
}
}
————————————————————————————————————————————————————
例题2：POJ 3254
可以发现这个题有如下特征，规模较小，每个方格只有两种状态，可以种玉米和不可以种玉米；
仍然考虑用状压dp；
定义状态：
定义状态dp[i][state]表示能到达第i行，且第i行的所有的种玉米和不种玉米的情况为state时的所有状态数。
种玉米代表1，不种玉米代表0；
分析这个状态定义，发现这个状态定义把整个问题分成了n个阶段(代表行数)，并且这n个阶段遵循无后效性；
状态转移：
当前阶段只受前一阶段的影响，当前阶段只能影响到后一阶段。所以状态转移就是把握住当前状态是如何影响后一
阶段的。在这个题中，我们会发现：
如果当前阶段的某列土地种了玉米，那么下个阶段的这列土地就不能种玉米。
另外，如果当前阶段某列土地的前一列土地种了玉米，那么这一列就不能再种玉米了。
需要注意的是，如果当前阶段的某一列可以种玉米，你可以有两种选择，种或不种。
按一个方向求解：
可以看出这个状态定义是按行数分了n个阶段，所以我们应该按照行数来进行求解，根据状态定义，结果是把最后
一行的所有可达到的状态的方法数加和即可。
代码如下：
#include<stdio.h>
#include<string.h>
#define mmset(a,b) memset(a,b,sizeof(a))
const int INF = 1 << 12 + 5;
int dp[15][INF];
int data[15][15];
int n,m; //行列
/*
2 3
1 1 1
0 1 0
Sample Output
9
*/
/*
i代表当前行
j代表当前列
state代表当前行(阶段)的状态
next代表下一行(阶段)的可到达状态
flag代表是上一列是否种了玉米，如果种了玉米，flag = 1,否则等于0；
*/
void dfs(int i,int j,int state,int next,int flag);
int main()
{
while(~scanf("%d%d",&n,&m))
{
for(int i = 1; i <= n; i++)
{
for(int j = 0; j < m; j++)
{
scanf("%d",&data[i][j]);
}
}
mmset(dp,0); //初始化
dp[0][0] = 1;
/*
遍历每个阶段的所有可达到状态，并搜索这种状态所能到达所有状态 。
这是状态转移的过程
*/
for(int i = 0; i < n; i++)
{
for(int state = 0; state < (1<<m); state++)
{
if(dp[i][state] > 0)
{
dfs(i,0,state,0,0);
}
}
}
int ans = 0;
/*
求解，对最后一行所有可达到的状态的方法数加和，并存在变量ans中;
*/
for(int state = 0; state < (1<<m); state++)
{
if(dp[n][state] > 0)
{
ans=(ans+dp[n][state])%100000000;
}
}
printf("%d\n",ans);
}
return 0;
}
void dfs(int i,int j,int state,int next,int flag)
{
if(j == m)
{
dp[i+1][next] = (dp[i+1][next] + dp[i][state])%100000000;
}
/*
下面这段代码有点绕，可以种玉米是指客观条件,
但种不种玉米是主观意愿。
*/
else
{
//表示可以种玉米
if(data[i+1][j] == 1 && (state & (1<<j)) == 0 && flag== 0)
{
if(flag == 0||flag == 1) //不种玉米
{
dfs(i,j+1,state,next,0);
}
if(flag == 0) //种玉米
{
dfs(i,j+1,state,next | (1<<j),1);
}
}
//不可以种玉米
else
{
dfs(i,j+1,state,next,0);
}
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
