习题：寿司晚宴（状压DP）

题目

传送门

思路

比较恶心的一道状压

如果你一开始就看最大范围，

你的心中可能一点想法都没有

但是如果你从最小的数据开始看

也就是\(n\le 30\)

如果你对质数足够熟悉的话

那么你会发现30以内的质数是10

还有一点，题目中对不和谐度的描述最关键的一点是互质

这说明了什么？

30分的思路时间复杂度极可能为\(O(n*2^n*2^n)\)

也就是状压，\(2^n\)的意义就为在二进制下，第i个质数是否出现

之后我们就可以很简单的统计出来。

很显然这个做法是可以推广的

我们依然是存一个二进制，之后多存一个变量来针对剩下的质数，也就是超过 \(\sqrt n\)的大质数

很显然，对于一个美味度，大质数只有一个

我们可以设\(f_{i,j}\)为小G拿的数的所有的质因数的状态为i，小W拿的数的所有的质因数状态为j

但是我们发现这个状态并没有考虑大质数的情况

我们再设\(dp_{n,i,j,t}\)表示第n个大质数属于i状态还是j状态，t为1就是属于i集合，反之则为j集合

比较好想的是\(n\)的那一位可以直接滚掉

我们先将所有美味度分解，

再按大质数的大小从小到大排序

之后就是状压的标准操作

枚举两个集合

如果两个集合没有相交，也就是&之后为0

你就把当前的美味度塞进去即可

转移方程即为

\(dp_{j|sus[i].sta,k,1}+=dp_{j,k,1}\)

当然，同理，当前这个美味度也可以塞到k集合，

\(dp_{j,k|sus[i].sta,0}+=dp_{j,k,0}\)

我们再想大质数怎么办

如果\(sus[i].p!=sus[i-1].p\)

就用一个类似于刷表的方式

\(dp_{i,j,0}=dp_{i,j,1}=f_{i,j}\)

如果\(sus[i].p!=sus[i+1].p\)

同上

\(f_{i,j}=dp_{i,j,1}+dp_{i,j,0}-f_{i,j}\)

代码

#include<iostream>
#include<algorithm>
using namespace std;
#define int long long
struct node
{
	int sta;
	int p;
	friend bool operator < (const node &a,const node &b)
	{
		return a.p<b.p;
	}
}sus[505];
int n,mod;
int pri[10]={2,3,5,7,11,13,17,19};
int dp[(1<<10)][(1<<10)][2];
int f[(1<<10)][(1<<10)];
long long ans;
signed main()
{
	cin>>n>>mod;
	f[0][0]=1;
	for(int i=2;i<=n;i++)
	{
		int t=i;
		for(int j=0;j<=7;j++)
		{
			if(t%pri[j]==0)
			{
				sus[i].sta|=(1<<j);
				while(t%pri[j]==0)
					t/=pri[j];
			}
		}
		sus[i].p=t;
	}
	sort(sus+2,sus+n+1);
	for(int i=2;i<=n;i++)
	{
		if(sus[i].p==1||sus[i].p!=sus[i-1].p)
		{
			for(int j=0;j<(1<<8);j++)
			{
				for(int k=0;k<(1<<8);k++)
				{
					dp[j][k][0]=dp[j][k][1]=f[j][k];
				}
			}
		}
		for(int j=(1<<8)-1;j>=0;j--)
		{
			for(int k=(1<<8)-1;k>=0;k--)
			{
				if((sus[i].sta&k)==0)
				{
					dp[j|sus[i].sta][k][1]=(dp[j|sus[i].sta][k][1]+dp[j][k][1])%mod;
				}
				if((sus[i].sta&j)==0)
				{
					dp[j][k|sus[i].sta][0]=(dp[j][k|sus[i].sta][0]+dp[j][k][0])%mod;
				}
			}
		}
		if(sus[i].p==1||sus[i].p!=sus[i+1].p)
		{
			for(int j=0;j<(1<<8);j++)
			{
				for(int k=0;k<(1<<8);k++)
				{
					f[j][k]=((dp[j][k][0]+dp[j][k][1]-f[j][k])%mod+mod)%mod;
				}
			}
		}
	}
	for(int i=0;i<(1<<8);i++)
	{
		for(int j=0;j<(1<<8);j++)
		{
			if((i&j)==0)
			{
				ans=(ans+f[i][j])%mod;
			}
		}
	}
	cout<<ans;
	return 0;
}