容斥原理

例：计算含有某几个质因子的数的个数

#include<cstdio>
#define maxn 20
using namespace std;

int n,k,a[maxn],ans=0;

void dfs(int now,int sum,int typ)
{
	if(now == k+1){ if(sum > 1)ans += (n / sum) * typ;return; }
	dfs(now+1,sum,typ);
	dfs(now+1,sum*a[now],-typ);
}

int main()
{
	scanf("%d%d",&n,&k);
	for(int i=1;i<=k;i++) scanf("%d",&a[i]);
	dfs(1,1,-1);
	printf("%d\n",ans);
}

上面那个东西当然是拿来搞笑的。
最近对容斥原理有了较深的理解，前来补博客。
容斥原理对于大多数人来说是一个原理，因为这个事实（对于普通人来说）太显然了，你想想，满足某一个条件的元素个数-满足某二个条件的元素个数+满足某三个条件的元素个数。。。。。显然是对的吧。
于是大多数人就这么去把它当做一个（）原理去套了，然后被毒瘤出题人折磨致死。

所以这个东西是需要证明的。
其实容斥原理就是一种反演。
因为你是用至少（多）满足某几个条件的方案数来推出刚好满足某几个条件的方案数。
令f(sta) = 至少（多）满足sta条件的方案数 （sta是一个集合）
令g(sta) = 刚好满足sta条件的方案数 （sta是一个集合）
如果是至少，那么f(sta) = sigma g(ista) (ista & sta = sta)
则 g(空) = f(空) - f(1) - f(2) - f(3) … + f(1,2) + f(2,3)…
这个就显然多了对吧。。。。。。
相应的g(sta) = sigma( (-1)^|tmp| * f(sta | tmp) , tmp & sta = 0)

这就是容斥原理的基本形式。
剩余其他的奇怪题目都是它的变形。
可以发现上面的形式是2^n的，效率很低。。。。。。
（其实，用的更加广泛的是减去补集。。。。）

但是容斥原理的原理并不在这，原理在于每一个元素的总（正负加起来）贡献是1。。。。。。

类型1：

这个就是一般人用常识推出来的容斥原理了。
一般中规中矩的容斥原理题都是这个类型。
其实上面的公式还有另外一种理解方法：
alpha(k) = sigma( C(q,k) * g(q) )
然后通过二项式反演可得：
g(k) = sigma( (-1)^q+k * C(q,k) * alpha(k) )
这是一样的。

例：
[bzoj4487][JSOI2015]染色问题
题目大意
有一个n*m的网格，你有p种颜色，每个格子可以不涂色或涂p种颜色中的一种。满足以下条件
1、每行都要有格子被涂
2、每列都要有格子被涂
3、每种颜色都得用

这个题就是非常典型的容斥原理题。
3大种不同的条件，但是同一大种条件中每一小种都互相等价。
1.设某一行没有格子被涂为一个a种条件
2.设某一列没有格子被涂为一个b种条件
3.设某一种颜色没有被涂为一个c种条件
g(a,b,c) = (-1)^a * (-1)^b * (-1)^c * alpha(a,b,c)
alpha(a,b,c) = C(n,a) * C(m,b) * C(p,c) * (n*m)^c+1
答案就是求g(0,0,0)

例2：
[bzoj4487][JSOI2015]染色问题
题目大意
有2^n个集合，每个集合只包含[1,n]，且这些集合两两不同。问有多少种选择方法（至少选一个），使得这些集合交集大小为k。

上一个题用一般人的办法好像也可以理解，但是求满足恰好k个条件，很多人就不会做了，其实就是求g(k)
g(k) = alpha(k) - C(k+1,k) * alpha(k+1)…
alpha(k) = C(n,k) * (2²^^(n-k)-1)（不会用csdn打幂套幂啊。。。）

其实容斥原理更深的本质就是去重，套一个容斥系数算简单的函数的答案组合起来。
所以上面的情形这是一种常用的容斥原理模型，更加广泛的运用就得把容斥系数活用起来，
研究不同的容斥系数模型是必要的，但是这些模型都是在集合容斥原理的基础上建立的，无论是用条件个数容斥，还是用集合容斥，答案对才是硬道理。。。。。。。

到这应该就能理解了，容斥系数就是通过构造，让每一个元素都只贡献它应该贡献的值。
在上面的广义容斥原理中，每一个满足恰好p个条件的元素都对g(0)贡献了sigma( (-1)^k * C(p,k) )
这个式子在p=0时值为1，其他时候为0。
那么同理对g(q)的贡献： sigma((-1)^k-q * C(p,k) * C(k,q) ) = sigma((-1)^k-q * C(p-q,k-q)) * C(p,q)
这个也是在p=q时值为1，其他时候为0。

这又是容斥原理的另一种理解方式。
现在我们有两种计算容斥系数的方法，第一种是直接去重，第二种是构造容斥系数。

下面就可以开始了：
满足恰好k个条件的一种方案的贡献为a[k],求总贡献。。。。
还是alpha(k)会将sta 算 C(|sta|,k)次。
然后我们来算alpha(k)在答案中的系数seq(k)，
sigma( seq(k) * C(|sta|,k) , k<=sta ) = a[|sta|] 对所有sta都满足。
显然只和|sta|有关，n^2爆算seq(k)。
或者 sigma( seq(k) * C(|sta|,|sta| - k) , k<=sta ) = a[|sta|]
这个都很明白要干什么事情吧，多项式除法（求逆） O(nlogn)
比如说？
错排问题，1~n，如果有k个位置满足错排，则价值定义为a[k]，求所有排列的价值和。（n<= 100000）
alpha(k) = C(n,k) * (n-k)！ = n! / k!
好像有点毒瘤，但是有点板，有点套路。

下面就是一些常见容斥系数模型（学习自WerKeyTom_FTD）：
1： 组合数形式 枚举约束的子集
2 : 斯特林数形式 枚举划分的子集

还有一种奇怪的容斥

参考博客：
https://blog.csdn.net/kele52he/article/details/77372902
https://blog.csdn.net/werkeytom_ftd/article/details/74701513