状压DP

Vic.GoodLuck

已于 2023-09-30 10:46:49 修改

阅读量22

点赞数

分类专栏：程序设计算法——动态规划文章标签：算法图论动态规划

于 2022-12-31 23:28:34 首次发布

本文链接：https://blog.csdn.net/weixin_50533561/article/details/128509533

版权

程序设计算法——动态规划专栏收录该内容

12 篇文章 0 订阅

订阅专栏

蒙德里安的梦想

求把 N×M 的棋盘分割成若干个 1×2 的长方形，有多少种方案

按列从左往右放

f[i][j]表示已经摆好前i-1列，且第i列伸出来的状态为j的方案数

f[i][j]由f[i-1][k]转移而来，k代表的是摆好前i-2列时第i-1列伸出来的状态

①需要满足 j&k == 0 第i列凸出来的都是从第i-1列伸出来的，所以需要满足和上一列不冲突

②需要满足 j|k 中连续空着的位置长度为偶数最后竖着的空位需要2*1的方块补齐

const int N=12,M=1<<N;
int n,m;
long long f[N][M];
bool vis[M];
void judge()
{
	for(int i=0;i<1<<n;i++)
	{
		vis[i]=true;
		int cnt=0;//连续0的个数 
		for(int j=0;j<n;j++)
			if(i>>j&1)
			{
				if(cnt&1)//当前段连续零有奇数个，不合法 
					vis[i]=false;
				cnt=0;
			}
			else cnt++;
		if(cnt&1) vis[i]=false;//最后一段 
	}
}
long long dp()
{
	memset(f,0,sizeof f);
	f[0][0]=1;
	for(int i=1;i<=m;i++)
		for(int j=0;j<1<<n;j++)
			for(int k=0;k<1<<n;k++)
				if((j&k)==0&&vis[j|k])
					f[i][j]+=f[i-1][k];
	return f[m][0];
}

最短Hamilton路径

f[i][j] 表示从0走到j，经过路径状态为i

枚举所有的路径状态，对于路径中的每个点，枚举路径中的其他点作为到达该点的前继点的情况，更新最小值

int dp()
{
	memset(f,0x3f,sizeof f);
	f[1][0]=0;
	for(int i=0;i<1<<n;i++)//枚举所有的路径状态
		for(int j=0;j<n;j++)
			if((i>>j)&1)//路径中包含j点
				for(int k=0;k<n;k++)//枚举路径上除j点外的其他点，作为到达j点的前一点
					if((i-(1<<j))>>k&1)//该点在路径上，更新最小值
						f[i][j]=min(f[i][j],f[i-(1<<j)][k]+a[k][j]);
	return f[(1<<n)-1][n-1];
}

小国王

1064. 小国王

题意：n*n的棋盘放k个国王，国王可以攻击周围八个位置，求摆放方案数

思路： $f[i][j][k]$ 表示前i行，放置了j个国王，且第i行放置的状态为k 的方案数

①首先考虑一行内的摆放状态，国王不能相邻摆放，即不能有相邻的1，先将合法的行内状态集合预处理出来

②然后考虑上下两行的摆放，假设状态为a,b，上下两行需要满足下图条件，即a&b==0且a|b没有相邻的1，预处理出每个状态可以相邻的合法状态集合

③开始DP：依次枚举第i行、放置了j个、第i行的状态，对于第i行的状态，枚举其对应的合法状态进行转移

#include<bits/stdc++.h>
using namespace std;
typedef long long ll; 
typedef pair<int,int> PII;
const int N=15,M=(1<<10)+5;
int n,k;
ll f[N][N*N][M];
//f[i][j][k] 前i层 放了j个 第i层状态是k
vector<int> st;//可以在同一行的状态
int cnt[M];//一行的状态对应的棋子个数 
vector<int> h[M];//一个状态对应可以在下一行放置的合法状态集合 
//判断是否为合法的行内状态（一行内不相互攻击） 
bool check(int x){
	//一行内的国王不能相邻放 
	for(int i=0;i<n;i++){
		if(x>>i&1&&x>>(i+1)&1){
			return false;
		}
	}
	return true;
}
//该行国王的个数 
int count(int x){
	int cnt=0;
	for(int i=0;i<n;i++){
		if(x>>i&1) cnt++;
	}
	return cnt;
} 
ll dp(){
	for(int i=0;i<1<<n;i++){
		if(check(i)){
			st.push_back(i);
			cnt[i]=count(i);
		}
	}
	for(int i=0;i<st.size();i++){
		for(int j=0;j<st.size();j++){
			int a=st[i],b=st[j];
			//上下两行需要满足不能相互攻击 
			if((a&b)==0&&check(a|b)){
				h[i].push_back(j);
			}
		}
	} 
	f[0][0][0]=1;
	for(int i=1;i<=n;i++){
		for(int j=0;j<=k;j++){
			for(int z=0;z<st.size();z++){
				int s=st[z];//第i行状态 
				int ct=cnt[s];
				if(j<ct) continue;
				//可以在第i-1行的 
				for(int u=0;u<h[z].size();u++){
					int ss=st[h[z][u]];//第i-1行状态 
					f[i][j][s]+=f[i-1][j-ct][ss]; 
				}
			}
		}
	}
	ll res=0;
	for(int i=0;i<st.size();i++){
		int s=st[i];
		res+=f[n][k][s];
	}
	return res;
} 
int main(){
	cin>>n>>k;
	cout<<dp()<<endl;
}

玉米田

327. 玉米田 - AcWing题库

题意：n*m的土地，每行有不能种植的土地，种植的土地没有公共边缘，求种植方案数

思路： $f[i][j]$ 表示前i层第i层种植状态是j 的方案数

①首先考虑一行内的种植状态，不能相邻种植，即不能有相邻的1，先将合法的行内状态集合预处理出来

②然后考虑上下两行的摆放，假设状态为a,b，上下两行需要满足下图条件，即a&b==0，预处理出每个状态可以相邻的合法状态集合

③开始DP：依次枚举第i行、第i行的状态，对于第i行的状态，首先判断有没有不能种植的土地，然后再枚举其对应的合法状态进行转移

ll f[N][M];
int g[N];//每行不能种植的土地 
//f[i][j] 前i层 第i层状态是j
vector<int> st;//可以在同一行的状态
vector<int> h[M];//一个状态对应可以在下一行放置的合法状态集合 
//判断是否为合法的行内状态
bool check(int x){
	for(int i=0;i<m-1;i++){
		if(x>>i&1&&x>>(i+1)&1){
			return false;
		}
	}
	return true;
}
ll dp(){
	//记录每行不育的土地 
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(!w[i][j]){
				g[i]+=1<<(j-1);
			}
		}
	}
	//处理行内合法状态 
	for(int i=0;i<1<<m;i++){
		if(check(i)){
			st.push_back(i);
		}
	}
	//处理行间合法状态 
	for(int i=0;i<st.size();i++){
		for(int j=0;j<st.size();j++){
			int a=st[i],b=st[j];
			if((a&b)==0){
				h[i].push_back(j);
			}
		}
	} 
	f[0][0]=1;
	for(int i=1;i<=n;i++){
		for(int j=0;j<st.size();j++){
			int s=st[j];//第i行状态
			//判断该状态能不能放到第i行（有没有不育的土地） 
			if(s&g[i]) continue;
			//可以在第i-1行的 
			for(int k=0;k<h[j].size();k++){
				int ss=st[h[j][k]];//第i-1行状态 
				f[i][s]=(f[i][s]+f[i-1][ss])%mod;
			}
		}
	}
	ll res=0;
	for(int i=0;i<st.size();i++){
		int s=st[i];
		res=(res+f[n][s])%mod;
	}
	return res;
}

炮兵阵地

292. 炮兵阵地 - AcWing题库

题意：n*m的地图上布置炮兵，某些位置不能摆放，炮兵的攻击范围是上下左右各2格，求不相互攻击的最大摆放数量

思路： $f[i][j][k]$ 表示前i层第i层状态是j 第i-1层状态k 的最大摆放数量

①首先考虑一行内的摆放状态，如下图，每个炮兵的左右2格内不能再摆放，先将合法的行内状态集合预处理出来

②然后考虑上下两行的摆放，假设状态为a,b，上下两行需要满足下图条件，即a&b==0，预处理出每个状态可以相邻的合法状态集合

③开始DP：

先枚举第i行状态，判断第i行是否有不能摆放的位置

再枚举第i行对应的相邻合法状态作为第i-1行的状态，判断第i-1行是否有不能摆放的位置

最后枚举第i-1行对应的相邻合法状态作为第i-2行的状态，判断第i-2行是否有不能摆放的位置。

另外，由于枚举时保证了第i行和第i-1行之间不会冲突，但是没有保证第i行和第i-2行不会冲突，所以对第i行和第i-2行的状态进行判断。最后进行状态转移即可

ll f[2][1<<M][1<<M];
//f[i][j][k] 前i层 第i层状态是j 第i-1层状态k 
int g[N];
vector<int> st;//可以在同一行的状态
int cnt[1<<M];
vector<int> h[1<<M];//一个状态对应可以在下一行放置的合法状态集合 
//判断是否为合法的行内状态
bool check(int x){
	for(int i=0;i<m;i++){
		if(x>>i&1){
			if(x>>(i+1)&1||x>>(i+2)&1) return false;
		}
	}
	return true;
}
int count(int x){
	int cnt=0;
	for(int i=0;i<m;i++){
		if(x>>i&1) cnt++;
	}
	return cnt;
}
ll dp(){
	//记录每行不能放置的 
	for(int i=1;i<=n;i++){
		for(int j=0;j<m;j++){
			if(w[i][j]=='H'){
				g[i]+=1<<j;
			}
		}
	}
	//处理行内合法状态 
	for(int i=0;i<1<<m;i++){
		if(check(i)){
			st.push_back(i);
			cnt[i]=count(i);
		}
	}
	//处理行间合法状态
	for(int i=0;i<st.size();i++){
		for(int j=0;j<st.size();j++){
			int a=st[i],b=st[j];
			if((a&b)==0){
				h[a].push_back(b);
			}
		} 
	} 
	for(int i=1;i<=n;i++){
		for(int j=0;j<st.size();j++){//第i行状态 
			int a=st[j];
			if((a&g[i])!=0) continue;
			for(int k=0;k<h[a].size();k++){//第i-1行状态 
				int b=h[a][k];
				if(i>1&&((b&g[i-1])!=0)) continue;
				for(int u=0;u<h[b].size();u++){//第i-2行状态 
					int c=h[b][u];
					if(i>2&&((c&g[i-2])!=0)) continue;
					if((a&c)!=0) continue;
					f[i&1][a][b]=max(f[i&1][a][b],f[(i-1)&1][b][c]+cnt[a]);
				}
			}
		}
	}
	ll res=0;
	for(int i=0;i<st.size();i++){
		int a=st[i];
		for(int j=0;j<h[a].size();j++){
			int b=h[a][j];
			res=max(res,f[n&1][a][b]);
		}
	}
	return res;
}

愤怒的小鸟

524. 愤怒的小鸟 - AcWing题库

宝藏

529. 宝藏 - AcWing题库

积木画

4406. 积木画 - AcWing题库

f[i][j]表示前i-1行摆满，第i行状态为j

j=0表示上面一块，j=1表示下面一块，j=2表示空，j=3表示满

#include<bits/stdc++.h>
using namespace std;
typedef long long ll; 
const int N=1e7+5,mod=1e9+7;
ll f[2][5]; 
int main(){
	int n;cin>>n;
	f[1][2]=1;
	for(int i=2;i<=n+1;i++){
		for(int j=0;j<4;j++){
			f[i&1][j]=0;
			if(j==0){
				f[i&1][j]=(f[i&1][j]+f[(i-1)&1][1])%mod;
				f[i&1][j]=(f[i&1][j]+f[(i-1)&1][2])%mod;
			}else if(j==1){
				f[i&1][j]=(f[i&1][j]+f[(i-1)&1][0])%mod;
				f[i&1][j]=(f[i&1][j]+f[(i-1)&1][2])%mod;
			}else if(j==2){
				f[i&1][j]=(f[i&1][j]+f[(i-1)&1][2])%mod;
				f[i&1][j]=(f[i&1][j]+f[(i-1)&1][3])%mod;
			}else{
				f[i&1][j]=(f[i&1][j]+f[(i-1)&1][0])%mod;
				f[i&1][j]=(f[i&1][j]+f[(i-1)&1][1])%mod;
				f[i&1][j]=(f[i&1][j]+f[(i-1)&1][2])%mod;
			}
		}
	}
	cout<<f[(n+1)&1][2];
}