840C - On the Bench （容斥 + DP）

最新推荐文章于 2024-11-11 18:21:37 发布

Orange琦~

最新推荐文章于 2024-11-11 18:21:37 发布

阅读量193

点赞数 1

分类专栏：组合数学文章标签：算法动态规划

本文链接：https://blog.csdn.net/Orangechengqi/article/details/129166789

版权

组合数学专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章介绍了如何处理一个数组排列问题，要求任何两个相邻元素的乘积不是完全平方数。通过将完全平方数归为同一类，并使用并查集进行合并。接着，将问题转化为计算不同颜色球的同色不相邻排列数量，利用动态规划和容斥原理求解，最后给出了一段C++代码实现。

摘要由CSDN通过智能技术生成

840C - On the Bench

题意

给定序列 $a [1... n]$ ，求有多种 $a$ 的排列，满足任意两个相邻的数乘积不是完全平方数，答案对 $10^9+7$ 取模。

$a_i\le 10^9,\ 1\le n \le 300$

转换

如果 $xy=p^2$ ， $yz=q^2$ ，那么 $xz=({\dfrac{pq}{x}})^2$ ，也是一个完全平方数。所以我们可以把把 $x, y, z$ 视为一个同一种颜色，以此类推……用并查集维护每一种颜色的数量。

于是问题转换为：

有 $m$ 种颜色的球，第 $i$ 种颜色的球有 $s_i$ 种，总共 $n$ 个球，求同色不相邻的排列的数量。

DP + 容斥 $O(n^2)$

本方法参考这篇博客。

设 $f (k)$ 表示把这些小球分成 $k$ 个连续段的方案数，其中：

每一段都是相同的颜色；
段内小球考虑排列顺序；
段与段之间无序，即所有的段构成一个无序集合。

下面用 DP 来求 $f (k)$ 。

设 $f (i, k)$ 表示考虑前 $i$ 种颜色，分成了 $k$ 组的方案数。容易推出 $f$ 的转移方程
$\sum_{j=1}^{\min(s_i, k)}f(i-1,k-j)\cdot \dfrac{s_i!\cdot{s_i-1\choose j-1}}{j!}$

简要介绍这个式子的含义。

枚举最后一种颜色（第 $i$ 种颜色）分成了 $j$ 段，所以由 $f (i - 1, k - j)$ 转移过来。

$s_i!$ 是将 $s_i$ 个同色小球排列，然后 ${s_i-1\choose j-1}$ 是将这个排列分成 $k$ 个段（原理是隔板法）。由于组与组是无序的，所以要除以 $j!$ 。

那么 $f (n, k)$ 就是将所有的小球分为 $k$ 组的方案数，简要记为 $f (k)$ 。

特别注意一下这个 DP 式子的复杂度，它虽然是三重循环，但神奇的是它的复杂度其实是 $O(n^2)$ 。因为第一层循环的是颜色，第三层循环的次数不超过该种颜色的数量，所以这两层循环的总次数其实是 $\sum_{i=m}^{n}s_i$ ，这两层和一块是 $O (n)$ 级别的。

如果把所有小球分为 $k$ 组，那么至少有 $n - k$ 对相邻的同色小球。

所以 $f(n)\cdot n!$ 就是提前钦定 $n - k$ 对同色小球，其余随意组合的方案数之和。这样答案就是典型的容斥
$ans=f(n)\cdot n! - f(n-1)\cdot(n-1)! + \dots$

#include <bits/stdc++.h>
using namespace std;

#define int long long
#define PII pair<int, int>


int Testnum = 1;

/**********************  Core code begins  **********************/

const int N = 1003, MOD = 1e9 + 7;
int n, a[N];
int fac[N], inv[N], invfac[N];
int m = 0, s[N], f[N][N];

struct DSU {
    int fa[N], siz[N];

    void init() {
        for (int i = 1; i < N; i++) {
            fa[i] = i;
            siz[i] = 1;
        }
    }

    int find(int x) {
        return fa[x] == x ? x : fa[x] = find(fa[x]);
    }

    void merge(int x, int y) {
        if (find(x) == find(y)) {
            return;
        }

        int fx = find(x), fy = find(y);
        fa[fx] = fy;
        siz[fy] += siz[fx];
    }
} dsu;


void init() {
    fac[0] = inv[0] = invfac[0] = 1;
    fac[1] = inv[1] = invfac[1] = 1;

    for (int i = 2; i < N; i++) {
        fac[i] = fac[i - 1] * i % MOD;
        inv[i] = ((MOD - MOD / i * inv[MOD % i]) % MOD + MOD) % MOD;
        invfac[i] = invfac[i - 1] * inv[i] % MOD;
    }
}


int C(int x, int y) {
    if (x < y || x < 0) {
        return 0;
    }

    return fac[x] * invfac[y] % MOD * invfac[x - y] % MOD;
}


void SolveTest() {
    cin >> n;

    dsu.init();
    init();

    for (int i = 1; i <= n; i++) {
        scanf("%lld", &a[i]);
    }

    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            int x = sqrt(a[i] * a[j]);

            if (x * x == a[i] * a[j]) {
                dsu.merge(i, j);
            }
        }
    }

    m = 0;

    for (int i = 1; i <= n; i++) {
        if (dsu.fa[i] == i) {
            s[++m] = dsu.siz[i];
        }
    }

    f[0][0] = 1;

    for (int i = 1; i <= m; i++) {

        for (int k = i; k <= n; k++) {
            for (int j = 1; j <= min(s[i], k); j++) {
                f[i][k] = (f[i][k] + f[i - 1][k - j] * fac[s[i]] % MOD 
                    * C(s[i] - 1, j - 1) % MOD * invfac[j] % MOD) % MOD;
            }

        }
    }

    int res = 0, sig = 1;

    for (int i = n; i >= 1; i--) {
        res = (res + sig * f[m][i] % MOD * fac[i] % MOD) % MOD;
        sig = MOD - sig;
    }

    cout << res;
}

/**********************  Core code ends  ***********************/


signed main() {

#ifdef LOCAL
    freopen("in.txt", "r", stdin);
#endif

    // cin >> Testnum;

    for (int i = 1; i <= Testnum; i++) {
        SolveTest();
    }

    return 0;
}