FWT (快速沃尔什变换) 学习笔记

一、FWT 与位运算卷积

非常牛逼的东西

SOSDP（Sum over Subsets DP）

这东西理解成按位做 $dp$ 就行，用于处理与位运算有关的贡献问题，使用条件是 贡献在每一位上独立，或者可以通过记录到状态里使得每一位独立

实际应用非常灵活，毕竟是 $dp$ 嘛

 

FWT

对于下标为 $[0,2^n-1]$ 的两个数组 $A,B$，定义它们的位运算卷积为 $C_k=\sum _{i\otimes j=k}{A}_i\times B_j$，其中 $\otimes$ 是某种位运算，记作 $C=A\otimes B$

暴力做是 $4^n$，想要加快这个过程，我们类比优化多项式卷积的思路，希望将 $A,B$ 数组进行某种变换后得到 $A^{\prime },B^{\prime }$，满足 $C_k^{\prime }=A_k^{\prime }\cdot B_k^{\prime }$，然后再通过某种方式将 $C^{\prime }$ 还原为 $C$

记这个变换为 $FWT(A)$，定义 $FWT(A{)}_i=\sum _{j=0}^{2^n-1}{A}_{j}f(i,j)$，其中 $f(i,j)$ 表示原数组 $A$ 的第 $j$ 项在自变量取 $i$ 时的贡献方式 (特别的，我们会发现当 $f(i,j)=i^j$ 时，恰好就是我们所熟悉的多项式点值)

我们希望这个变换能够用来加速卷积，符合上面的条件，即 $FWT(A\otimes B)=FWT(A)\cdot FWT(B)$，同时我们希望它是一个线性变换，即 $FWT(A+B)=FWT(A)+FWT(B)$  $FWT(kA)=kFWT(A)$

想要满足第一个式子，$f(i,j)$ 需要满足 $f(i,j)f(i,k)=f(i,j\otimes k)$，以下是推导：

$$\forall i,FWT(A\otimes B{)}_i=FWT(A{)}_i\cdot FWT(B{)}_i$$
$$\sum _{s=0}^{2^n-1}(f(i,s)\times \sum _{p\otimes q=s}{A}_p{B}_q)=(\sum _{j=0}^{2^n-1}{A}_{j}f(i,j))(\sum _{k=0}^{2^n-1}{B}_{k}f(i,k))$$
$$\sum _{s=0}^{2^n-1}(f(i,s)\times \sum _{p\otimes =s}{A}_p{B}_q)=\sum _j\sum _k{A}_j{B}_{k}f(i,j)f(i,k)$$
与左边对照
$$\sum _{s=0}^{2^n-1}(f(i,s)\times \sum _{p\otimes =s}{A}_p{B}_q)=\sum _{s=0}^{2^n-1}\sum _{j\otimes k=s}{A}_j{B}_{k}f(i,j)f(i,k)$$

只要满足 $f(i,s)=f(i,j)f(i,k)$ 即可，即 $f(i,j\oplus k)=f(i,j)f(i,k)$

注意以上推导没有用到任何位运算的性质，对所有卷积都是适用的

现在还是无法快速求出 $FWT(A)$，我们考虑给 $f(i,j)$ 加上一些位运算的性质：

要求 $f(i,j)={\prod }_{k=0}^{n-1}f(i_k,j_k)$，其中 $i_k$ 表示二进制中 $i$ 第 $k$ 位上的值

接下来就可以分治计算 $FWT(A)$ 了

$FWT(A{)}_i=\sum _{j=0}^{2^n-1}{A}_{j}f(i,j)$

注意到去掉最高位之后两部分与原问题完全一致，设 $c$ 为 $i$ 最高为的值，$i^{\prime },j^{\prime }$ 为去掉最高为剩下的值

$=f(c,0)\sum _{j=0}^{2^{n-1}-1}{A}_{j}f(i^{\prime },j^{\prime })+f(c,1)\sum _{j=2^{n-1}}^{2^n-1}{A}_{j}f(i^{\prime },j^{\prime })$

递归求解即可

这样我们就求出了 $FWT(A\otimes B)$。接下来考虑它的逆变换，注意到 $FWT$ 的过程可以看作是把 $A$ 数组乘上 $f$ 矩阵，那么逆变换只需要把 $f$ 变成其对应的逆矩阵就好了。

也就是说，$FWT$ 适用于优化卷积的条件是该位运算满足 $f(i,j)f(i,k)=f(i,j\oplus k)$ 且 $f$ 有逆矩阵

复杂度为 $O(n{2}^n)$

基础位运算卷积

or 卷积

即 $C_k=\sum _{i|j=k}{A}_i\times B_j$

$C=A|B$，$f(i,j)f(i,k)=f(i,j|k)$，注意到 $j|k$ 是 $i$ 的子集当且仅当 $k$ 为 $i$ 子集 且 $j$ 为 $i$ 子集

那么构造矩阵 $f(i,j)=[j\subset i]$
$$\left[\begin{array}{cc}1& 0\\ 1& 1\end{array}\right]$$

左继承，右加左

逆矩阵为
$$\left[\begin{array}{cc}1& 0\\ -1& 1\end{array}\right]$$
左不变，右减左

and 卷积

即 $C_k=\sum _{i\&j=k}{A}_i\times B_j$

$f(i,j)f(i,k)=f(i,j\&k)$, $i$ 是 $j\&k$ 的子集当且仅当 $i$ 是 $j$ 的子集 且 $i$ 是 $k$ 的子集

构造矩阵 $f(i,j)=[i\subset j]$

$$\left[\begin{array}{cc}1& 1\\ 0& 1\end{array}\right]$$

逆矩阵为
$$\left[\begin{array}{cc}1& -1\\ 0& 1\end{array}\right]$$

xor 卷积

$f(i,j)f(i,k)=f(i,j\stackrel{ˆ}{}k)$

需要一些观察，构造 $f(i,j)=(-1{)}^{|i\&j|}$，因为 $(-1{)}^{|i\&j|+|i\&k|}=(-1{)}^{|i\&(j\stackrel{ˆ}{}k)|}$，若 $i$ 这一位为 $0$，两边都没有贡献；否则只有 $j,k$ 不同才有贡献，符合 $xor$ 性质

构造：
$$\left[\begin{array}{cc}1& 1\\ 1& -1\end{array}\right]$$

逆矩阵为
$$\left[\begin{array}{cc}\frac{1}{2}& -\frac{1}{2}\\ \frac{1}{2}& \frac{1}{2}\end{array}\right]$$

代码实现

#include
using namespace std ;

typedef long long LL ;
const int N = 17 , mod = 998244353 ;

int n ;
LL a[1<<N] , b[1<<N] , A[1<<N] , B[1<<N] ; 
void FWT_OR( LL *f )
{
	for(int i = 1 ; i <= n ; i ++ ) {
		int p = (1<<(i-1)) ;
		for(int j = 0 ; j < (1<<n) ; j += (1<<i) ) {
			for(int k = 0 ; k < p ; k ++ ) {
				f[j+k+p] = ( f[j+k+p] + f[j+k] ) % mod ;
			}
		}
	}
}
void IFWT_OR( LL *f )
{
	for(int i = 1 ; i <= n ; i ++ ) {
		int p = (1<<(i-1)) ;
		for(int j = 0 ; j < (1<<n) ; j += (1<<i) ) {
			for(int k = 0 ; k < p ; k ++ ) {
				f[j+k+p] = ( f[j+k+p] - f[j+k] ) % mod ;
			}
		}
	}
}
void FWT_AND( LL *f )
{
	for(int i = 1 ; i <= n ; i ++ ) {
		int p = (1<<(i-1)) ;
		for(int j = 0 ; j < (1<<n) ; j += (1<<i) ) {
			for(int k = 0 ; k < p ; k ++ ) {
				f[j+k] = ( f[j+k] + f[j+k+p] ) % mod ;
			}
		}
	}
}
void IFWT_AND( LL *f )
{
	for(int i = 1 ; i <= n ; i ++ ) {
		int p = (1<<(i-1)) ;
		for(int j = 0 ; j < (1<<n) ; j += (1<<i) ) {
			for(int k = 0 ; k < p ; k ++ ) {
				f[j+k] = ( f[j+k] - f[j+k+p] ) % mod ;
			}
		}
	}
}
void FWT_XOR( LL *f )
{
	for(int i = 1 ; i <= n ; i ++ ) {
		int p = (1<<(i-1)) ;
		for(int j = 0 ; j < (1<<n) ; j += (1<<i) ) {
			for(int k = 0 ; k < p ; k ++ ) {
				LL a = f[j+k] , b = f[j+k+p] ;
				f[j+k] = (a+b)%mod ;
				f[j+k+p] = (a-b)%mod ;
			}
		}
	}
}
const LL inv2 = (mod+1)/2 ;
void IFWT_XOR( LL *f )
{
	for(int i = 1 ; i <= n ; i ++ ) {
		int p = (1<<(i-1)) ;
		for(int j = 0 ; j < (1<<n) ; j += (1<<i) ) {
			for(int k = 0 ; k < p ; k ++ ) {
				LL a = f[j+k] , b = f[j+k+p] ;
				f[j+k] = (a+b)*inv2%mod ;
				f[j+k+p] = (a-b)*inv2%mod ;
			}
		}
	}
}

int main()
{
	scanf("%d" , &n ) ;
	for(int i = 0 ; i < (1<<n) ; i ++ ) scanf("%lld" , &A[i] ) ;
	for(int i = 0 ; i < (1<<n) ; i ++ ) scanf("%lld" , &B[i] ) ;
	memcpy(a,A,sizeof a) ; memcpy(b,B,sizeof b) ;
	FWT_OR(a) ; FWT_OR(b) ;
	for(int i = 0 ; i < (1<<n) ; i ++ ) a[i] = a[i]*b[i]%mod ;
	IFWT_OR(a) ;
	for(int i = 0 ; i < (1<<n) ; i ++ ) printf("%lld " , (a[i]+mod)%mod ) ;
	printf("\n") ;
	
	memcpy(a,A,sizeof a) ; memcpy(b,B,sizeof b) ;
	FWT_AND(a) ; FWT_AND(b) ;
	for(int i = 0 ; i < (1<<n) ; i ++ ) a[i] = a[i]*b[i]%mod ;
	IFWT_AND(a) ;
	for(int i = 0 ; i < (1<<n) ; i ++ ) printf("%lld " , (a[i]+mod)%mod ) ;	
	printf("\n") ;
	
	memcpy(a,A,sizeof a) ; memcpy(b,B,sizeof b) ;
	FWT_XOR(a) ; FWT_XOR(b) ;
	for(int i = 0 ; i < (1<<n) ; i ++ ) a[i] = a[i]*b[i]%mod ;
	IFWT_XOR(a) ;
	for(int i = 0 ; i < (1<<n) ; i ++ ) printf("%lld " , (a[i]+mod)%mod ) ;	
	printf("\n") ;
	return 0 ;
}

拓展操作

K 进制卷积

推导过程没什么区别，问题在于构造 $f$ 矩阵

FWT and

定义 $K$ 进制下 $and$ 运算为 $i\&j=\max (i,j)$，本质上是高维后缀和

转移矩阵： [ 1 1 1 . . . 1 0 1 1 . . . 1 0 0 1 . . . 1 ⋮ ⋮ ⋮ ⋱ ⋮ 0 0 0 . . . 1 ] \large\begin{bmatrix} 1 & 1 &1 &... &1 \\ 0 & 1 &1 &... &1 \\ 0 & 0 &1 &... &1 \\ \vdots &\vdots&\vdots&\ddots &\vdots \\ 0 & 0 & 0 & ... &1 \end{bmatrix} ​100⋮0​110⋮0​111⋮0​.........⋱...​111⋮1​ ​

 

FWT or

$i|j=\min (i,j)$，本质上是高维前缀和

转移矩阵： [ 1 0 0 . . . 0 1 1 0 . . . 0 1 1 1 . . . 0 ⋮ ⋮ ⋮ ⋱ ⋮ 1 1 1 . . . 1 ] \large\begin{bmatrix} 1 & 0 &0 &... &0 \\ 1 & 1 &0 &... &0 \\ 1 & 1 &1 &... &0 \\ \vdots &\vdots&\vdots&\ddots &\vdots \\ 1 & 1 & 1 & ... &1 \end{bmatrix} ​111⋮1​011⋮1​001⋮1​.........⋱...​000⋮1​ ​

FWT xor

定义 $i\oplus j=(i+j)\mathrm{mod}K$，要求 $f(i,j)f(i,k)=f(i,(j+k)\%K)$

注意到单位根有类似的周期性质，发现只需令 $f(i,j)=w_K^j$ 即可满足上式

但这样会导致矩阵每一行都一样，没有逆，所以我们再钦定一手 $f(i,j)=w_K^{ij}$

那么矩阵： [ 1 1 1 . . . 1 1 w K 1 w K 2 . . . w K K − 1 1 w K 2 w K 4 . . . w K 2 ( K − 1 ) ⋮ ⋮ ⋮ ⋱ ⋮ 1 w K K − 1 w K ( K − 1 ) 2 . . . w K ( K − 1 ) ( K − 1 ) ] \begin{bmatrix} 1 & 1 &1 &... &1 \\ 1 & w_K^1 &w_K^2 &... &w_K^{K-1} \\ 1 & w_K^2 &w_K^4 &... &w_K^{2(K-1)} \\ \vdots &\vdots&\vdots&\ddots &\vdots \\ 1 & w_K^{K-1} &w_K^{(K-1)2} &... &w_K^{(K-1)(K-1)} \end{bmatrix} ​111⋮1​1wK1​wK2​⋮wKK−1​​1wK2​wK4​⋮wK(K−1)2​​.........⋱...​1wKK−1​wK2(K−1)​⋮wK(K−1)(K−1)​​ ​

这不就和我们在 FFT 中见到的矩阵一模一样吗？它就是 范德蒙德矩阵，其逆为：

1 K [ 1 1 1 . . . 1 1 1 / w K 1 1 / w K 2 . . . 1 / w K K − 1 1 1 / w K 2 1 / w K 4 . . . 1 / w K 2 ( K − 1 ) ⋮ ⋮ ⋮ ⋱ ⋮ 1 1 / w K K − 1 1 / w K ( K − 1 ) 2 . . . 1 / w K ( K − 1 ) ( K − 1 ) ] \frac{1}{K}\begin{bmatrix} 1 & 1 &1 &... &1 \\ 1 & 1/w_K^1 &1/w_K^2 &... &1/w_K^{K-1} \\ 1 & 1/w_K^2 &1/w_K^4 &... &1/w_K^{2(K-1)} \\ \vdots &\vdots&\vdots&\ddots &\vdots \\ 1 & 1/w_K^{K-1} &1/w_K^{(K-1)2} &... &1/w_K^{(K-1)(K-1)} \end{bmatrix} K1​ ​111⋮1​11/wK1​1/wK2​⋮1/wKK−1​​11/wK2​1/wK4​⋮1/wK(K−1)2​​.........⋱...​11/wKK−1​1/wK2(K−1)​⋮1/wK(K−1)(K−1)​​ ​

 

二、集合幂级数

（注：以下内容并非严谨的定义，只是笔者为了方便理解而使用的一些类比）

（多数是参考了这篇 blog）

一种比较简单的理解方式：集合幂级数就是以某个全集 $U$ 的所有子集 $2^U$ 为定义域，以集合为自变量，映射到另一个域（oi 中通常研究的是对某个大质数取模后的整数域）的函数。把 $U$ 的每个子集 $S$ 带入函数，均有对应取值 $f_S$

我们考虑如何表示一个集合幂级数，首先给每个集合 $S$ 对应的取值 $f_S$ 后添加占位符 $x^S$，记作 $f_S{x}^S$， 表示当且仅当 $x=S$ 时，返回值为 $f_S$，否则为 $0$。也就是说，我们记 $f=\sum _{S\subset 2^U}{f}_S{x}^S$

接下来定义集合幂级数的运算

加法很好理解，直接把同类项系数相加即可，当然进行加法运算的两个集合幂级数需要保证全集相同

对于乘法，考虑集合幂级数 $h=f\cdot g=(\sum _{L\subset U}{f}_L{x}^L)(\sum _{R\subset U}{g}_R{x}^R)$

很自然的，我们希望这种运算也具有分配律，那么 $h=\sum _{L,R}(f_L\times g_R)x^{L\ast R}$

其中第一个 $\times$ 是我们熟知的整数域上的运算，直接把对应系数相乘；而 $L\ast R$ 则是在 $2^U$ 上的二元运算，它决定了 集合之间的贡献方式，类型不唯一，常见的有 并卷积，对称差卷积，子集卷积，分别对应位运算中的 或卷积，异或卷积，子集卷积

子集卷积

由于前两种运算与上文的位运算卷积没有很大的区别，我们重点看第三种 —— 子集卷积

这种二元运算形式化的定义是： $x^L\cdot x^R=\{\begin{array}{cc}0& (L\cap R\ne \varnothing )\\ x^{L\cup R}& (L\cap R=\varnothing )\end{array}$

那么我们求的就是 $$h_S=\sum _{L\subset 2^U}\sum _{R\subset 2^U}[L\cup R=S][L\cap R=\varnothing ]f_L{g}_R$$

暴力的子集枚举复杂度是 $O(3^n)$，我们考虑更好的做法

注意力惊人的发现当 $L\cup R=S$ 时，$L\cap R=\varnothing$ 等价于 $|L|+|R|=|S|$，我们考虑设 $F_{i,s}=[|s|=i]f_s$，同理有 $G_{i,s},H_{i,s}$

可以得到：$$H_i=\sum _{j+k=i}{F}_j\otimes G_k$$其中 $\otimes$ 是集合并卷积，对两边同取 $FWT$ 得到：

$$FWT(H_i{)}_s=\sum _{j+k=i}FWT(F_j{)}_s\times FWT(G_k{)}_s$$发现这就是普通的乘法卷积，对每个 $s$ 暴力 $n^2$ 卷积即可，最后 $IFWT$ 还原

复杂度是 $O(n^2{2}^n)$

半在线子集卷积

实际题目中我们遇到的 $dp$ 转移式更多是这样：

$f_s=\sum _{t\subset s}{f}_t{g}_{s/t}$

称这种转移为半在线子集卷积

注意到我们做子集卷积时本身就有按 $|s|$ 大小的顺序，直接从小往大做就行

• P4221 [WC2018] 州区划分
  基本是半在线子集卷积板子题，注意 需要微调转移式使得参与卷积的两部分独立

• P11734 [集训队互测 2015] 胡策的统计
  感觉又是很神秘的技巧，经常会遇到这种 为了确保顺序在转移时钦定枚举的子集 $t$ 要包含 $s$ 中最小的元素
  这种怎么子集卷积优化呢？首先把钦定最小改成钦定最大方便一点，然后注意到 只有最高位相同的 $f$ 才会互相转移，在外层枚举一个最高位 $id$，接下来对 $2^{id}$ 的部分跑正常的子集卷积，复杂度 $\sum i^2{2}^i$ ，还是 $O(n^2{2}^n)$

  for(int id = 0 ; id < n ; id ++ ) {//最大值所在位 
  	for(int i = 0 ; i <= id ; i ++ ) {
  		for(int s = 0 ; s < (1<<id) ; s ++ ) {
  			if( i == num[s] ) G[i][s] = pw2[E[s]] ;
  			else G[i][s] = 0 ;
  			F[i][s] = 0 ;
  		}
  	}
  	for(int i = 0 ; i <= id ; i ++ ) fwt(G[i],id) ;
  	for(int i = 0 ; i <= id ; i ++ ) {
  		if( i == 0 ) {
  			dp[(1<<id)] = 1 ;
  			for(int s = 0 ; s < (1<<id) ; s ++ ) F[i][s] = 1 ;
  		}
  		else {
  			for(int j = 0 ; j < i ; j ++ ) {
  				for(int s = 0 ; s < (1<<id) ; s ++ ) {
  					F[i][s] = ( F[i][s] + 1LL*F[j][s]*G[i-j][s] ) % mod ;
  				}
  			}
  			ifwt(F[i],id) ;
  			for(int s = 0 ; s < (1<<id) ; s ++ ) {
  				if( num[s]==i ) {
  					F[i][s] = ( pw2[E[s^(1<<id)]] - F[i][s] + mod ) % mod ;
  					dp[s^(1<<id)] = F[i][s] ;
  				}
  			}
  			fwt(F[i],id) ;
  		}
  	}
  }
  

 

进阶操作

既然它也叫幂级数，那自然也有全家桶啦

exp

设 $f$ 是一个集合幂级数，定义 $\exp (f)=\sum _{i\ge 0}\frac{f^i}{i!}$，为了避免不收敛我们规定 $[x^{\varnothing }]f=0$

通常这里的乘法定义都是子集卷积，以此为例来说明一下做法：

设 $g=\exp (f)$，同时定义它们的占位多项式为 $F,G$

$$g=\sum _{i\ge 0}\frac{f^i}{i!}$$
$$G_j=\sum _{i\ge 0,\sum a_k=j}\frac{F_{a_1}\otimes F_{a_2}...F_{a_i}}{i!}$$

同取 $FWT$：

$$FWT(G_j{)}_s=\sum _{i\ge 0,\sum a_k=j}\frac{FWT(F_{a_1}{)}_s\times FWT(F_{a_2}{)}_s...FWT(F_{a_i}{)}_s}{i!}$$

容易发现此时固定一个 $s$ 后，等式右边就是一个形式幂级数 $\exp$

难道我们还需要写 $O(n\log n)$ 的 NTT 吗？这很愚蠢啊，$n$ 这么小考虑 $n^2$ 暴力

哎，怎么 $n^2$ 求 $\exp$ 呢？

---

设 $G(x)=\exp (F(x))$，两边同时对 $x$ 求导：

$$G(x{)}^{\prime }=\exp (F(x))F^{\prime }(x)$$

$$G(x{)}^{\prime }=G(x)F^{\prime }(x)$$

展开：

$$\forall i\ge 0,[x^i]G^{\prime }=\sum _{j\le i}[x^j]G\times [x^{i-j}]F^{\prime }$$

$$(i+1)[x^{i+1}]G=\sum _{j\le i}[x^j]G\times (i-j+1)[x^{i-j+1}]F$$

即：

$$\forall i\ge 1,[x^i]G=\frac{1}{i}\sum _{j<i}[x^j]G\times (i-j)[x^{i-j}]F$$

显然 $[x^0]G=1$，然后就可以递推啦，复杂度就是 $O(n^2)$

---

接上文，如果把 $i$ 这一维看成行，$s$ 这一维看成列，我们做的操作实际上是 先对每一行 $fwt$，再对每一列做 $\exp$，最后再对每行 $ifwt$ 回来

for(int i = 0 ; i <= m ; i ++ ) {//每行fmt
	fmt(F[i]) ;
}
for(int s = 0 ; s < (1<<m) ; s ++ ) {//对每列做 m^2 exp 
	G[0][s] = 1 ;//规定，否则会出问题 
	for(int i = 1 ; i <= m ; i ++ ) {
		for(int j = 0 ; j < i ; j ++ ) {
			G[i][s] = ( G[i][s] + G[j][s]*F[i-j][s]%mod*(i-j) ) % mod ;
		}
		G[i][s] = G[i][s]*iv[i]%mod ;
	}
}
for(int i = 0 ; i <= m ; i ++ ) {
	ifmt(G[i]) ;
}

复杂度还是 $O(n^2{2}^n)$

例题 P6570 [NOI Online #3 提高组] 优秀子序列

 

ln

推导没有很大区别

设 $f$ 为一集合幂级数，定义 $\ln (f+1)=\sum _{i\ge 1}(-1{)}^{i-1}\frac{f^i}{i!}$，还是要求 $[x^{\varnothing }]f=0$（这里 $+1$ 指的是集合幂级数的单位元，这是为了让它在 $0$ 处能展开）

设 $g=\ln (f+1)$，同理得到：$$FWT(G_j{)}_s=\sum _{i\ge 0,\sum a_k=j}(-1{)}^{i-1}\frac{FWT(F_{a_1}{)}_s\times FWT(F_{a_2}{)}_s...FWT(F_{a_i}{)}_s}{i!}$$

还是考虑 $n^2$ 求 $\ln$

设 $G=\ln F$，两边求导得：

$$G^{\prime }=\frac{F^{\prime }}{F}$$

$$F^{\prime }=F{G}^{\prime }$$

$$\forall i\ge 0,[x^i]F^{\prime }=\sum _{j\le i}[x^j]F\times [x^{i-j}]G^{\prime }$$

$$(i+1)[x^{i+1}]F=\sum _{j\le i}[x^j]F\times (i-j+1)[x^{i-j+1}]G$$

$$\forall i\ge 1,[x^i]F=\frac{1}{i}\sum _{j<i}[x^j]F\times (i-j)[x^{i-j}]G$$

$$[x^i]F=\frac{1}{i}\sum _{1\le j\le i}[x^{i-j}]F\times j[x^j]G$$

取出 $j=i$ 这一项

$$[x^i]F=\frac{1}{i}\sum _{1\le j<i}[x^{i-j}]F\times j[x^j]G+[x^0]F\times [x^i]G$$

注意到 $\ln F$ 是良定义的当且仅当 $[x^0]F=1$，那么我们直接就能得到：

$$[x^i]G=[x^i]F-\frac{1}{i}\sum _{1\le j<i}[x^{i-j}]F\times j[x^j]G$$

这就可以愉快 $n^2$ 递推了

for(int s = 0 ; s < (1<<n) ; s ++ ) {// n^2 ln
	G[0][s] = 0 ;
	for(int i = 1 ; i <= n ; i ++ ) {
		for(int j = 1 ; j < i ; j ++ ) {
			G[i][s] = ( G[i][s] + 1LL*j*G[j][s]%mod*F[i-j][s] ) % mod ;
		}
		G[i][s] = ( F[i][s] - G[i][s]*inv[i] ) % mod ;
	}
}

注意这里求的是 $\ln (F+1)$

 

求逆

设 $f$ 为一集合幂级数，定义它的逆为使得 $f\otimes g=ϵ$ 的 $g$（ $ϵ$ 为集合幂级数单位元）

还是先对每行 $fmt$，然后每列求逆，最后 $ifmt$

$n^2$ 求逆：

假设已知 $F$，求它的逆 $G$，我们设 $f,g$ 表示它们的各项系数，有：

$$\sum _{i=0}^n{f}_i{g}_{n-i}=[n=0]$$

得到：$$g_i=\{\begin{array}{cc}\frac{1}{f_0}& i=0\\ -\frac{1}{f_0}\sum _{j<i}{g}_j{f}_{i-j}& i\ge 1\end{array}$$

例题：P11734 [集训队互测 2015] 胡策的统计，略微卡常

例题

#154. 集合划分计数

设 $F_s$ 表示 $s$ 有多少个，不难发现求的就是 $[x^U]\sum _{i\le k}\frac{F^i}{i!}$，乘法还是子集卷积

通过上面的几种经典操作，我们可以总结出求这种式子的一般思路：

• 转化为占位幂级数，用 $FMT$ 求出每一行点值
• 对每一列看成形式幂级数，借助求导找到 $n^2$ 递推式
• 最后 $IFMT$ 还原

重点在于第二步。设 $G=\sum _{i\le k}\frac{F^i}{i!}$，两边求导，得：

$$G^{\prime }=F^{\prime }\sum _{i\le k-1}\frac{F^i}{i!}$$

$$G^{\prime }=F^{\prime }\sum _{i\le k-1}\frac{F^i}{i!}$$

$$G^{\prime }=F^{\prime }(G-\frac{F^k}{k!})$$

这样只需要求一个 $F^k$ 就能递推了

求这个一般的想法是直接 $F^k=\exp (k\ln F)$，但需要注意这个做法只有当 $F$ 满足 $[x^{\varnothing }]F=1$ 才成立，否则会导致 $\ln$ 未定义

那还是借助求导，找递推式的思路，设 $G=F^k$，同求导：

$$G^{\prime }=k{F}^{k-1}{F}^{\prime }$$

配凑一下，两边同乘上 $F$：

$$G^{\prime }F=k{F}^k{F}^{\prime }$$

$$G^{\prime }F=kG{F}^{\prime }$$

又可以递推啦

写出来式子：

$$g_i=\frac{k\sum _{i=0}^n(i+1)f_{i+1}{g}_{n-i}-\sum _{i=0}^{n-1}(i+1)g_{i+1}{f}_{n-i}}{i{f}_0}$$

然后就发现，我 $f_0=0$ 还是做不了啊 ？！！

哎，别急，形式幂级数的运算肯定是更好做的，类比 这个题 中的技巧，我们找到 $f$ 低位第一个非 $0$ 的位置 $p$，以这个位置作为起点，同理 $g$ 以 $K\cdot p$ 作为起点进行递推就 ok 啦

#include
using namespace std ;

typedef long long LL ;
const int N = 21 , mod = 998244353 ;
LL ksm( LL a , LL b )
{
	LL res = 1 , t = a % mod ;
	while( b ) {
		if( b&1 ) res = res * t % mod ;
		b = b >> 1 ;
		t = t * t % mod ;
	}
	return res ;
}
int n , m , K , x , num[1<<N] ;
LL F[N+1][1<<N] , G[N+1][1<<N] , inv[N+1] ;
void fmt( LL *f )
{
	for(int i = 0 ; i < n ; i ++ ) {
		for(int s = 0 ; s < (1<<n) ; s ++ ) {
			if( s&(1<<i) ) {
				f[s] = ( f[s] + f[s^(1<<i)] ) % mod ;
			}
		}
	}
}
void ifmt( LL *f )
{
	for(int i = 0 ; i < n ; i ++ ) {
		for(int s = 0 ; s < (1<<n) ; s ++ ) {
			if( s&(1<<i) ) {
				f[s] = ( f[s] - f[s^(1<<i)] ) % mod ;
			}
		}
	}
}
void poly_pow( LL *f , int K , LL *g )
{
	int p = 0 ;
	while( !f[p] && p <= n ) p ++ ;
	if( p*K > n ) return ;
	LL *nf = f+p , *ng = g+K*p , inv0 = ksm(nf[0],mod-2) ;
	int nn = n-K*p ;
	ng[0] = ksm(nf[0],K) ;
	for(int i = 1 ; i <= nn ; i ++ ) {
		for(int j = 0 ; j < i ; j ++ ) {
			ng[i] = ( ng[i] + (j+1)*nf[j+1]%mod*ng[i-1-j] ) % mod ;
		}
		ng[i] = ng[i]*K%mod ;
		for(int j = 0 ; j < i-1 ; j ++ ) {
			ng[i] = ( ng[i] - (j+1)*ng[j+1]%mod*nf[i-1-j] ) % mod ;
		}
		ng[i] = ng[i]*inv[i]%mod*inv0%mod ;
	}
}

int main()
{
	scanf("%d%d%d" , &n , &m , &K ) ;
	LL ifc = 1 ;
	for(int i = 1 ; i <= K ; i ++ ) ifc = ifc*i%mod ;
	ifc = ksm(ifc,mod-2) ;	
	for(int s = 0 ; s < (1<<n) ; s ++ ) num[s] = num[s>>1]+(s&1) ;
	for(int i = 1 ; i <= m ; i ++ ) {
		scanf("%d" , &x ) ;
		F[num[x]][x] ++ ;
	}
	for(int i = 1 ; i <= n ; i ++ ) fmt(F[i]) , inv[i] = ksm(i,mod-2) ; 
	for(int s = 0 ; s < (1<<n) ; s ++ ) {
		LL H[N+1] = {} , T[N+1] = {} ;
		for(int i = 0 ; i <= n ; i ++ ) {
			H[i] = F[i][s] ;
		}
		poly_pow(H,K,T) ;
		for(int i = 0 ; i <= n ; i ++ ) T[i] = T[i]*ifc%mod ;
		G[0][s] = 1 ;
		for(int i = 1 ; i <= n ; i ++ ) {
			for(int j = 0 ; j < i ; j ++ ) {
				G[i][s] = ( G[i][s] + (G[j][s]-T[j])*(i-j)%mod*F[i-j][s] ) % mod ;
			}
			G[i][s] = G[i][s]*inv[i]%mod ;
		}
	}
	ifmt(G[n]) ;
	printf("%lld\n" , (G[n][(1<<n)-1]+mod)%mod ) ;
	return 0 ;
}

应用

（你可以说它没考过，但你不能否认它确实很有用，能做好多以前不敢想的东西）

[AGC034F] RNG and XOR

据说