【CodeForces840C】On the Bench（容斥、DP）

最新推荐文章于 2024-05-02 11:06:22 发布

原创最新推荐文章于 2024-05-02 11:06:22 发布 · 378 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#DP #CodeForces #容斥

OI题解同时被 2 个专栏收录

74 篇文章

订阅专栏

动态规划(DP)

20 篇文章

订阅专栏

本文探讨了一个计数问题，即求解给定条件下排列的数量，确保相邻元素的乘积不是完全平方数。通过去除数的平方因子，将问题转化为经典计数问题并运用容斥原理求解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目大意

$m(1\leq m \leq 300)$ 个数 $a_i(1\leq a_i \leq 10^9)$ ，求有多少个排列（每个数都不相同，即使它们值一样），满足相邻两个数相乘的积不为完全平方数。

题解

将每个 $a_i$ 的平方因子全部除掉，剩下的数转换为一个经典问题：
有 $n_1$ 个 $a_1$ ， $n_2$ 个 $a_2$ …… $n_N$ 个 $a_N$ ，每个数都不相同，求使得相邻两个数不相同的排列有几个。
利用容斥原理，用 $f_k$ 表示至少有 $k$ 对相邻的数相同。
答案 $ans=f_0-f_1+f_2-f_3+f_4-...+(-1)^{m-1}f_{m-1}$

利用分块来求出“至少有 $k$ 个相邻的数相同”
用 $dp[i][k]$ 表示前 $i$ 种数分为 $k$ 块，使得每一个块里面的数保证相同，并保证块与块之间没有顺序（可以理解为块总是按从小到大的排序）
这样 $dp[N][k]\times k!$ ，表示把所有数分为 $k$ 块的方案数，就保证了最多有 $k-1$ 对相邻数不同（块与块之间），也就是最多有 $(n-1)-(k-1)=n-k$ 对相邻数相同。
$\times k!$ 原因是 $dp[N][k]$ 表示的块是无序的，乘以 $k!$ 得到它的全排列方案。

保证块与块之间无序可以这样理解：3个值相同的数（用 $1,2,3$ 表示）分成两块，有这些分法
$112233 | | | | | | 231312323121$ $\begin{matrix} 1&|&2&3\\ 1&|&3&2\\ 2&|&1&3\\ 2&|&3&1\\ 3&|&1&2\\ 3&|&2&1\\ \end{matrix}$
保证无序的意思就是把 $1\space 2\space |\space 3$ 看做与 $3\space|\space 1\space 2$ 是一种方案。

转移时，枚举将第 $i$ 种数，分为 $j$ 块

d p [i] [k] = \sum j = 1 k d p [i - 1] [k - j] \times C j - 1 n i - 1 \times n i ! j !

$dp[i][k]=\sum_{j=1}^k dp[i-1][k-j]\times C_{n_i-1}^{j-1}\times \frac {n_i!} {j!}$

Cj−1ni−1Cni−1j−1 $C_{n_i-1}^{j-1}$ 利用隔板法，把

nini $n_i$ 个数分为

jj $j$ 块
除以

j!

$j!$ 表示使块无序
乘以

ni!ni! $n_i!$ ，因为每个数都不相同，所以还需乘以总排列数

代码

#include<cstdio>
#include<cstring>
#include<map>
using namespace std;
const int MAXN=305;
const int MOD=1000000007;

int pow_mod(int a,int b)
{
    int ret=1;
    while(b)
    {
        if(b&1)
            ret=(1LL*ret*a)%MOD;
        a=(1LL*a*a)%MOD;
        b>>=1;
    }
    return ret;
}

int n;
map<int,int> ni;
int fac[MAXN],inv[MAXN];
int C[MAXN][MAXN];
int dp[MAXN][MAXN];

int main()
{
    fac[0]=1;
    for(int i=1;i<MAXN;i++)
        fac[i]=(1LL*fac[i-1]*i)%MOD;
    inv[MAXN-1]=pow_mod(fac[MAXN-1],MOD-2);
    for(int i=MAXN-2;i>=1;i--)
        inv[i]=(1LL*inv[i+1]*(i+1))%MOD;

    C[0][0]=1;
    for(int i=1;i<MAXN;i++)
    {
        C[i][0]=1;
        for(int j=1;j<MAXN;j++)
            C[i][j]=(C[i-1][j]+C[i-1][j-1])%MOD;
    }

    scanf("%d",&n);
    for(int i=1,a;i<=n;i++)
    {
        scanf("%d",&a);
        for(int p=2;1LL*p*p<=a;p++)
            while(a%(p*p)==0)
                a/=p*p;
        ni[a]++;
    }

    dp[0][0]=1;
    map<int,int>::iterator it=ni.begin();
    int cnt=0;
    for(int i=1,num=it->second;it!=ni.end();it++,i++,num+=it->second,cnt++)
        for(int k=i;k<=num;k++)
            for(int j=1;j<=k&&j<=it->second;j++)
                dp[i][k]=(dp[i][k]+1LL*dp[i-1][k-j]*C[it->second-1][j-1]%MOD*fac[it->second]%MOD*inv[j]%MOD)%MOD;

    int ans=0;
    for(int k=n,flag=1;k>=1;k--,flag=-flag)
        ans=(ans+MOD+1LL*flag*dp[cnt][k]*fac[k]%MOD)%MOD;
    printf("%d\n",ans);

    return 0;
}