[bzoj2839]集合计数 （容斥原理/二项式反演）

[bzoj2839]集合计数

容斥原理/二项式反演

考虑一个比较错误的答案，先选出 \(k\) 个元素，有 \(C(n,k)\) 种方案，再从剩下的 \(n-k\) 个数中选集合，有 \(2^{n-k}\) 集合，有 \(2^{2^{n-k}}-1\) 种选法（去掉什么都不选），答案 \(g_k=C(n,k)\times2^{2^{n-k}}-1\)。这样做显然会算重，设 \(A\) 为我们钦定的 \(k\) 个元素，假如有一个交集 \(B\in A\)，那么 \(B\) 集合它会被算 \(C(|B|,k)\) 次。

法一：二项式反演

设交集恰好为 \(k\) 个元素的方案数为 \(f_k\)，那么根据上面有关系 \(g_k=\sum_{i=k}^nC(i,k)f_i\)。

这个形式就是二项式反演：\(g_n=\sum_{i=k}^nC(i,k)f_i\Rightarrow f_n=\sum_{i=k}^n(-1)^{i-k}C(i,k)g_i\)

所以直接跑一遍二项式反演即可。复杂度 \(O(n\log V)\)。

法二：容斥原理

直接根据上面的想法容斥，属性就是当前交集的元素，类就是交集的大小，\(k\) 类的答案就是 \(g_k\)。算重的 \(g_k\) 多算了 \(C(k+1,k)\) 次 \(g_{k+1}\)，减去；多减了 \(C(k+2,k)\) 次 \(g_{k+2}\)，加上，以此类推。最后答案的形式和二项式反演的形式相同。

所以实质上这题就是求集合中一类的数量，那么容斥就有 \(g_n=\sum_{i=k}^nC(i,k)f_i\Rightarrow f_n=\sum_{i=k}^n(-1)^{i-k}C(i,k)g_i\)。

#include <bits/stdc++.h>
#define pii std::pair<int, int>
#define fi first
#define se second
#define pb push_back

using i64 = long long;
using ull = unsigned long long;
const i64 iinf = 0x3f3f3f3f, linf = 0x3f3f3f3f3f3f3f3f;
const int N = 1e6 + 10, mod = 1e9 + 7;
i64 qpow(i64 a, i64 b, i64 m) {
	i64 ret = 1;
	while(b) {
		if(b & 1) ret = ret * a % m;
		a = a * a % m;
		b >>= 1;
	}
	return ret;
}
struct BIN {
	i64 fac[N], inv[N];
	void init(int n) {
		fac[0] = 1;
		for(int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mod;
		inv[n] = qpow(fac[n], mod - 2, mod);
		for(int i = n - 1; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
	}
	i64 C(i64 n, i64 m) {
		if(n < m) return 0;
		return fac[n] * inv[m] % mod * inv[n - m] % mod;
	}
} comb;
void solve() {
	comb.init(N - 10);
	int n, k;
	std::cin >> n >> k;

	i64 ans = 0;
	for(int i = k; i <= n; i++) {
		ans = (ans + qpow(-1, i - k, mod) * comb.C(i, k) % mod * comb.C(n, i) % mod * (qpow(2, qpow(2, n - i, mod - 1), mod) - 1) % mod + mod) % mod;
	}
	std::cout << ans << "\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
	solve();

	return 0;
}