Codeforces 840C On the Bench 【容斥+DP】

题目地址：点击打开链接

【看了叉姐的代码再慢慢思考才会的。。Orz】

两个数字的乘积是完全平方数的话，那么这两个数的对应质因子的数量和一定是偶数。那么也就是说，如果两个数分解质因数之后每种质因子的个数最多只有一个的话，那么两个数的乘积为完全平方数当且仅当两个数相等。考虑到完全平方数的性质，我们可以将数列中的每个数中存在的多余的质因子去掉（两个两个去掉）。

例如说，对于数字300，分解质因数之后为2*2*3*5*5，于是便可以将2*2和5*5去掉（因为其对两个数的乘积的对应质因子数的奇偶性不会做出贡献），于是在这个问题中，300跟3是完全等效的。

于是对数列进行上述处理之后，问题便转化为，有多少种排列组合使得没有两个相同的数字相邻。

原数列的顺序已经无关紧要了。所以可以使用一个map统计【某个数有多少个】。

考虑这个问题的简化模式，将数列中的数字归类为k个数块（每个数块中的数字数量至少为1，且数块中的数字是相同的），问有多少种归类方式。

设该简化版的问题的解为dp[k]，则原问题的答案可由dp[k]容斥得到：

ans=dp[n]*n!-dp[n-1]*(n-1)!+dp[n-2]*(n-2)!-dp[n-3]*(n-3)!+......

其中，由于dp[k]为归类的方案数，所以需要乘上k!，表示用这k块进行全排列的方案数。剩余部分便是容斥了。

对于dp[k]，可以考虑多一维处理（为了方便进行dp）。

于是设dp[i][k]为，考虑map种的前i种数时的dp[k]

则对于dp[i][k]而言，枚举第i种数的分块方案（分成j块），然后乘上dp[i-1][k-j]，累加起来便是答案。

设第i种数的个数为p，那么将p个数分为j块的方案数就是，p个数的全排列（p!），再乘上在p个数中放j-1块隔板使其分成j块的方案数（C(p-1,j-1)），再除以j个块的全排列（j!）（因为分块方案是无序的，但是块內的数是有序的）。

于是就可以计算出dp[k]，进而计算出ans。

预处理出阶乘，组合数，阶乘逆元，然后计算即可。

代码如下：

#include <bits/stdc++.h>

using namespace std;

#define sfi(a) scanf("%d",&a)
#define sfd(a) scanf("%lf",&a)
#define sfl(a) scanf("%lld",&a)
#define sfs(a) scanf("%s",a)

#define rep(i,a,b) for(int i=int(a);i<int(b);++i)
#define dwn(i,b,a) for(int i=int(b-1);i>=int(a);--i)

#define mem(a,p) memset(a,p,sizeof(a))

typedef long long LL;
typedef unsigned UINT;
typedef unsigned long long ULL;

const LL mod=1e9+7;

LL inv(LL a)
{
	if(a==1)return a;
	return inv(mod%a)*(mod-mod/a)%mod;
}

LL C[305][305];
LL F[305],invF[305];

LL dp[305][305];

void init()
{
	C[0][0]=1;
	C[1][0]=C[1][1]=1;
	F[0]=F[1]=1;
	invF[0]=invF[1]=1;
	rep(i,2,301)
	{
		F[i]=(F[i-1]*i)%mod;
		invF[i]=inv(F[i]); 
		C[i][0]=C[i][i]=1;
		rep(j,1,i)
			C[i][j]=(C[i-1][j-1]+C[i-1][j])%mod;
	}
}

map<int,int> mp;

int main()
{
	init();
	int n;
	while(sfi(n)==1)
	{
		mp.clear();
		rep(i,0,n)
		{
			int a;
			sfi(a);
			int p=1;
			for(int d=2;d*d<=a;d++)
			{
				if(a%d==0)
				{
					int cnt=0;
					while(a%d==0)
					{
						a/=d;
						cnt++;
					}
					if(cnt&1)p*=d;
				}
			}
			if(a>1)p*=a;
			mp[p]++;
		}
		mem(dp,0);
		dp[0][0]=1;
		int cnt=1;
		for(map<int,int>::iterator it=mp.begin();it!=mp.end();it++)
		{
		//	printf("(%d %d)\n",(*it).first,(*it).second);
			int p=(*it).second;
			rep(i,0,n+1)
			{
				rep(j,1,i+1)
				{
					if(j>p)break;
					
					LL pans=1;
					pans*=F[p];
					pans*=C[p-1][j-1];
					pans%=mod;
					pans*=invF[j];
					pans%=mod;
					
		//			printf("pans=F[%d]*C[%d][%d]/F[%d]\n",p,p-1,j-1,j);
		//			printf("F[%d]=%lld\n",p,F[p]);
		//			printf("C[%d][%d]=%lld\n",p-1,j-1,C[p-1][j-1]);
		//			printf("invF[%d]=%lld\n",j,invF[j]);
					
		//			printf("Add dp[%d][%d]*%lld into dp[%d][%d]\n",cnt-1,i-j,pans,cnt,i);
					
					dp[cnt][i]+=(dp[cnt-1][i-j]*pans);
					dp[cnt][i]%=mod;
				}
		//		printf("dp[%d][%d]=%lld\n",cnt,i,dp[cnt][i]);
			}
			cnt++;
		}
		
		LL ans=0;
		dwn(i,n+1,0)
		{
			LL pans=F[i]*dp[cnt-1][i];
			pans%=mod;
			if((n-i)&1)ans-=pans;
			else ans+=pans;
			ans=((ans%mod)+mod)%mod;
		}
		printf("%lld\n",ans);
	}
}