洛谷2150 [NOI2015]寿司晚宴 （状压dp+思维）

真的是一道好题qwq
思路很巧妙的啊。。

首先根据题目描述，我们不难想到通过质因子来限制那个要求

也就是说，我们对于同一个质因子只能分配给一个人。

那么对于那个小的数据范围，也就是 $n\le 30$

$f[s1][s2]$表示 $A选了s1集合，B选了s2的集合$的方案数

然后对于一个新的物品（防止计算重复，我们倒着枚举）
$if (k\ and\ s2==0)$那么 $f[s1|k][s2]+=f[s1][s2]$
$if (k\ and\ s1==0)$那么 $f[s1][s2|k]+=f[s1][s2]$

最后只需要把所有情况的和加起来就结束了

但是正解应该怎么做呢？
qwq
由于质数太多，所以我们不能直接状压。

但是考虑到

大小大于根号n的质因数，在[1,n]的数中，每个数最多含有一个。

那么这时候，我们可以考虑把原来的每一个权值弄成一个小质数的 $01$压缩串，和一个大质数的乘积（如果没有就是1）

由于我们发现，这些大于 $\sqrt n$的数，不会影响别的权值的。

所以我们不妨按照大质数排序，把一样的放到一起计算

然后，我们考虑把他分给某一个人

那么我们不妨对这一段开两个数组进行 $dp$

由于我们是继承之前的方案数

所以

$f1[i][j]和f2[i][j]$都一开始的初始值是dp[i][j]

$if ((k\ and\ j)==0) f1[i|k][j]+=f1[i][j]$

这个是表示把含有这个大因数的所有数分给A。

$f2$同理

由于两种方案数是独立的，所以可以直接相加

然后 $dp[i][j]=f1[i][j]+f2[i][j]-dp[i][j]$

因为两个都不选的方案会被算重复一次（初始值）

if (a[i].da==1 || a[i].da!=a[i-1].da) 
  	{
  		memcpy(f1,dp,sizeof(f1));
  		memcpy(f2,dp,sizeof(f2));
    }
    for (int j=mx;j>=0;j--)//倒着枚举是因为滚掉了一维，原理和背包是一样的 
      for (int k=mx;k>=0;k--)
      {
      	  if (j&k) continue;
      	  if ((a[i].xiao & k)==0) f1[j|a[i].xiao][k] = (f1[j|a[i].xiao][k]+f1[j][k])%mod;
          if ((a[i].xiao & j)==0) f2[j][k|a[i].xiao] = (f2[j][k|a[i].xiao]+f2[j][k])%mod; 
      }
    if (a[i].da==1 || a[i].da!=a[i+1].da || i==n-1)
    {
      for (int j=mx;j>=0;j--) 
        for (int k=mx;k>=0;k--)
        {
      	  if (j&k) continue;
          dp[j][k]=(-dp[j][k]+mod)%mod; 
      	  dp[j][k]=(dp[j][k]+f1[j][k])%mod;
          dp[j][k]=(dp[j][k]+f2[j][k])%mod;//都不选的情况会计算两次。 
        }
    }

那么这个题基本上就能解决了

感觉思路还是非常神仙的

代码中也有一些注释。

// luogu-judger-enable-o2
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#define mk make_pair
#define ll long long

using namespace std;

inline int read()
{
  int x=0,f=1;char ch=getchar();
  while (!isdigit(ch)) {if (ch=='-') f=-1;ch=getchar();}
  while (isdigit(ch)) {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
  return x*f;
}

const int maxn = 310;

int dp[maxn][maxn];
//dp[i][j] 当A选了集合i,B选了集合j的方案数
int f1[maxn][maxn];
//f1[i][j] 当A选了集合i，B选了集合j的方案数（当前大数给A）
int f2[maxn][maxn];
//f2[i][j] 当A选了集合i，B选了集合j的方案数（当前大数给B）

//大致思路 就是我们对于小于根号n的质因子进行状压，然后大于根号n的因子(一个因数只可能有一个），只有一个是解决这个题的关键。
//因为不同的大于根号n的质因子，不会影响彼此。
 
//我们把相同的放到一起，然后考虑把他分给某一个人
// f1[i][j]和f2[i][j]都一开始的初始值是dp[i][j]
// if ((k&j)==0) f1[i|k][j]+=f1[i][j]
//这个是表示把含有这个大因数的所有数分给A。
//f2同理
//然后dp[i][j]=f1[i][j]+f2[i][j]-dp[i][j]因为两个都不选的方案会被算重复一次
int n,m;
int mod;
int mx = (1<<8)-1;

struct Node{
    int xiao,da;
};

Node a[1010];
int val[1010];
int prime[10]={0,2,3,5,7,11,13,17,19,23};

void solve(int num) //质因数分解 
{
    int x = val[num];
    int nn = x;
    for (int i=1;i<=8;i++) 
    {
        while (x%prime[i]==0)
        {
            a[num].xiao|=(1<<(i-1));
            x/=prime[i];
        }
    }
    a[num].da=x;
}

bool cmp(Node a,Node b)
{
    return a.da<b.da;
}

int main()
{
  n=read(),mod=read();
  for (int i=1;i<=n-1;i++) val[i]=i+1;
  for (int i=1;i<=n-1;i++) solve(i);
  sort(a+1,a+1+n-1,cmp);
  dp[0][0]=1;
  for (int i=1;i<=n-1;i++)
  {
  	if (a[i].da==1 || a[i].da!=a[i-1].da) 
  	{
  		memcpy(f1,dp,sizeof(f1));
  		memcpy(f2,dp,sizeof(f2));
    }
    for (int j=mx;j>=0;j--)//倒着枚举是因为滚掉了一维，原理和背包是一样的 
      for (int k=mx;k>=0;k--)
      {
      	  if (j&k) continue;
      	  if ((a[i].xiao & k)==0) f1[j|a[i].xiao][k] = (f1[j|a[i].xiao][k]+f1[j][k])%mod;
          if ((a[i].xiao & j)==0) f2[j][k|a[i].xiao] = (f2[j][k|a[i].xiao]+f2[j][k])%mod; 
      }
    if (a[i].da==1 || a[i].da!=a[i+1].da || i==n-1)
    {
      for (int j=mx;j>=0;j--) 
        for (int k=mx;k>=0;k--)
        {
      	  if (j&k) continue;
          dp[j][k]=(-dp[j][k]+mod)%mod; 
      	  dp[j][k]=(dp[j][k]+f1[j][k])%mod;
          dp[j][k]=(dp[j][k]+f2[j][k])%mod;//都不选的情况会计算两次。 
        }
    }
  }
  int ans=0;
  for (int j=0;j<=mx;j++)
    for (int k=0;k<=mx;k++)
    {
    	if (j&k) continue;
    	ans=(ans+dp[j][k])%mod;
    }
  cout<<ans;
  return 0;
}