函数与表达式的反演变换

下面提到的所有知识不一定同属一个范畴，但是它们的思想和作用相似，所以将其归为一篇文章。

---

莫比乌斯反演

请先学习狄利克雷卷积，否则您会一脸懵逼。

一般式：
$$\begin{array}{r}F(n)=\sum _{d|n}G(d)\to G(n)=\sum _{d|n}\mu (\frac{n}{d})F(d)\\ F(n)=\sum _{n|d}G(d)\to G(n)=\sum _{n|d}\mu (\frac{d}{n})F(d)\end{array}$$

证明可以考虑下面恒等式的第一条。

然后再放一些有助于反演的恒等式：（其中 $\ast$ 指狄利克雷卷积，$ϵ(n)$ 表示 $[n=1]$）
$$\begin{array}{rl}& \mu \ast 1=ϵ\\ & \phi \ast 1=id\\ & \mu \ast id=\mu \ast 1\ast \phi =ϵ\ast \phi =\phi \\ & \phi (n)=\sum _{i=1}^nϵ(\gcd (n,i))\\ & \phi (nm)=\frac{\phi (n)\phi (m)\gcd (n,m)}{\phi (\gcd (n,m))}\\ & \sum _{i=1}^n\sum _{j=1}^nϵ(\gcd (i,j))=2\cdot (\sum _{i=1}^n\phi (i))-1\\ & \sum _{d|ij}1=\sum _{x|i}\sum _{y|j}ϵ(\gcd (x,y))\\ & \sum _{d|ijk}1=\sum _{x|i}\sum _{y|j}\sum _{z|k}ϵ(\gcd (x,y))ϵ(\gcd (y,z))ϵ(\gcd (x,z))\\ & \cdots \cdots \end{array}$$

推完式子之后，可以考虑用一些数论筛法预处理某些项，或是用整除分块求值。

---

拿一道例题来讲解吧。

一共 $T$ 组询问 $(T\le 10^4)$，给定常数 $K$，每次询问单独给定 $N$，满足 $N\le 10^7$，求出：
$$\sum _{i=1}^N\sum _{j=1}^N(i+j{)}^K\gcd (i,j){\mu }^2(\gcd (i,j))(\mathrm{m}\mathrm{o}\mathrm{d}{2}^{32})$$
看模数 $2^{32}$，显然可以自然溢出，这可以帮助我们减小常数。

接下来表演推式子：
$$\begin{array}{rl}原式& =\sum _{d=1}^N\sum _{i=1}^N\sum _{j=1}^N[\gcd (i,j)=d]((i+j{)}^{K}d{\mu }^2(d))\\ & =\sum _{d=1}^N{d}^{K+1}{\mu }^2(d)\sum _{i=1}^{\lfloor \frac{N}{d}\rfloor }\sum _{j=1}^{\lfloor \frac{N}{d}\rfloor }ϵ(\gcd (i,j))(i+j{)}^K\\ & =\sum _{d=1}^N{d}^{K+1}{\mu }^2(d)\sum _{i=1}^{\lfloor \frac{N}{d}\rfloor }\sum _{j=1}^{\lfloor \frac{N}{d}\rfloor }(i+j{)}^K\sum _{x|\gcd (i,j)}\mu (x)\\ & =\sum _{d=1}^N{d}^{K+1}{\mu }^2(d)\sum _{x=1}^{\lfloor \frac{N}{d}\rfloor }{x}^K\mu (x)\sum _{i=1}^{\lfloor \frac{N}{dx}\rfloor }\sum _{j=1}^{\lfloor \frac{N}{dx}\rfloor }(i+j{)}^K\\ & =\sum _{T=1}^N{T}^K\sum _{i=1}^{\lfloor \frac{N}{T}\rfloor }\sum _{j=1}^{\lfloor \frac{N}{T}\rfloor }(i+j{)}^K\sum _{d|T}d{\mu }^2(d)\mu (\frac{T}{d})\end{array}$$
到这里式子就是可做的了。

---

我猜你现在肯定一脸懵。

那就先来讲一讲吧。

• $Step1$

我们考虑枚举这个 $\gcd$ 的值。

为什么这里要做这样一个看似只会添一层循环的无意义举动呢？

可以发现，在后面的式子中多出了一个艾弗森括号，这个括号里写下的等式是可以转化为单位元的形式的。

• $Step2$

我们考虑对于每一个 $d$，只枚举 $d$ 的倍数。

（实际上，此时枚举的 $i,j$ 在后面的运算中会乘上一个 $d$。）

这样，艾弗森括号中的等式就可以被改写了，具体来说就是 $[\gcd (id,jd)=d]=[\gcd (i,j)=1]$。

在上面的式子中，后者已经写成了单位元的形式。

值得注意的是，由于 $i,j$ 实际上除去了一个 $d$，所以运算中多出来的一个 $d^K$ 要提到前面去。同时只和 $d$ 有关的一项 $d{\mu }^2(d)$ 也要提到前面去。

• $Step3$

还记得上面的公式 $\mu \ast 1=ϵ$ 吗？我们可以直接把这个单位元转化为莫比乌斯函数和 $1$ 的狄利克雷卷积！

所以，把卷积用好了，莫比乌斯反演就不难了，再难也只可能难在函数的筛法上。

然后呢？我们再把这个枚举的 $x$ 提前，把 $i,j$ 再次强制转化为 $dx$ 的倍数，多出来的 $x^K$ 同 $\mu (x)$ 一起往前提。

继续，我们发现这个式子代数还是太多了，于是考虑枚举 $T=dx$，那么 $d$ 必然是 $T$ 的因数，此时的 $x$ 则恰好等于 $\frac{T}{d}$，这样化简出来，式子已经可做了。

---

问题是，我们怎样知道式子是可做的呢？

我们设 $S(N)={\sum }_{i=1}^N{\sum }_{j=1}^N(i+j{)}^K$，$f(T)={\sum }_{d|T}d{\mu }^2(d)\mu (\frac{T}{d})$。

现在整个式子化简成了这样一个形式：${\sum }_{T=1}^N{T}^{K}S(\lfloor \frac{N}{T}\rfloor )f(T)$。

接下来分别考虑线性预处理 $S$ 和 $f$。

可以发现在 $S(N)$ 中，从 $2\sim 2N$ 的每一个数 $d^K$ 一共被计算了 $\min (d-1,2N+1-d)$ 次。

于是我们可以再设两个辅助函数 $F(N)={\sum }_{i=1}^N{i}^K$，$G(N)={\sum }_{i=1}^{N}F(i)$，显然这两个函数都是可以线性预处理的。

那么我们有式子：$S(N)={\sum }_{i=N+1}^{2N}F(i)-{\sum }_{i=1}^{N}F(i)=G(2N)-G(N)$，同样也可以线性预处理。

再来看 $f$，可以发现 $f$ 是一个狄利克雷卷积的标准形式，并且卷的是两个积性函数，说明整个式子也是一个积性函数。如果您阅读过我的文章《积性函数的筛法》，可以知道这样的函数是可以欧拉筛的。

我们来讨论一下 $f$ 在 $p^k(p\in Prime)$ 处的取值吧。

• $k=0$，显然有 $f(1)=1$；
• $k=1$，有 $f(p)=\mu (p)+p{\mu }^2(p)=p-1$；
• $k=2$，有 $f(p^2)=\mu (p^2)+p{\mu }^2(p)\mu (p)+p^2\mu (p^2)=-p$；
• $k\ge 3$，则每一项都存在 $\mu$ 为 $0$ 的情况，答案为 $0$。

次数很好判断，所以分讨即可。

最后，可以发现 $\frac{N}{T}$ 的取值个数是 $\sqrt{N}$ 级别的，所以可以套用整除分块。同时为了方便，可以把 $T^K$ 这一项扔进 $f$ 中一起预处理（最后求前缀和时配合 $F$ 数组一起求即可）。

为了省空间，把 $F$ 和 $G$ 当作一个数组，毕竟有了 $G$，$F$ 也没什么用了。

贴上代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>

#define MAXN 20000005

using uint = unsigned int;
using namespace std;

int T, N, K, len, Prime[MAXN];
uint f[MAXN], F[MAXN];
bool NotPrime[MAXN];

inline uint Pow(uint a, uint b)
{
	uint res = 1;
	while(b)
	{
		if(b & 1) res = res * a;
		a = a * a;
		b >>= 1;
	}
	return res;
}

inline void Sieve(int n, int k)
{
	f[1] = F[1] = 1;
	for(register int i = 2; i <= n; i++)
	{
		if(!NotPrime[i])
		{
			Prime[++len] = i;
			f[i] = i - 1;
			F[i] = Pow(i, k);
		}
		for(register int j = 1; j <= len && i * Prime[j] <= n; j++)
		{
			NotPrime[i * Prime[j]] = true;
			F[i * Prime[j]] = F[i] * F[Prime[j]];
			if(i % Prime[j] == 0)
			{
				if((i / Prime[j]) % Prime[j]) f[i * Prime[j]] = -Prime[j] * f[i / Prime[j]];
				break;
			}
			f[i * Prime[j]] = f[i] * f[Prime[j]];
		}
	}
	for(register int i = 2; i <= n; i++) f[i] = f[i - 1] + f[i] * F[i], F[i] += F[i - 1];
	for(register int i = 2; i <= n; i++) F[i] += F[i - 1];
	return;
}

inline uint Count(int k) { return F[k * 2] - F[k] * 2; }

int main()
{
	scanf("%d%d%d", &T, &N, &K), Sieve(N << 1, K);
	while(T--)
	{
		int n; scanf("%d", &n);
		uint ans = 0;
		for(register int l = 1, r; l <= n; l = r + 1)
		{
			r = n / (n / l);
			ans += Count(n / l) * (f[r] - f[l - 1]);
		}
		printf("%u\n", ans);
	}
	return 0;
}

---

二项式反演

其实二项式反演有一个更不广为人知的名字——广义容斥原理。

一般有两种形式：
$$\begin{array}{r}f(n)=\sum _{i=0}^n{C}_n^{i}g(i)\iff g(n)=\sum _{i=0}^n(-1{)}^{n-i}{C}_n^{i}f(i)\\ f(n)=\sum _{i=n}^m{C}_i^{n}g(i)\iff g(n)=\sum _{i=n}^m(-1{)}^{i-n}{C}_i^{n}f(i)\end{array}$$
正如前面所说，我们一般设 $g(n)$ 为 “恰好满足 $n$ 个性质” 的方案数。对于形式一和形式二，我们一般设 $f(n)$ 为 “至多满足 $n$ 个性质” 和 “至少满足 $n$ 个性质” 的方案数。

显然 $f(n)$ 更好求，并且 $g(n)$ 一般都做为题目要求的东西。

例题可以康康这道，太板了就不放题解和代码了。

---

单位根反演

其实就是这样一个式子：$[n|k]=\frac{1}{n}{\sum }_{i=0}^{n-1}{\omega }_n^{ik}$。

$\omega$ 指单位根。从数学上讲，它是一个复数。但是从广义上讲，只要在给定的数域和运算内满足 ${\omega }_n^n$（即 $n$ 阶单位根的 $n$ 次方）为 $1$，那么它就可以称做单位根。所以 $\omega$ 实际上还可以是原根。

证明略去~~，显然是因为不会~~。

---

康康例题

首先我们有 $\lfloor \frac{i}{k}\rfloor =({\sum }_{j=0}^i[k|j])-1$，这样就转化为单位根反演的形式了。

（可以不管后面的减 $1$，因为可以直接拆开然后二项式定理搞掉。）

然后我们直接莽式子：
$$\begin{array}{rl}& \sum _{i=0}^n{C}_n^i{p}^i((\sum _{j=0}^i[k|j])-1)\\ =& (\sum _{i=0}^n{C}_n^i{p}^i\sum _{j=0}^i\frac{1}{k}\sum _{t=0}^{k-1}{\omega }_k^{jt})-(p+1{)}^n\\ =& \frac{1}{k}(\sum _{t=0}^{k-1}\sum _{i=0}^n{C}_n^i{p}^i\sum _{j=0}^i({\omega }_k^t{)}^j)-(p+1{)}^n\\ =& \frac{1}{k}(\sum _{t=0}^{k-1}\sum _{i=0}^n{C}_n^i{p}^i\frac{{\omega }_k^{t(i+1)}-1}{{\omega }_k^t-1})-(p+1{)}^n\\ =& \frac{1}{k}(\sum _{t=0}^{k-1}\frac{({\sum }_{i=0}^n{C}_n^i{p}^i{\omega }_k^{t(i+1)})-(p+1{)}^n}{{\omega }_k^t-1})-(p+1{)}^n\\ =& \frac{1}{k}(\sum _{t=0}^{k-1}\frac{({\omega }_k^t(p{\omega }_k^t+1{)}^n-(p+1{)}^n}{{\omega }_k^t-1})-(p+1{)}^n\end{array}$$
可以发现，上面的式子中大量地用到了二项式定理，这玩意确实会经常和单位根反演配合使用。

上面的式子已经可做了，时间复杂度为 $O(k{\log }_{2}n)$，带 $\log$ 是因为快速幂。

然后您会发现您连样例都过不去。

我们再来审视一下整个式子。可以发现，当 $t=0$ 时，${\omega }_k^t=1$，此时分母为 $0$，这一段贡献是算错了的。

我们回到原来的式子：${\sum }_{i=0}^n{C}_n^i{p}^i{\sum }_{j=0}^i({\omega }_k^t{)}^j$，当 ${\omega }_k^t=1$ 时，该式子为 ${\sum }_{i=0}^n{C}_n^i{p}^i(i+1)$。

我们考虑一下这个式子怎么做。

首先我们把后面的加 $1$ 提出来，直接做一遍二项式定理。

剩下的就是 ${\sum }_{i=0}^n{C}_n^i{p}^{i}i$。

然后我们有一个广为人知的组合恒等式：$i{C}_n^i=n{C}_{n-1}^{i-1}$。

证明：$i{C}_n^i=i\cdot \frac{n!}{i!(n-i)!}=\frac{n!}{(i-1)!(n-i)!}=n\cdot \frac{(n-1)!}{(i-1)!((n-1)-(i-1))!}=n{C}_{n-1}^{i-1}$。

由于 $i=0$ 时没有贡献，因此我们从 $i=1$ 开始枚举。
$$\begin{array}{rl}& \sum _{i=1}^n{C}_n^i{p}^{i}i\\ =& n\sum _{i=1}^n{C}_{n-1}^{i-1}{p}^i\\ =& n\sum _{i=0}^{n-1}{C}_{n-1}^i{p}^{i+1}\\ =& np\sum _{i=0}^{n-1}{C}_{n-1}^i{p}^i\\ =& np(p+1{)}^{n-1}\end{array}$$
算法到此就大功告成了。

代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>

#define MOD 998244353

using namespace std;

int n, p, k, ans;

inline int GetMOD(int k) { if(k >= MOD) k -= MOD; return k; }

inline int Pow(int k, int q)
{
	int res = 1;
	while(q)
	{
		if(q & 1) res = 1LL * res * k % MOD;
		k = 1LL * k * k % MOD;
		q >>= 1;
	}
	return res;
}

inline int Inv(int k) { return Pow(k, MOD - 2); }

int main()
{
	scanf("%d%d%d", &n, &p, &k);
	const int G = Pow(3, (MOD - 1) / k);
	int w = 1;
	for(register int t = 0; t < k; t++)
	{		
		if(w == 1) ans = GetMOD(ans + GetMOD(1LL * n * p % MOD * Pow(p + 1, n - 1) % MOD + Pow(p + 1, n)));
		else ans = GetMOD(ans + 1LL * GetMOD(1LL * w * Pow(GetMOD(1LL * p * w % MOD + 1), n) % MOD - Pow(p + 1, n) + MOD) * Inv(w - 1) % MOD);
		w = 1LL * w * G % MOD;
	}
	ans = 1LL * ans * Inv(k) % MOD;
	ans = GetMOD(ans - Pow(p + 1, n) + MOD);
	printf("%d\n", ans);
	return 0;
}

---

快速沃尔什变换

$\mathrm{FWT}$，又称废物树，主要用于处理子集之间的关系。

用例题来讲：

给定两个长度为 $2^n$ 的数组 $A,B$，设：
$$C_i=\sum _{j\otimes k=i}{A}_j\cdot B_k$$
求当 $\otimes$ 为 $\mathrm{or},\mathrm{and},\mathrm{xor}$ 时的 $C$。$(n\le 17)$

解法：

对于 $\mathrm{or}$，我们考虑构造 $F_i^{\prime }={\sum }_{j\mathrm{or}i=i}{F}_j$。

为什么要这样构造？

因为有：
$$\begin{array}{rl}{A}^{\prime }\times B^{\prime }& =\sum _{j\mathrm{or}i=i}{A}_j\sum _{k\mathrm{or}i=i}{B}_k\\ & =\sum _{j\mathrm{or}i=i}\sum _{k\mathrm{or}i=i}{A}_j{B}_k\\ & =\sum _{(j\mathrm{or}k)\mathrm{or}i=i}{A}_j{B}_k\\ & =C^{\prime }\end{array}$$
现在我们考虑如何将 $A\to A^{\prime }$。

其实就是一个类似 $\mathrm{CDQ}$ 分治的思想。

可以发现，在原数组的基础上，每一个数都会对自己二进制表示下的真超集造成贡献，而真超集的特点在于：至少存在一位，满足本身为 $0$ 而超集为 $1$。

所以做法就很显然了：我们类似快速傅里叶变换的递归过程，从大到小枚举位数，把该位上为 $0$ 的位置贡献到该位为 $1$ 位置。

而逆变换怎么办呢？直接减回来呗。

可以发现两个变换可以合并：

inline void Or(int *f, int t = 1)
{
	for(register int len = 2; len <= n; len <<= 1)
	{
		int k = len >> 1;
		for(register int i = 0; i < n; i += len)
			for(register int j = 0; j < k; j++) 
				f[i + j + k] = GetMOD(f[i + j + k] + GetMOD(1LL * f[i + j] * t % MOD));
	}
	return;
}

与的构造和变换同理：

inline void And(int *f, int t = 1)
{
	for(register int len = 2; len <= n; len <<= 1)
	{
		int k = len >> 1;
		for(register int i = 0; i < n; i += len)
			for(register int j = 0; j < k; j++)
				f[i + j] = GetMOD(f[i + j] + GetMOD(1LL * f[i + j + k] * t % MOD));
	}
	return;
}

异或的变换就有点麻烦了，因为存在交叉贡献。

我们定义 $a\otimes b=\mathrm{popcount}(a\mathrm{and}b)\mathrm{m}\mathrm{o}\mathrm{d}2$，其中 $\mathrm{popcount}(k)$ 表示 $k$ 在二进制下 $1$ 的个数。

那么我们存在一个性质：$(i\otimes j)\mathrm{xor}(i\otimes k)=i\otimes (j\mathrm{xor}k)$。

证明的话，考虑化原式为 $\mathrm{popcount}(i\mathrm{and}j)+\mathrm{popcount}(i\mathrm{and}k)\equiv \mathrm{popcnt}(i\mathrm{and}(j\mathrm{xor}k))$，然后按位分讨即可，这里就不详细写了。

然后我们构造 $F_i^{\prime }={\sum }_{i\otimes j=0}{F}_j-{\sum }_{i\otimes j=1}{F}_j$。

那么有：
$$\begin{array}{rl}{A}^{\prime }\times B^{\prime }& =(\sum _{i\otimes j=0}{A}_j-\sum _{i\otimes j=1}{A}_j)(\sum _{i\otimes k=0}{B}_k-\sum _{i\otimes k=1}{B}_k)\\ & =(\sum _{i\otimes j=0}{A}_j)(\sum _{i\otimes k=0}{B}_k)-(\sum _{i\otimes j=0}{A}_j)(\sum _{i\otimes k=1}{B}_k)-(\sum _{i\otimes j=1}{A}_j)(\sum _{i\otimes k=0}{B}_k)+(\sum _{i\otimes j=1}{A}_j)(\sum _{i\otimes k=1}{B}_k)\\ & =\sum _{i\otimes (j\mathrm{xor}k)=0}{A}_j{B}_k-\sum _{i\otimes (j\mathrm{xor}k)=1}{A}_j{B}_k\\ & =C^{\prime }\end{array}$$
现在的问题就在于计算贡献。

还是考虑从小到大枚举每一位 $i$。

我们设 $F_j^{\prime }$ 为枚举到的位置 $j$ 的 $F^{\prime }$ 的值，$F_{j_0}^{\prime }$ 表示的是 $j$ 的前 $i-1$ 位和第 $i$ 位的 $0$ 组成的数的 $F^{\prime }$ 值，$F_{j_1}^{\prime }$ 同理。（注意前面的 $F_j^{\prime }$ 是要求的，后面的 $F_{j_0}^{\prime },F_{j_1}^{\prime }$ 是已经求出来的）

对于第 $i$ 位本身就为 $0$ 的位置，在 $\mathrm{and}$ 意义下这一位必然为 $0$，所以这个位置的贡献等于 $j$ 在前 $i-1$ 位所对应的两个位置的数值和，即 $F_j^{\prime }=F_{j_0}^{\prime }+F_{j_1}^{\prime }$。

对于第 $i$ 位为 $1$ 的位置，显然 $j$ 对应的第 $i$ 位为 $0$ 的位置会对其产生正贡献，第 $i$ 位为 $1$ 的位置会对其产生负贡献，所以 $F_j^{\prime }=F_{j_0}^{\prime }-F_{j_1}^{\prime }$。

如果你学过小学奥数就可以发现就是在原来的基础上乘上了一个 $\frac{1}{2}$。

inline void Xor(int *f, int t = 1)
{
	for(register int len = 2; len <= n; len <<= 1)
	{
		int k = len >> 1;
		for(register int i = 0; i < n; i += len)
			for(register int j = 0; j < (len >> 1); j++)
			{
				f[i + j] = GetMOD(f[i + j] + f[i + j + k]);
				f[i + j + k] = GetMOD(f[i + j] - f[i + j + k] * 2LL % MOD + MOD);
				f[i + j] = 1LL * f[i + j] * t % MOD, f[i + j + k] = 1LL * f[i + j + k] * t % MOD;
			}
	}
	return;
}

贴上完整代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>

#define MAXN 200005
#define MOD 998244353
#define Inv2 499122177

using namespace std;

int n, A[MAXN], B[MAXN], a[MAXN], b[MAXN];

inline int GetMOD(int k) { if(k >= MOD) k -= MOD; return k; }
inline void Copy() { return memcpy(a, A, sizeof A), memcpy(b, B, sizeof B), void(); }
inline void Multiply() { for(register int i = 0; i < n; i++) a[i] = 1LL * a[i] * b[i] % MOD; return; }
inline void Output() { for(register int i = 0; i < n; i++) printf("%d ", a[i]); return putchar('\n'), void(); }

inline void Or(int *f, int t = 1)
{
	for(register int len = 2; len <= n; len <<= 1)
	{
		int k = len >> 1;
		for(register int i = 0; i < n; i += len)
			for(register int j = 0; j < k; j++) 
				f[i + j + k] = GetMOD(f[i + j + k] + GetMOD(1LL * f[i + j] * t % MOD));
	}
	return;
}

inline void And(int *f, int t = 1)
{
	for(register int len = 2; len <= n; len <<= 1)
	{
		int k = len >> 1;
		for(register int i = 0; i < n; i += len)
			for(register int j = 0; j < k; j++)
				f[i + j] = GetMOD(f[i + j] + GetMOD(1LL * f[i + j + k] * t % MOD));
	}
	return;
}

inline void Xor(int *f, int t = 1)
{
	for(register int len = 2; len <= n; len <<= 1)
	{
		int k = len >> 1;
		for(register int i = 0; i < n; i += len)
			for(register int j = 0; j < (len >> 1); j++)
			{
				f[i + j] = GetMOD(f[i + j] + f[i + j + k]);
				f[i + j + k] = GetMOD(f[i + j] - f[i + j + k] * 2LL % MOD + MOD);
				f[i + j] = 1LL * f[i + j] * t % MOD, f[i + j + k] = 1LL * f[i + j + k] * t % MOD;
			}
	}
	return;
}

int main()
{
	scanf("%d", &n), n = (1 << n);
	for(register int i = 0; i < n; i++) scanf("%d", A + i);
	for(register int i = 0; i < n; i++) scanf("%d", B + i);
	Copy(), Or(a), Or(b), Multiply(), Or(a, MOD - 1), Output();
	Copy(), And(a), And(b), Multiply(), And(a, MOD - 1), Output();
	Copy(), Xor(a), Xor(b), Multiply(), Xor(a, Inv2), Output();
	return 0;
}

---

有了 $\mathrm{FWT}$，我们还可以做一件事情——子集卷积：

给定序列 $A$ 和 $B$，序列 $C$ 满足：
$$C_k=\sum _{i\mathrm{and}j=0,i\mathrm{or}j=k}{A}_i{B}_j$$
求出 $C$。

题解：

对于限制 $i\mathrm{or}j=k$，废物树可以直接干。

对于限制 $i\mathrm{and}j=0$，我们发现可以转化为 $|i|+|j|=|i\mathrm{and}j|$。

所以，我们对每个集合大小跑一遍 $\mathrm{FWT}$，然后计算的时候同时用两层循环枚举集合大小即可，最后再跑 $\mathrm{IFWT}$。

代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>

#define FILE

#define Bitcnt(k) __builtin_popcount(k)

#define MAXN 2000005
#define MAXLOG 21
#define MOD 1000000009

using namespace std;

int n, m, a[MAXLOG][MAXN], b[MAXLOG][MAXN], c[MAXLOG][MAXN];

inline int GetMOD(int k) { if(k >= MOD) k -= MOD; return k; }

inline void FWT(int *f, int t = 1)
{
	for(register int len = 2; len <= m; len <<= 1)
	{
		int k = len >> 1;
		for(register int i = 0; i < m; i += len)
			for(register int j = 0; j < k; j++)
				f[i + j + k] = GetMOD(f[i + j + k] + 1LL * f[i + j] * t % MOD);
	}
	return;
}

int main()
{
	scanf("%d", &n), m = (1 << n);
	for(register int i = 0; i < m; i++) scanf("%d", &a[Bitcnt(i)][i]);
	for(register int i = 0; i < m; i++) scanf("%d", &b[Bitcnt(i)][i]);
	for(register int i = 0; i <= n; i++) FWT(a[i]), FWT(b[i]);
	for(register int i = 0; i <= n; i++)
		for(register int j = 0; j <= i; j++)
			for(register int k = 0; k < m; k++) c[i][k] = GetMOD(c[i][k] + 1LL * a[j][k] * b[i - j][k] % MOD);
	for(register int i = 0; i <= n; i++) FWT(c[i], MOD - 1);
	for(register int i = 0; i < m; i++) printf("%d ", c[Bitcnt(i)][i]);
	return 0;
}

---

子集反演

实际上，子集反演的前置知识就是上面提到的废物树和子集卷积。

它其实就是类似这样的一个式子：
$$F(S)=\sum _{T\subset S}G(T)\iff G(S)=\sum _{T\subset S}(-1{)}^{|S-T|}F(T)$$

---

例题

我们设 $F(S)$ 为有多少种方案使得玩具的集合是 $S$ 的子集，设 $f(S)$ 为有多少个盒子的玩具集合是 $S$ 的子集，那么显然有 $F(S)=2^{f(S)}-1$（减不减 $1$ 无所谓，反正最后会容斥掉）。再设 $G(S)$ 为有多少种方案使得玩具集合恰好为 $S$，那么可以直接套用上面的子集反演公式。

（事实上，大多数计数题也用到了这个设置状态的思路，即设置 “至少”、“至多” 和 “恰好”。）

然后考虑求 $f(S)$，可以发现这就是一个废物树的变换，直接套上即可。

（这里提一句，$f(S)$ 实际上称作高维前缀和，而这种用 $\mathrm{FWT}$ 优化其的方法称做 $sos\_dp$，又叫求救优化。）

贴上代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>

#define MAXN 2000005
#define MAXM 21
#define MOD 1000000007

using namespace std;

int n, m, f[MAXN], F[MAXN], ans;

inline int GetMOD(int k) { if(k >= MOD) k -= MOD; return k; }
inline int Bitcnt(int k) { return __builtin_popcount(k); }

inline void FWT(int *f)
{
	for(register int len = 2; len <= (1 << m); len <<= 1)
	{
		int k = len >> 1;
		for(register int i = 0; i < (1 << m); i += len)
			for(register int j = 0; j < k; j++)
				f[i + j + k] = GetMOD(f[i + j + k] + f[i + j]);
	}
	return;
}

inline int Pow(int k, int p)
{
	int res = 1;
	while(p)
	{
		if(p & 1) res = 1LL * res * k % MOD;
		k = 1LL * k * k % MOD;
		p >>= 1;
	}
	return res;
}

int main()
{
	scanf("%d%d", &n, &m);
	for(register int i = 1; i <= n; i++)
	{
		int ki; scanf("%d", &ki);
		int st = 0;
		for(register int j = 1; j <= ki; j++)
		{
			int t; scanf("%d", &t);
			st |= (1 << (t - 1));
		}
		++f[st];
	}
	FWT(f);
	for(register int i = 0; i < (1 << m); i++) F[i] = Pow(2, f[i]) - 1;
	for(register int i = 0; i < (1 << m); i++)
	{
		if(Bitcnt(((1 << m) - 1) ^ i) & 1) ans = GetMOD(ans - F[i] + MOD);
		else ans = GetMOD(ans + F[i]);
	}
	printf("%d\n", ans);
	return 0;
}

---

$ToBeContinued\cdots \cdots$