BZOJ4197 [Noi2015]寿司晚宴

最新推荐文章于 2021-07-09 21:31:58 发布

neither_nor

最新推荐文章于 2021-07-09 21:31:58 发布

阅读量611

点赞数

CC 4.0 BY-SA版权

分类专栏： BZOJ DP、递推

本文链接：https://blog.youkuaiyun.com/neither_nor/article/details/52248067

BZOJ 同时被 2 个专栏收录

382 篇文章

订阅专栏

DP、递推

84 篇文章

订阅专栏

本文介绍了一种解决特定数学问题的方法，通过状态压缩动态规划技术来计算两个玩家选取互质数字的方案数量。考虑到数字大小限制，文章利用小于根号500的质数进行状态压缩，并详细阐述了DP过程。

注意到对于任意一个数，他与别的数是否互质取决于他俩是否有相同的质因数，而对于任意的x，x的大于根号x的质因数最多有一个，而n<=500，根号500内的质数只有8个

所以我们可以考虑对每个人取的小于根号500的质数的状态状压，然后枚举每个数，进行DP

f[i][j]表示第一个人小于根号五百的质数的状态为i，第二个人为j的方案数

枚举当前数，设当前数为x，x去掉所有小于根号五百的质因子之后的数为y

对于所有y相等但不为1的数（每个y为1的数都可以考虑为y互不相同的，因为他们是互不影响的），考虑这个y被谁拿了

设g[i][j][k]表示当前的y由i拿，第一个人状态为j，第二个人状态为k的方案数

初始g[i][j][k]=f[j][k]，然后先枚举所有y等于当前y的数，然后从大到小枚举j和k，每当第i个人能拿当前数时，f[i][j][k]+=f[i][j|d[x]][k]或者f[i][j][k]+=f[i][j][k|d[x]]

dp完之后，f[i][j]=g[1][i][j]+g[2][i][j]-f[i][j]

减去f[i][j]是因为两个人都没选当前数的情况被算了两遍

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<map>
#include<set>
#include<bitset>
#include<queue>
#include<stack>
using namespace std;
#define MAXN 510
#define MAXM 510
#define INF 1000000000
#define MOD 1000000007
#define eps 1e-8
#define ll long long
struct num{
	int d;
	int r;
	friend bool operator <(num x,num y){
		return x.r!=y.r?x.r<y.r:x.d<y.d;
	}
};
int f[MAXN][MAXN],g[2][MAXN][MAXN];
num a[MAXN];
int n,mod;
int p[20]={2,3,5,7,11,13,17,19};
int main(){
	int i,j,k;
	int N=(1<<8);
	scanf("%d%d",&n,&mod);
	for(i=2;i<=n;i++){
		a[i].r=i;
		for(j=0;j<8;j++){
			while(!(a[i].r%p[j])){
				a[i].d|=1<<j;
				a[i].r/=p[j];
			}
		}
	}
	sort(a+2,a+n+1);
	f[0][0]=1;
	for(i=2;i<=n;i++){
		if(a[i].r!=a[i-1].r||a[i].r==1){
			memcpy(g[0],f,sizeof(f));
			memcpy(g[1],f,sizeof(f));
		}
		for(j=N-1;~j;j--){
			for(k=N-1;~k;k--){
				if(!(a[i].d&k)){
					(g[0][j|a[i].d][k]+=g[0][j][k])%=mod;
				}
				if(!(a[i].d&j)){
					(g[1][j][k|a[i].d]+=g[1][j][k])%=mod;
				}
			}
		}
		if(a[i].r!=a[i+1].r||a[i].r==1){
			for(j=N-1;~j;j--){
				for(k=N-1;~k;k--){
					f[j][k]=(((g[0][j][k]+g[1][j][k])%mod-f[j][k])%mod+mod)%mod;
				}
			}
		}
	}
	int ans=0;
	for(j=N-1;~j;j--){
		for(k=N-1;~k;k--){
			(ans+=f[j][k])%=mod;
		}
	}
	printf("%d\n",ans);
	return 0;
}

/*
3 100

*/