状压dp。

已于 2022-11-14 21:07:55 修改
阅读量248 收藏
点赞数
文章标签： 算法 c++ 图论
于 2022-11-11 10:53:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cn_tigerhan/article/details/127794470
版权

想学的推荐别看我博客。
呃不得不学的，dp专题确实难搞QWQ。做完第一题再来总结一下吧。
P1896 [SCOI2005] 互不侵犯呃啊这一题！其实之前看过的，主要是这个状态压缩呀它要预处理。然后你要处理出所有的情况，就是行的情况你要处理出来才能枚举呀。

#include<bits/stdc++.h>
#define int long long 
using namespace std;
int n,m,k,f[11][200][200],cnt=0,num[10001],sum[10001],ans=0;
//f[i][j][k]的状态表示在第i行j的状况下已经放了k个国王 (i一共放了k个)
int getsum(int S)
{
	int tot=0;
	while(S) tot+=(S&1),S>>=1;
	return tot; 
}
void init()
{
	cnt=0;
	for(int i=0;i<(1<<n);i++)
	{
		if(i&(i<<1)) continue ;//如果相邻的两个都放了就g 
		num[++cnt]=i;sum[cnt]=getsum(i);//s是放的位置（每个国王），num是放的数量 //若是这个位置放下国王，统计一下 
	}
	return ;
}
void dp()
{
	f[0][1][0]=1;//在第0行的一号状态放0个有一种情况。
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=cnt;j++)
		{
			for(int l=0;l<=k;l++)//枚举之前摆了的国王 (!!!我也摆！！！)
			{
				if(l<sum[j]) continue ;
				for(int t=1;t<=cnt;t++)	
				{
					if((num[t] & num[j])||(num[t] & (num[j]<<1))||(num[t] & (num[j]>>1))) continue ;
					//看看是否与之前有冲突 
					f[i][j][l]+=f[i-1][t][l-sum[j]];//转移向前 
				}
			}
		}	
	}
	return ; 
}
signed main()
{
	scanf("%lld%lld",&n,&k);
	init();dp();ans=0;
	for(int i=1;i<=cnt;i++) ans+=f[n][i][k];//printf("%lld %lld %lld\n",i,k,ans);//printf("%lld ",ans);
	printf("%lld",ans); 
	return 0;
}

P2704 [NOI2001] 炮兵阵地这题的转移状态会多很多，首先，我们压去前两行（欸这是一个小知识点），呃其他就可以直接转啦，问题在于细节很多，第一：

int getsum(int S)
{
	int tot=0;
	while(S) tot+=(S&1),S>>=1;
	return tot;
}

	for(int i=0;i<=mm;i++) 
	{
		if((i&(i<<1))||(i&(i<<2))) continue ;
		num[++cnt]=i,sum[cnt]=getsum(i);
		if(a[1]&num[cnt]) ans=max(ans,sum[cnt]);
	}

这个就会是我们以后将沿用的板子，压缩了空间以及计算好了完美情况。
第二：注意你要计算第一第二行的情况，就因为这个搞了半天。
第三：你tm是不是忘记把整一排不放的情况忘了！！！计数要从0开始啊铸币。
P1879 [USACO06NOV]Corn Fields G第三题。大概我好像是有些上手了吧，就没花多久，不过还有一个小问题就是初始化的时候搞了一会。

#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,m,a[1001],sum[10001],num[10001],cnt=0,mm,ans=0,mod=1e9;
int f[20][6000];
int getsum(int x)
{
	int tot;
	while(x) tot+=(x&1),x>>=1;
	return tot;
}
signed main()
{
	scanf("%lld%lld",&n,&m);mm=(1<<m)-1;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			int x;scanf("%lld",&x);
			if(x==0) a[i]|=(1<<(j-1));//?/a[i]|=(1<<j-1);
		}
	}
	for(int i=0;i<=mm;i++) 
	{
		if((i&(i<<1))) continue ;
		num[++cnt]=i;//sum[cnt]=getsum(i);
	}
	f[0][1]=1;//这一句调了很久，因为忘记了我num数组下标是从1开始的，表示的是上行全0的情况 
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=cnt;j++)
		{
			if(num[j]&a[i]) continue ;
			for(int k=1;k<=cnt;k++)
			{
				if((num[k]&a[i-1])||(num[k]&num[j])) continue ;
				f[i][j]=(f[i][j]+f[i-1][k])%mod;
			}
		}
	}
	for(int i=0;i<=cnt;i++) ans=(ans+f[n][i])%mod;
	printf("%lld",ans);
	return 0;
}

P2622 关灯问题II状压dp的好题，考虑如何转移，那么明显枚举状态而不是枚举方案。（可以先用一种方案再用前面用过的方案，那么枚举方案会出事），那么再考虑直接枚举按钮，然后转移就行啦

#include<bits/stdc++.h> 
using namespace std;
int n,m,a[101][101],f[10001],nn;//f[i]表示的是从最初全0状态转移到i的状态最少需要几次 
//f[nn]是全开的 
//在这一份代码中cnt是没有用的，因为其左右点没有任何的限制 
int main()
{
	memset(f,63,sizeof(f));
	scanf("%d%d",&n,&m);nn=(1<<n)-1;
	for(int i=1;i<=m;i++)
	{
		for(int j=1;j<=n;j++) scanf("%d",&a[i][j]);
	}
	f[nn]=0; 
	for(int i=nn;i>=0;i--)
	{
		for(int j=1;j<=m;j++)
		{
			int now=i;
			for(int k=1;k<=n;k++)
			{
				if(a[j][k]==0) continue ;
				if(a[j][k]==1&&(i&(1<<(k-1)))) now^=(1<<(k-1));
				if(a[j][k]==-1&&!(i&(1<<(k-1)))) now^=(1<<(k-1));
			}	
			f[now]=min(f[now],f[i]+1);
		}
	}
	if(f[0]==f[nn+1]) printf("-1");
	else printf("%d",f[0]);
	return 0;
}

P2396 yyy loves Maths VII说这题状压未免太过勉强，不过判断01的方式确实学到不少。

#include<bits/stdc++.h>
#define lowbit(x) x&(-x)
using namespace std;
int n,m,b1,b2,f[1<<24],dis[1<<24],nn,mod=1e9+7;
main()
{
	scanf("%d",&n);nn=(1<<n)-1;
	for(int i=0;i<=n-1;i++) scanf("%d",&dis[1<<i]);
	scanf("%d",&m);
	if(m==1) scanf("%d",&b1);
	if(m==2) scanf("%d%d",&b1,&b2);
	f[0]=1;
	for(int i=1;i<=nn;i++)
	{
		dis[i]=dis[i^lowbit(i)]+dis[lowbit(i)];//看看自己，是不是和b要匹配
		if(dis[i]==b1||dis[i]==b2) continue;
		for(register int j = i, k = lowbit(j); j; j ^= k, k = lowbit(j)) 
		{
            f[i] += f[i^k];
            if(f[i] > mod) f[i] -= mod;
		}
	}
	printf("%d",f[nn]);
	return 0;
}

P2473 [SCOI2008] 奖励关呃看看就懂啦，注意要从后往前算哦

#include<bits/stdc++.h>
using namespace std;
int K,n,m,num[100001],nn;
double f[101][1<<16],p[100001];
int main()
{
	scanf("%d%d",&K,&n);nn=(1<<n)-1;
	for(int i=1;i<=n;i++)
	{
		scanf("%lf",&p[i]);
		int x;while(scanf("%d",&x),x!=0) num[i]|=(1<<(x-1));
	}
	for(int i=K;i>=1;i--)
	{
		for(int j=0;j<=nn;j++)
		{
			for(int k=1;k<=n;k++)
			{
				if((j&num[k])==num[k]) f[i][j]+=max(f[i+1][j],f[i+1][j|(1<<(k-1))]+p[k]);
				else f[i][j]+=f[i+1][j];
			}
			f[i][j]/=n;
		}
	}
	printf("%lf",f[1][0]);
	return 0;
}

好啦最后一道，所有的也都是为了这一题Grouping,记录状态枚举子集，左右开弓。

//这题我们预处理出每一种组合
//然后枚举子集将自己拆成两。 
#include<bits/stdc++.h>
#define int long long 
using namespace std;
int n,m,f[1<<16],a[16][16],nn,val[1<<16];
 main()
{
	scanf("%lld",&n);nn=(1<<n)-1;//printf(" %d",nn);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++) scanf("%lld",&a[i][j]);
	}
	for(int i=1;i<=nn;i++)
	{
		for(int j=1;j<=n;j++)
		{
			for(int k=1;k<=j-1;k++) 
			{
				if(((1<<(k-1))&i)&&((1<<(j-1))&i)) val[i]+=a[j][k];
			}
		}
//		printf("%d\n",val[i]);
	}
	for(int i=1;i<=nn;i++)
	{
		f[i]=val[i];
		for(int j=i&(i-1);j>=1;j=i&(j-1)) f[i]=max(f[i],f[i^j]+f[j]);	
	}
	printf("%lld",f[nn]);
	return 0;
}

补一题难一些的？P5005 中国象棋 - 摆上马，不过是高级些罢了。倒也没表面上那么难，只不过判断稍微麻烦些，作为一道练手的题目大抵也是不错的。不过！做到一半的我发现，有蹩马腿这一操作，那么复杂些了.

#include<bits/stdc++.h>
#define int long long 
using namespace std;
int n,m,cnt=0,num[100001],sum[100001],nn,mod=1e9+7;
int f[5][70][70],ans=0;
//int getsum(int x)
//{
//	int tot=0;
//	while(x) tot+=(x&1),x>>=1;
//	return tot;
//}
 main()
{
	int Y;scanf("%lld%lld",&n,&Y);nn=(1<<Y)-1;
	if(n==1) 
	{
		printf("%lld",(1<<Y));
		return 0;
	}
//	for(int i=0;i<=nn;i++) num[cnt]=i;//sum[cnt]=getsum(i);
	int tmp=0;
	for(int i=2;i<=n;i++)
	{
		tmp^=1;
		for(int j=0;j<=nn;j++)
		{
			for(int k=0;k<=nn;k++)
			{
				f[tmp][j][k]=0;
				if(!(((j&(~(j>>1)))&(k>>2))||((j&(~(j<<1)))&(k<<2))||(((k&(~(k>>1)))&(j>>2)))||((k&(~(k<<1)))&(j<<2))))
				{
					if(i==2) f[tmp][j][k]=1;
					else 
					{
						for(int l=0;l<=nn;l++)
						{
							if(!(((j&(~k))&(l>>1))||((j&(~k))&(l<<1))||((l&(~k))&(j>>1))||((l&(~k))&(j<<1))))
							{
								f[tmp][j][k]=(f[tmp][j][k]+f[tmp^1][k][l])%mod;
							}
						}	
					}
					if(i==n) ans=(ans+f[tmp][j][k])%mod;
				}
			}
		}
	}	
	printf("%lld",ans);
	return 0;
}

呃有道km的题但是可以直接爆搜：P1559 运动员最佳匹配问题…不行听说爆搜被卡了但是！我们还可以尝试状压dp。

#include<bits/stdc++.h>
//#define int long long 
#define lowbit(x) x&(-x)
using namespace std;
int n,m,f[3][1<<20+1],p[202][202],q[202][202],num[1<<20+1];
int getsum(int x)
{
	int tot=0;
	while(x) tot+=(x&1),x>>=1;
	return tot;
}
int main()
{
	scanf("%d",&n);int nn=(1<<n)-1;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++) scanf("%d",&p[i][j]);
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++) scanf("%d",&q[i][j]);
	}
	for(int i=1;i<n;i++) num[1<<i]=i;
	memset(f,0,sizeof(f));int tmp=0;
	for(int i=1;i<=n;i++)
	{
		tmp^=1;
		for(int j=0;j<=nn;j++)
		{
			if(getsum(j)!=i) continue ;
			int k=j;
			while(k) 
			{
				int tt=lowbit(k);	
				f[tmp][j]=max(f[tmp][j],f[tmp^1][j-tt]+p[i][num[tt]+1]*q[num[tt]+1][i]);
				k-=tt;
			}
//			printf("%d %d = %d\n",i,j,f[tmp][j]);
		}
	}
	printf("%d",f[tmp][nn]);
	return 0;
}
cn_tigerhan
关注
状压DP
砥安的博客
10-30 395
状压DP 其实状压DP网上讲解一抓一大把。个个都比我的详细易懂。所以我就不介绍这些东西了。我主要讲一些小技巧，以及自己对状压的理解。 理解 状压还是dp，所以关键就是找出状态转移方程。通常都是这个式子： f[yet][state ∣ yet]=min⁡{f[have][state]+dis[have][yet]} f[yet][state \ | \ yet]=\min\lbr...
状压dp
Oxide‘s Blog
07-20 460
以前从未尝试过写一个知识点，emmm可能是懒得一个个写了叭。 状压dp就是将储存很耗空间的东西转成2进制（用1与0表示状态），再转成10进制储存。（其实感觉也对bfs挺适用的） 来几道题便于理解： 【T1】国王 #include<cstdio> int n, k, len, tmp; long long sum, sta[1028], king[1028], dp[12][1028][...
【规划】状压dp
zsjzliziyang的博客
08-09 550
1.简介 将较小的状态压缩成一个数，储存在dp的一维里，方便转移。 状压dp有很多不同的形态。 其中一种叫轮廓线dp（又称插头dp）
状压DP——子集DP
AliceK1008的博客
06-20 684
我们直接通过一个例题来了解子集 DP，子集 DP 属于状压 DP 的一种。给定一个长度不超过 n 的字符串 s，如果 s 中的一个子序列是回文，那么我们就可以从 s 中移除这个子序列，求最少经过多少步我们可以移除整个字符串 s。如：我们可以从"dqewfretd"中移除 “defed”，剩下的字符串即：“qwrt”。使用状压DP进行求解： 对于状态i，用dp[i]dp[i]dp[i]表示最少的操作次数 当状态i 对应的子序列是回文时，dp[i]=1 对于状态i的一个子状态t，如果t也是回文序列，那么 dp[
子集状压DP
lyh20021209的博客
12-30 1917
本来应该放到DP篇。但由于这个部分灵神单列了题单，我就按题单刷题记录单列一篇。位运算状压应该算是我入门第一个接触到的算法级别的trick。知识图谱也列出来了：因此本篇会略过位运算，仅将其作为工具。主要还是子集DP。
最短路径（状压dp）（ybtoj）
BUG_Creater_jie的博客
06-24 309
解析 “bug总有de完的一天” 头疼 暴力写的话本题显然复杂度是假的 有一个很好的思路优化时间复杂度 先用dp[k][i]表示**从第k个关键点到任意i点的最短路 跑k遍 SPFA或迪杰斯特拉 即可 然后转移时可以只考虑关键点 使状态转移数大大降低 细节 头真疼 边界条件： if((st^1<<(id[pl]-1))==0){ return f[id[s]][pl]; } 从这里也可以看出也需要预处理一下s的最短路 那就加在后面也求一下即可 bug ！！！ 1.有向图！！！（惯性.
5.5状压dp
jyy0806的博客
02-15 822
状压dp
状压DP/TSP问题
qq_23096319的博客
05-02 996
Boboniu and Bit Operations CodeForces 1395C 题目链接：https://codeforces.com/problemset/problem/1395/C 题目大意 给定两个序列a，b，对于ai在序列b中任选一个作为mask，ans |= (ai & mask). 思路 首先注意序列大小范围<2^9，由于位运算性质最终答案<2^9. 定义状态： f[i][j]:前i个数存在状态j(bool) f[i][j]: 前i个数存在状态j(bool) f[i
状压dp基础习题
Daniel__d的博客
07-21 343
状压dp基础习题 常见位运算操作 例题 T1 HDU1565（基础状压dp） 题解 非常基础的一道状压dp 我们用二进制来表示每一行取数情况，111表示取，000表示不取 很容易得到状态转移方程: f[i][j]=max(f[i][j],f[i−1][k]+ans[i][j]);f[i][j]=max(f[i][j],f[i-1][k]+ans[i][j]);f[i][j]=max(f[i][j],f[i−1][k]+ans[i][j]);当且仅当jjj&k==0k==0k==0时 代码 #inc
DP模型——状压DP
INGg__的博客
08-06 1230
文章目录前言什么是状态压缩DP基本例题1前期思考状态表示状态计算Code基本例题2前期思考状态表示状态计算Code扩展棋盘式小国王思考状态表示状态计算Code玉米田前期思考状态表示状态计算Code炮兵阵地思考状态表示状态计算Code 前言 第200篇blog！好耶！ 在之前发过一个状压DP的初步blog，现在回看发现上面写的好像不是那么的好，现在在这篇把状压再写出来。当然，是按照模型的关系循序渐进的 什么是状态压缩DP 我的理解就是用K进制来表示所要解决问题的状态的K种状态 基本例题1 蒙德里安的梦想
状压DP_C++_算法_状压_状态压缩DP_状压DP_
09-30
**状压DP（动态规划状态压缩）是一种在解决动态规划问题时优化空间复杂度的方法，尤其适用于当状态之间有大量重叠或者状态数量极其庞大时。C++是实现这一算法的常用编程语言，其强大的模板机制和高效性能使得在处理...
【c++提高1】优化DP专题：状压DP & 倍增优化DP & 环形DP的单调队列优化DP
小学生蒟蒻
07-11 794
这是c++提高的第一讲动态规划是解决“多阶段决策最优化问题”的一种算法思想。阶段的划分决定了状态的定义，状态定义的一个重要特性就是要确保**“无后效性”。** 很多DP问题在定义状态的时候，为了确保无后效性，需要在状态中加入多个维度，如果每个维度都用一维数组来表示的话，当维度较多时会导致占用的空间太大。 很多时候状态的维度虽然很多，但是决策非常少，特别的很多时候只有两种决策。例如背包问题中每个物品只有0和1两种决策。对于这种情况，没有必要为每个维度都分配一维空间，而是用一个二进制数来存储所有维度，每个二进制
【状压DP】易懂讲解状态压缩/状态压缩DP
qq_35684989的博客
05-31 3222
本文是状态压缩DP的总结
【状压DP】状态压缩动态规划入门超详解
繁凡さん的博客
03-15 9909
状压DP一、概述1.状态压缩2.使用条件3.状压DP二、位运算三、例题引入入门例题【例1】填满棋盘入门例题【例二】玉米地 感觉好多讲状压DP的博客都有点乱，我就结合各路大佬的博客，加上我自己的理解，总结出一篇博客来，供初学者参考 一、概述 1.状态压缩 状态压缩就是使用某种方法，简明扼要地以最小代价来表示某种状态，通常是用一串01数字（二进制数）来表示各个点的状态。这就要求使用状态压缩的对象的点的...
二叉树最小深度
2301_80161204的博客
09-27 472
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1284
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
最新发布
m0_57859086的博客
10-01 1014
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
算法：按既定顺序创建目标数组
AWSDN的博客
09-29 221
本文主要介绍按既定顺序创建目标数组问题
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1286
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
状压DP一般分为哪几类
06-11
状压DP一般可以分为以下几类： 1. 状态压缩表示状态：将一个状态压缩成一个整数，用二进制表示状态中的每个元素，将其转化为一个整数，方便状态转移和空间压缩。 2. 状态压缩表示集合：将一个集合压缩成一个整数，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值