【7】状态压缩DP学习笔记

前言

状态压缩 DP 是一类常用的 DP 方式，思维难度不是很大，但需要一点卡常和实现技巧。比较容易掌握，是一个骗分的好东西。

状态压缩DP

状态压缩 DP 通常用来处理 DP 过程中与具体状态相关的问题。这种情况下，我们通过二进制压缩使状态可以成为 DP 的一个维度，从而进行动态规划。

因此，状态压缩 DP 的时间复杂度大体为 \(O(2^n)\)。故状态压缩 DP 数据范围一般不大，\(n\le25\) 左右。

一些具体的压缩方式，可以参见例题。

位运算基础知识

例题

例题 \(1\) ：

P1879 [USACO06NOV] Corn Fields G

由于数据范围很小，考虑状态压缩 DP。不难发现，在当前这一行某一个位置是否可以种草，取决于这块地是否适合种草以及上一行这个位置是否种草。而当前这一行某一个位置是否可以种草可以直接得出，而上一行这个位置是否种草是转移时需要的信息。因此，我们把上一行每个位置是否种草压缩成状态，成为 DP 数组的维度。

具体的，设状态 \(f[x][y]\) 表示当前处于第 \(x\) 行，上一行状态为 \(y\) 的方案数。若 \(y\) 的第 \(i\) 位为 \(0\)，则上一行第 \(i\) 个位置没有种草；若 \(y\) 的第 \(i\) 位为 \(1\)，则上一行第 \(i\) 个位置种了草。

考虑枚举这一行的状态 \(z\)，\(z\) 的定义与 \(y\) 相同。首先，判定 \(z\) 中所有 \(1\) 的位置是否能种草以及是否有 \(1\) 相邻。然后，判定 \(z\) 中所有 \(1\) 的位置是否在 \(y\) 中也为 \(1\)。如果都为 \(1\)，根据状态定义，我们发现出现了有公共边的两块草地，不满足题意。

最后，对于每一个合法状态 \(z\)，显然有如下转移方程：

\[f[x+1][z]=f[x+1][z]+f[x][y]
\]

最后的答案为 \(\sum_{i=0}^{2^n-1}f[m+1][i]\)，时间复杂度为 \(O(m2^n)\)。代码中使用了记忆化搜索的实现方法。

#include <bits/stdc++.h>
using namespace std;
int m,n,map1[20][20],f[20][5000],mod=100000000;
int dfs(int now,int pre)
{
    int ans=0;
    if(f[now][pre])return f[now][pre];
	if(now==m+1)
	   {
	   	ans=(ans+1)%mod;
	   	return ans;
	   }
	int t=(1<<n);
	for(int i=0;i<t;i++)
	    {
	    int flag=1;
	    for(int j=0;j<n;j++)
		    if(((i>>j)&1)&&((pre>>j)&1||(i>>(j-1)&1)||(i>>(j+1)&1)||(!map1[now][j+1])))flag=0;
		if(flag)ans=(ans+dfs(now+1,i))%mod;
	    }
	f[now][pre]=ans;
	return ans;
}

int main()
{
	scanf("%d%d",&m,&n);
	for(int i=1;i<=m;i++)
	   for(int j=1;j<=n;j++)
	      scanf("%d",&map1[i][j]);
	printf("%d\n",dfs(1,0));
	return 0;
}

例题 \(2\) ：

P2704 [NOI2001] 炮兵阵地

与上一道题目类似，但是需要状态压缩上两行的数据。判断转移也与上面基本一样，但需要判定两行。设状态 \(f[x][y][z]\) 表示目前是第 \(x\) 行，上一行状态为 \(y\)，上两行状态为 \(z\)，若可以由状态 \(f[x-1][z][w]\)，则有转移方程：(令 \(p[x]\) 为状态 \(x\) 的二进制位为 \(1\) 的位置数量)

\[f[x][y][z]=\max(f[x][y][z],f[x-1][z][w]+p[y])
\]

使用滚动数组优化空间即可通过。

#include <bits/stdc++.h>
using namespace std;
int m,n,f[2][3000][3000],p[3000],c[200],ans=0,now=0;
char map1[200][200];
int lowbit(int x)
{
	return x&(-x);
}

int popcnt(int x)
{
	int ans=0;
	while(x>0)ans++,x-=lowbit(x);
	return ans;
}

int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
	   {
	   scanf("%s",map1[i]);
	   for(int j=0;j<m;j++)
	       if(map1[i][j]=='P')c[i]+=(1<<j);
       }
    for(int i=1;i<=(1<<m)-1;i++)p[i]=popcnt(i);
	for(int i=0;i<=(1<<m)-1;i++)
	    for(int j=0;j<=(1<<m)-1;j++)
	        f[now][i][j]=-1e5;
	f[now][0][0]=0;
	for(int i=0;i<n;i++)
	    {
	    for(int j=0;j<=(1<<m)-1;j++)
	        for(int k=0;k<=(1<<m)-1;k++)
		        f[now^1][j][k]=-1e5;
	    for(int j=0;j<=(1<<m)-1;j++)
	        for(int k=0;k<=(1<<m)-1;k++)
	            {
	            if((j&(j<<1))||(j&(j<<2))||(k&(k<<1))||(k&(k<<2))||((c[i]&j)!=j))continue;
	            for(int l=0;l<=(1<<m)-1;l++)
	                {
	                	if((l&(l<<1))||(l&(l<<2))||(j&l)||(k&l)||((c[i+1]&l)!=l))continue;
	                	f[now^1][l][j]=max(f[now^1][l][j],f[now][j][k]+p[l]);
					}
				}
	    now^=1;
	    }
	for(int i=0;i<=(1<<m)-1;i++)
	    for(int j=0;j<=(1<<m)-1;j++)
	        ans=max(ans,f[now][i][j]);
	printf("%d\n",ans);
	return 0;
}

例题 \(3\) ：

P3959 [NOIP2017 提高组] 宝藏

不难发现最后的路径一定会构成一棵树。由于每条路的贡献与与其深度有关，故考虑设计与深度有关的状态。由于数据范围很小，考虑状态压缩 DP，每次扩展一层。

设状态 \(f[i][j]\) 表示目前扩展到第 \(i\) 层，所有节点的状态为 \(j\)。若第 \(k\) 位为 \(1\)，则表示节点 \(k\) 已经被打通；若第 \(k\) 位为 \(0\)，则表示节点 \(k\) 未被打通。记状态 \(k\) 转移到状态 \(j\) 经过的边权之和为 \(cost(k,j)\)，不难得到如下转移方程：

\[f[i][j]=\min(f[i][j],f[i-1][k]+cost(k,j)\times(i-1))
\]

接下来，考虑预处理出两个数组 \(cost(k,j)\) 与 \(pos(k,j)\)，表示状态 \(k\) 转移到状态 \(j\) 经过的边权之和为 \(cost(k,j)\) 与可行性。再预处理一个数组 \(ex(i)\)，表示状态 \(i\) 可以扩展的所有点(包括原有点)的状态集合。若第 \(k\) 位为 \(1\)，则表示节点 \(k\) 可以被扩展；若第 \(k\) 位为 \(0\)，则表示节点 \(k\) 不可以被扩展。

\(ex(i)\) 并不难预处理，只需要枚举已有节点的每一条边，能扩展到的标记为 \(1\) 即可。有了 \(ex(i)\) 后，我们发现 \(pos(k,j)\) 也不难预处理。当且仅当 \(k\) 是 \(j\) 的子集且 \(j\) 是 \(ex(k)\) 的子集时，\(pos(k,j)=1\)。判断子集可以用位运算来实现，若 \(j\&k=k\)，则 \(k\) 是 \(j\) 的子集。

接下来，考虑求出满足 \(pos(k,j)\) 的 \(cost(k,j)\)。考虑枚举状态 \(j\) 中未扩展的点，枚举从 \(k\) 中的点到这一个点的边，取边权最小值为贡献。最后，将每一个未扩展的点的贡献加和，即为 \(cost(k,j)\)。预处理之后，转移也比较显然。

时间复杂度为 \(O(m2^{n}+n3^n)\)，其中 \(3^n\) 是枚举子集的时间复杂度。

#include <bits/stdc++.h>
using namespace std;
int n,m,u,v,d,h[30000],ex[5000],cst[5000][5000],f[20][5000],ans=1e9;
vector<int>to[20],dis[20];
bool pos[5000][5000];
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++)
	    {
	    	scanf("%d%d%d",&u,&v,&d);
	    	to[u].push_back(v),dis[u].push_back(d);
	    	to[v].push_back(u),dis[v].push_back(d);
		}
	for(int i=0;i<=(1<<n)-1;i++)
	    {
	    	ex[i]=i;
	    	for(int j=0;j<n;j++)
	    	    if(i&(1<<j))
	    	       {
	    	       int s=to[j+1].size();
	    	       for(int k=0;k<s;k++)ex[i]|=(1<<(to[j+1][k]-1));
	    	       }
		}
	for(int i=0;i<=(1<<n)-1;i++)
	    for(int j=0;j<=(1<<n)-1;j++)
	        if((j|ex[i])==ex[i]&&(i|j)==j&&i!=j)
	           {
	           	pos[i][j]=1;
	           	for(int k=0;k<n;k++)
	           	    if(!(i&(1<<k))&&(j&(1<<k)))
		           	    {
		    	        int mi=1e9,s=to[k+1].size();
		    	        for(int l=0;l<s;l++)
						    if((i&(1<<(to[k+1][l]-1))))mi=min(mi,dis[k+1][l]);
						cst[i][j]+=mi;
						}
			   }
	for(int i=0;i<=n;i++)
	    for(int j=0;j<=(1<<n)-1;j++)
	        f[i][j]=1e9;
	for(int i=1;i<=n;i++)
	    f[0][(1<<(i-1))]=0;
	for(int i=1;i<=n;i++)
	    for(int j=0;j<=(1<<n)-1;j++)
	        for(int k=0;k<=(1<<n)-1;k++)
	            if(pos[k][j]&&f[i-1][k]!=1e9)f[i][j]=min(f[i][j],f[i-1][k]+cst[k][j]*i);
	for(int i=0;i<=n;i++)ans=min(ans,f[i][(1<<n)-1]);
	printf("%d\n",ans);
	return 0;
}

后记

蒹葭苍苍，白露为霜。所谓伊人，在水一方。溯洄从之，道阻且长。溯游从之，宛在水中央。