状态压缩dp(状压dp)

2024-09-05 21:32
文章标签 dp 压缩 状态 状压

本文主要是介绍状态压缩dp(状压dp),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

注:在涉及到位运算时,一定要注意位运算的优先级。该加的括号一定要加

状压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");elseprintf("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);}}
}

 

 

 

 

这篇关于状态压缩dp(状压dp)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1140121

相关文章

hdu1043(八数码问题,广搜 + hash(实现状态压缩) )

利用康拓展开将一个排列映射成一个自然数,然后就变成了普通的广搜题。 #include<iostream>#include<algorithm>#include<string>#include<stack>#include<queue>#include<map>#include<stdio.h>#include<stdlib.h>#include<ctype.h>#inclu

hdu1565(状态压缩)

本人第一道ac的状态压缩dp,这题的数据非常水,很容易过 题意:在n*n的矩阵中选数字使得不存在任意两个数字相邻,求最大值 解题思路: 一、因为在1<<20中有很多状态是无效的,所以第一步是选择有效状态,存到cnt[]数组中 二、dp[i][j]表示到第i行的状态cnt[j]所能得到的最大值,状态转移方程dp[i][j] = max(dp[i][j],dp[i-1][k]) ,其中k满足c

hdu4826(三维DP)

这是一个百度之星的资格赛第四题 题目链接:http://acm.hdu.edu.cn/contests/contest_showproblem.php?pid=1004&cid=500 题意:从左上角的点到右上角的点,每个点只能走一遍,走的方向有三个:向上,向下,向右,求最大值。 咋一看像搜索题,先暴搜,TLE,然后剪枝,还是TLE.然后我就改方法,用DP来做,这题和普通dp相比,多个个向上

hdu1011(背包树形DP)

没有完全理解这题, m个人,攻打一个map,map的入口是1,在攻打某个结点之前要先攻打其他一个结点 dp[i][j]表示m个人攻打以第i个结点为根节点的子树得到的最优解 状态转移dp[i][ j ] = max(dp[i][j], dp[i][k]+dp[t][j-k]),其中t是i结点的子节点 代码如下: #include<iostream>#include<algorithm

hdu4865(概率DP)

题意:已知前一天和今天的天气概率,某天的天气概率和叶子的潮湿程度的概率,n天叶子的湿度,求n天最有可能的天气情况。 思路:概率DP,dp[i][j]表示第i天天气为j的概率,状态转移如下:dp[i][j] = max(dp[i][j, dp[i-1][k]*table2[k][j]*table1[j][col] )  代码如下: #include <stdio.h>#include

usaco 1.1 Broken Necklace(DP)

直接上代码 接触的第一道dp ps.大概的思路就是 先从左往右用一个数组在每个点记下蓝或黑的个数 再从右到左算一遍 最后取出最大的即可 核心语句在于: 如果 str[i] = 'r'  ,   rl[i]=rl[i-1]+1, bl[i]=0 如果 str[i] = 'b' ,  bl[i]=bl[i-1]+1, rl[i]=0 如果 str[i] = 'w',  bl[i]=b

uva 10154 DP 叠乌龟

题意: 给你几只乌龟,每只乌龟有自身的重量和力量。 每只乌龟的力量可以承受自身体重和在其上的几只乌龟的体重和内。 问最多能叠放几只乌龟。 解析: 先将乌龟按力量从小到大排列。 然后dp的时候从前往后叠,状态转移方程: dp[i][j] = dp[i - 1][j];if (dp[i - 1][j - 1] != inf && dp[i - 1][j - 1] <= t[i]

uva 10118 dP

题意: 给4列篮子,每次从某一列开始无放回拿蜡烛放入篮子里,并且篮子最多只能放5支蜡烛,数字代表蜡烛的颜色。 当拿出当前颜色的蜡烛在篮子里存在时,猪脚可以把蜡烛带回家。 问最多拿多少只蜡烛。 代码: #include <iostream>#include <cstdio>#include <cstdlib>#include <algorithm>#include <cs

uva 10069 DP + 大数加法

代码: #include <iostream>#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <cmath>#include <stack>#include <vector>#include <queue>#include <map>#include <cl

uva 10029 HASH + DP

题意: 给一个字典,里面有好多单词。单词可以由增加、删除、变换,变成另一个单词,问能变换的最长单词长度。 解析: HASH+dp 代码: #include <iostream>#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <cmath>#inc