斯特林的试炼

下面提到的内容均属组合数学范畴。

---

前言

由于式子较多，为增强直观性，笔者将一改以往的笔风，用 $\left(\genfrac{}{}{0ex}{}{n}{m}\right)$ 表示组合数 $C_n^m$。同理，笔者分别会用 $\left[\begin{array}{c}n\\ k\end{array}\right]$ 和 $\left\{\begin{array}{c}n\\ k\end{array}\right\}$ 表示第一类斯特林数 $s(n,k)$ 和第二类斯特林数 $S(n,k)$。

阅读这篇文章前，您需要较为熟练地掌握组合数、排列数（特别是圆排列）的定义和公式，以及常见的组合恒等式。

---

前置知识

上升幂和下降幂

• 定义 $x^{\overline{n}}$ 为 $x$ 的 $n$ 次上升阶乘幂，又称上升幂。它的值等于 ${\prod }_{i=0}^n(x+i)$。
• 定义 $x^{\underline{n}}$ 为 $x$ 的 $n$ 次下降阶乘幂，又称下降幂。它的值等于 ${\prod }_{i=0}^n(x-i)$。

上升幂和下降幂的转换公式（请读者自主完成证明）：
$$\begin{gathered} (-x{)}^{\overline{n}}=(-1{)}^n{x}^{\underline{n}} \\ (-x{)}^{\underline{n}}=(-1{)}^n{x}^{\overline{n}} \end{gathered}$$
实际上，上升幂和下降幂与普通幂之间也有转换公式，不过由于公式中存在斯特林数，因此将在下文提及。

普通生成函数

通俗的讲，对于一个数列 $a_n$，它的普通生成函数（简称 $\mathrm{OGF}$）为一个多项式：
$$f(x)=\sum _{i=0}^{\infty }{a}_i{x}^i$$
（严谨地讲，$f(x)$ 应该叫做形式幂级数，不过笔者并不了解其确切定义，因此这里用更通俗的方式解释。）

也就是说，对于多项式 $f(x)$，有 $a_n=[x^n]f(x)$。

如果我们能够得到这个多项式，那么我们也可以从它的系数中获取到这个序列。

同时，如果我们要对数列间做一些运算（如卷积），也可以通过对这个多项式做运算得到最终的结果。

---

第一类斯特林数

把 $n$ 个互不相同的数分为 $k$ 个圆排列，这样的方案数称为第一类斯特林数，也叫斯特林轮换数，记做 $s(n,k)$，也记做 $\left[\begin{array}{c}n\\ k\end{array}\right]$。

递推式

我们知道，如果在一个长为 $n$ 的圆排列中插入一个数（一共有 $n$ 个位置可以插入），形成的 $n$ 种长为 $n+1$ 的圆排列是互不相同的，因为它们互相之间不可以通过轮换得到。

所以，第一类斯特林数有递推公式：
$$\left[\begin{array}{c}n\\ k\end{array}\right]=\left[\begin{array}{c}n-1\\ k-1\end{array}\right]+(n-1)\left[\begin{array}{c}n-1\\ k\end{array}\right]$$
考虑从组合意义去证明：加入一个数，要么自己单独构成一个圆排列，要么插入已有的圆排列。前面说过，后者的方案数为 $n-1$。所以，根据加法原理，即可得到该递推式。

当然，该递推式也存在边界条件：$\left[\begin{array}{c}n\\ 0\end{array}\right]=[n=0]$。

由于第一类斯特林数不存在通项公式，这个递推式就显得尤为重要了，它将辅助证明下面的诸多结论。

常用公式

1. 和阶乘的关系：

$$n!=\sum _{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right]$$

前者实际上是指 $1\sim n$ 的全排列。由于每一种排列中，圆排列的个数是一定的，那么我们可以考虑枚举所有的圆排列个数，把对应的第一类斯特林数相加即为答案。

2. 和上升幂的关系（上升幂转普通幂）：

$$x^{\overline{n}}=\sum _{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right]x^i$$

证明：

1. 考虑构造生成函数 $f_n(x)={\sum }_{i=0}^{\infty }\left[\begin{array}{c}n\\ i\end{array}\right]x^i$.

   $\because$ 根据递推式有 $f_n(x)=x{f}_{n-1}(x)+(n-1)f_{n-1}(x)$.

   $\therefore$ 有 $f_n(x)=(x+n-1)f_{n-1}(x)$.

   $\because$ 当 $n=1$ 时，有 $f_1(x)=x$.

   $\therefore$ $f_n(x)={\sum }_{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right]x^i=x^{\overline{n}}$.

   以上证明过程也说明了：所有 $n$ 相同的第一类斯特林数（也叫第 $n$ 行第一类斯特林数）的生成函数是 $x^{\overline{n}}$。

2. 受上面过程的启发，我们还可以考虑用数学归纳法证明。

   显然当 $n=0$ 或 $n=1$ 时，原式左右两边相等。

   设当前结论满足 $n=m$ 的情况，求证当前结论也满足 $n=m+1$ 的情况。

   即证明：${\sum }_{i=0}^{n+1}\left[\begin{array}{c}n+1\\ i\end{array}\right]x^i=(x+n){\sum }_{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right]x^i$。
   $$\begin{array}{rl}& \sum _{i=0}^{n+1}\left[\begin{array}{c}n+1\\ i\end{array}\right]x^i\\ =& \sum _{i=0}^{n+1}(\left[\begin{array}{c}n\\ i-1\end{array}\right]+n\cdot \left[\begin{array}{c}n\\ i\end{array}\right])x^i\\ =& \sum _{i=0}^{n+1}\left[\begin{array}{c}n\\ i-1\end{array}\right]x^i+\sum _{i=0}^{n+1}n\cdot \left[\begin{array}{c}n\\ i\end{array}\right]x^i\\ =& \sum _{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right]x^{i+1}+n\cdot \sum _{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right]x^i\\ =& x\cdot \sum _{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right]x^i+n\cdot \sum _{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right]x^i\\ =& (x+n)\sum _{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right]x^i\end{array}$$

同一行第一类斯特林数的求法

模板题

根据递推公式，我们可以得到一个 $\mathcal{O}(n^2)$ 的做法。

根据上面的结论（第 $n$ 行第一类斯特林数的生成函数是 $x^{\overline{n}}$），我们有 $\mathcal{O}(n{\log }_2^{2}n)$ 的做法：

因为上升幂本质上是若干个二项式相乘，所以我们分治后直接跑 $\mathrm{NTT}$ 即可。

有没有更快的做法？当然有！

考虑倍增（它是多项式内容里的常客），当前求出了 $x^{\overline{n}}$，要求 $x^{\overline{2n}}$。

因为 $x^{\overline{2n}}=x^{\overline{n}}(x+n{)}^{\overline{n}}$，所以我们只要能够求出 $(x+n{)}^{\overline{n}}$，就能够做到 $\mathcal{O}(n{\log }_{2}n)$ 了。

考虑生成函数的展开形式：已知 $f(x)={\sum }_{i=0}^n{a}_i{x}^i$，要求 $f(x+n)={\sum }_{i=0}^n{a}_i(x+n{)}^i$。

我们对后面的这个式子做二项式展开：
$$\begin{array}{rl}& \sum _{i=0}^n{a}_i(x+n{)}^i\\ =& \sum _{i=0}^n{a}_i\sum _{j=0}^i\left(\genfrac{}{}{0ex}{}{i}{j}\right)x^j{n}^{i-j}\\ =& \sum _{i=0}^n{a}_i\sum _{j=0}^i\frac{i!}{j!(i-j)!}{x}^j{n}^{i-j}\\ =& \sum _{j=0}^n\frac{x_j}{j!}\sum _{i=j}^n{a}_{i}i!\frac{n^{i-j}}{(i-j)!}\\ =& \sum _{j=0}^n\frac{x_j}{j!}\sum _{i=0}^{n-j}{a}_{i+j}(i+j)!\frac{n^i}{i!}\end{array}$$
不看左边，我们设右边的式子为 $c_j$，发现其很像卷积形式，但是用 $\mathrm{NTT}$ 是不能直接做的。

没关系，我们还是可以用 $\mathrm{NTT}$ 做的，只不过有一个小技巧：颠倒系数。

什么意思？

正常的卷积形式是 ${\sum }_{i=0}^j{f}_i{g}_{j-i}$。

如果我们把 $f_i$ 这个数列翻转过来，还是做正常的卷积，得到的结果应该是：${\sum }_{i=0}^j{f}_{n-i}{g}_{j-i}$。

或者把 $g_i$ 这个数列翻转过来，也做正常的卷积，得到的结果是：${\sum }_{i=0}^j{f}_i{g}_{n-j+i}$。

可以发现，在原来的卷积中，$f$ 的下标里的 $i$ 和 $g$ 的下标里的 $i$ 是以相反数的形式出现的。不过在颠倒系数后，$f$ 的下标里的 $i$ 和 $g$ 的下标里的 $i$ 是以同符号形式出现的。

我们再看看 $c_j$，如果设 $f_i=a_{i}i!$，设 $g_i=\frac{n^i}{i!}$，那么有 $c_j={\sum }_{i=0}^{n-j}{f}_{i+j}{g}_i$，下标中的 $i$ 也是以同符号形式出现的！

所以，算法的大体框架已经出来了：我们只要求出 $f_i$ 和 $g_i$，然后颠倒其中的一个，再把它们做一遍 $\mathrm{NTT}$。

当然，做完 $\mathrm{NTT}$ 后的答案并不是我们想要的答案，只不过是形式对应了而已。

如果将 $f_i$ 颠倒，即 $f_i^{\prime }=f_{n-i}$，则对 $f^{\prime }$ 和 $g$ 卷积后的结果为：

$$c_j^{\prime }=\sum _{i=0}^j{f}_{n-j+i}{g}_j$$

那么有对应关系：

$$\begin{array}{rl}{c}_j& =\sum _{i=0}^{n-j}{f}_{i+j}{g}_i\\ & =\sum _{i=0}^{n-j}{f}_{n-(n-j)+i}{g}_i\\ & =c_{n-j}^{\prime }\end{array}$$

所以只要再把求出的 $c^{\prime }$ 颠倒即为答案。

如果将 $g_i$ 颠倒，即 $g_i^{\prime }=g_{n-i}$，则对 $f$ 和 $g^{\prime }$ 卷积后的结果为：

$$c_j^{\prime }=\sum _{i=0}^j{f}_i{g}_{n-j+i}$$

那么有对应关系：

$$\begin{array}{rl}{c}_j& =\sum _{i=0}^{n-j}{f}_{i+j}{g}_i\\ & =\sum _{i=j}^n{f}_i{g}_{i-j}\\ & =\sum _{i=0}^{n+j}{f}_i{g}_{n-(n+j)+i}\\ & =c_{j+n}^{\prime }\end{array}$$

（注意：由于 $f$ 和 $g$ 都只有第 $0\sim n$ 位不为 $0$，所以推导的第三步加入的所有贡献均为 $0$。）

所以只要把求出的 $c^{\prime }$ 整体向低位移动 $n$ 位即为答案。

求出 $(x+n{)}^{\overline{n}}$ 后，我们再将其和 $x^{\overline{n}}$ 做卷积即可。

注意要特判奇数的情况，此时还要再乘上一个 $x+2n$，直接 $\mathcal{O}(n)$ 乘即可。

代码（写的是第一种，即颠倒 $f_i$）：

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

#define MAXN 2000005

#define MOD 167772161
#define Min_G 3
#define Inv_Min_G 55924054

using namespace std;

int n, fac[MAXN], inv[MAXN], f[MAXN], g[MAXN], s[MAXN], t[MAXN];

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

namespace Polynomial
{
	int p, q, rev[MAXN];

	inline void Init(int n)
	{
		p = 1, q = -1;
		while(p < n) p <<= 1, ++q;
		for(register int i = 0; i < p; i++) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << q);
		return;
	}

	inline void NTT(int *f, int n, bool Inverse = false)
	{
		for(register int i = 0; i < n; i++) if(i < rev[i]) swap(f[i], f[rev[i]]);
		for(register int len = 2; len <= n; len <<= 1)
		{
			int k = (len >> 1), g = Pow(Inverse ? Inv_Min_G : Min_G, (MOD - 1) / len);
			for(register int i = 0; i < n; i += len)
			{
				int w = 1;
				for(register int j = 0; j < k; j++)
				{
					int u = f[i + j], v = 1LL * w * f[i + j + k] % MOD;
					f[i + j] = (u + v) % MOD;
					f[i + j + k] = (u - v + MOD) % MOD;
					w = 1LL * w * g % MOD;
				}
			}
		}
		if(Inverse)
		{
			int Inv_N = Pow(n, MOD - 2);
			for(register int i = 0; i < n; i++) f[i] = 1LL * f[i] * Inv_N % MOD;
		}
		return;
	}
}

inline void Init(int n)
{
	fac[0] = 1;
	for(register int i = 1; i <= n; i++) fac[i] = 1LL * fac[i - 1] * i % MOD;
	inv[n] = Pow(fac[n], MOD - 2);
	for(register int i = n - 1; i >= 0; i--) inv[i] = 1LL * inv[i + 1] * (i + 1) % MOD;
	return;
}

inline void Solve(int *f, int n)
{
	if(n == 0) return f[0] = 1, void();
	if(n & 1)
	{
		Solve(f, n - 1);
		if(n & 1)
		{
			for(register int i = n; i >= 1; i--) f[i] = (1LL * f[i] * (n - 1) % MOD + f[i - 1]) % MOD;
			f[0] = 1LL * f[0] * (n - 1) % MOD;
		}
		return;
	}
	Solve(f, n >> 1);

	int m = (n >> 1), w = 1;
	Polynomial :: Init((m << 1) + 1);
	int p = Polynomial :: p;
	fill(s, s + p, 0), fill(t, t + p, 0);
	for(register int i = 0; i <= m; i++)
	{
		s[i] = 1LL * f[m - i] * fac[m - i] % MOD;
		t[i] = 1LL * w * inv[i] % MOD;
		w = 1LL * w * m % MOD;
	}
	Polynomial :: NTT(s, p), Polynomial :: NTT(t, p);
	for(register int i = 0; i < p; i++) s[i] = 1LL * s[i] * t[i] % MOD;
	Polynomial :: NTT(s, p, true);

	fill(f + n + 1, f + p, 0), fill(g, g + p, 0);
	for(register int i = 0; i <= m; i++) g[i] = 1LL * s[m - i] * inv[i] % MOD;
	Polynomial :: NTT(f, p), Polynomial :: NTT(g, p);
	for(register int i = 0; i < p; i++) f[i] = 1LL * f[i] * g[i] % MOD;
	Polynomial :: NTT(f, p, true);
	return;
}

int main()
{
	scanf("%d", &n);
	Init(n << 1);
	Solve(f, n);
	for(register int i = 0; i <= n; i++) printf("%d ", f[i]);
	putchar('\n');
	return 0;
}

例题

• [FJOI2016]建筑师

题解：

做组合数学的题，光有推式子能力还不行，还得通过组合意义列出答案的式子。

例如这道题目，我们要思考的是，如何在其中加入组合意义。

可以发现，无论是从左边还是从右边，都可以并且一定会看到最高的楼。

然后，我们如果设 $\ast$ 为能够看到的楼，$.$ 为不能够看到的楼，$H$ 为最高的楼，那么建筑一定是这种形式：
$$\ast ....\ast ..\ast ..\ast ...H.\ast .....\ast ..\ast$$
我们来从左侧的角度解释一下这个图的一些细节（右侧同理）：

• $H$ 左侧的 $\ast$ 数量为 $A-1$；
• 左侧要么不存在 $\ast$，要么第一个字符即为 $\ast$，每一个 $\ast$ 的右边存在若干个 $.$，这个 $\ast$ 的高度高于这些 $.$；
• 对于左侧的一个 $\ast$，右侧的 $.$ 顺序随意。

“顺序随意” 给了我们一定的启发，如果耐心把式子列出来，可以发现：如果我们把一个 $\ast$ 和其右侧的 $m$ 个 $.$ 看作一个整体，那么由于一共有 $(m-1)!$ 种排列方式。

如果你对排列数十分敏感，可以一眼看出——这就是圆排列。

圆排列！我们能想到什么？第一类斯特林数！

所以，我们只要在 $n-1$ 个数中选出 $A+B-2$ 个圆排列，并任选 $A-1$ 个放在 $H$ 的左边，$B-1$ 个放在 $H$ 的右边，即为一种方案。

那么，答案就呼之欲出了：$\left[\begin{array}{c}n-1\\ A+B-2\end{array}\right]\cdot \left(\genfrac{}{}{0ex}{}{A+B-2}{A-1}\right)$。

直接预处理即可，时间在可承受范围内。

代码就不贴了。

---

第二类斯特林数

把 $n$ 个互不相同的数划分为 $k$ 个互不区分、互不相交的集合，这样的方案数称为第二类斯特林数，记做 $S(n,k)$，也记做 $\left\{\begin{array}{c}n\\ k\end{array}\right\}$。

第二类斯特林数相对于第一类的用处会更加广泛。

---

递推式

$$\left\{\begin{array}{c}n\\ k\end{array}\right\}=\left\{\begin{array}{c}n-1\\ k-1\end{array}\right\}+k\cdot \left\{\begin{array}{c}n-1\\ k\end{array}\right\}$$

还是考虑从组合意义去证明：加入一个数，要么自己单独构成一个集合，要么加入已有的 $k$ 个集合。

边界条件同样是：$\left\{\begin{array}{c}n\\ 0\end{array}\right\}=[n=0]$。

通项公式

第二类斯特林数是存在通项公式的：
$$\left\{\begin{array}{c}n\\ k\end{array}\right\}=\frac{1}{k!}\sum _{i=0}^k(-1{)}^i(\genfrac{}{}{0ex}{}{k}{i})(k-i{)}^n=\sum _{i=0}^k\frac{(-1{)}^i}{i!}\cdot \frac{(k-i{)}^n}{(k-i)!}=\sum _{i=0}^k\frac{(-1{)}^{k-i}}{(k-i)!}\cdot \frac{i^n}{i!}$$
（上面把推式子可能会用到的三种形式都写出来了。）

证明：

设 $n$ 个互不相同的数划分为 $k$ 个互不相同的集合的方案数为 $f_k,g_k$，前者允许空集，后者不允许空集。

那么有：
$$\begin{gathered} f_k=k^n \\ {f}_k=\sum _{i=0}^k\left(\genfrac{}{}{0ex}{}{k}{i}\right)g_i \end{gathered}$$
考虑二项式反演：
$$g_k=\sum _{i=0}^k(-1{)}^{k-i}(\genfrac{}{}{0ex}{}{k}{i})f_i=\sum _{i=0}^k(-1{)}^i\left(\genfrac{}{}{0ex}{}{k}{i}\right)(k-i{)}^n$$
由于 $g_k$ 在统计过程中，集合之间相互区分，所以：

$$\left\{\begin{array}{c}n\\ k\end{array}\right\}=\frac{1}{k!}{g}_k=\frac{1}{k!}\sum _{i=0}^k(-1{)}^i(\genfrac{}{}{0ex}{}{k}{i})(k-i{)}^n$$

常用公式

和下降幂的关系（普通幂转下降幂）：

$$x^n=\sum _{i=0}^x\left(\genfrac{}{}{0ex}{}{x}{i}\right)\left\{\begin{array}{c}n\\ i\end{array}\right\}i!=\sum _{i=0}^n\left\{\begin{array}{c}n\\ i\end{array}\right\}{x}^{\underline{i}}$$

证明：

考虑组合意义，等式左侧即为 $n$ 个互不相同的数划分为 $x$ 个互不相同的可空集合的方案数，等式右侧即选出 $i$ 个集合强制非空的方案数。

当然，你也可以考虑用上面的数学归纳法证明，这里就留给读者当作练习吧。

同一行第一类斯特林数的求法

据说有一种用 $\mathrm{EGF}$（指数型生成函数）做的方法，但是由于笔者能力有限，加上其速度较慢，故此处不讲解这种方法。

其实非常简单，我们再一次观察通项公式：
$$\left\{\begin{array}{c}n\\ k\end{array}\right\}=\sum _{i=0}^k\frac{(-1{)}^i}{i!}\cdot \frac{(k-i{)}^n}{(k-i)!}$$
可以发现这就是一个卷积的形式，$\mathrm{NTT}$ 即可。

代码：

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

#define MAXN 1000005

#define MOD 167772161
#define Min_G 3
#define Inv_Min_G 55924054

using namespace std;

int n, f[MAXN], g[MAXN], fac[MAXN], invf[MAXN], p, q, rev[MAXN];

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

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

inline void Init()
{
	fac[0] = 1;
	for(register int i = 1; i <= n; i++) fac[i] = 1LL * fac[i - 1] * i % MOD;
	invf[n] = Pow(fac[n], MOD - 2);
	for(register int i = n - 1; i >= 0; i--) invf[i] = 1LL * invf[i + 1] * (i + 1) % MOD;
	p = 1, q = -1;
	while(p < (n << 1)) p <<= 1, ++q;
	for(register int i = 0; i < p; i++) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << q);
	return;
}

inline void NTT(int *f, bool Inverse = false)
{
	for(register int i = 0; i < p; i++) if(i < rev[i]) swap(f[i], f[rev[i]]);
	for(register int len = 2; len <= p; len <<= 1)
	{
		int k = (len >> 1), g = Pow(Inverse ? Inv_Min_G : Min_G, (MOD - 1) / len);
		for(register int i = 0; i < p; i += len)
		{
			int w = 1;
			for(register int j = 0; j < k; j++)
			{
				int u = f[i + j], v = 1LL * w * f[i + j + k] % MOD;
				f[i + j] = Get_MOD(u + v);
				f[i + j + k] = Get_MOD(u - v + MOD);
				w = 1LL * w * g % MOD;
			}
		}
	}
	if(Inverse)
	{
		int Inv_N = Pow(p, MOD - 2);
		for(register int i = 0; i < p; i++) f[i] = 1LL * f[i] * Inv_N % MOD;
	}
	return;
}

int main()
{
	scanf("%d", &n);
	Init();
	for(register int i = 0; i <= n; i++)
	{
		f[i] = 1LL * ((i & 1) ? MOD - 1 : 1) * invf[i] % MOD;
		g[i] = 1LL * Pow(i, n) * invf[i] % MOD;
	}
	NTT(f), NTT(g);
	for(register int i = 0; i < p; i++) f[i] = 1LL * f[i] * g[i] % MOD;
	NTT(f, true);
	for(register int i = 0; i <= n; i++) printf("%d ", f[i]);
	return 0;
}

例题

• BZOJ5093 图的价值

“简单无向图” 是指无重边、无自环的无向图（不一定连通）。

一个带标号的图的价值定义为每个点度数的 $k$ 次方的和。

给定 $n$ 和 $k$，请计算所有 $n$ 个点的带标号的简单无向图的价值之和。

答案对 $998233353$ 取模。

$1\le n\le 10^9,1\le k\le 2\times 10^5$。

题解：

显然每个点对答案的贡献是相同的，所以我们只需要算出一个点对答案的贡献，最后乘上 $n$ 即可。

我们枚举一个点的度数，那么有：
$$Answer=n\cdot 2^{\left(\genfrac{}{}{0ex}{}{n-1}{2}\right)}\sum _{i=0}^{n-1}{i}^k\left(\genfrac{}{}{0ex}{}{n-1}{i}\right)$$
这个时候，如果只用一般的方法，大概率会无从下手。

回顾普通幂转化为第二类斯特林数的公式，我们可以得到：
$$\begin{array}{rl}Answer& =n\cdot 2^{\left(\genfrac{}{}{0ex}{}{n-1}{2}\right)}\sum _{i=0}^{n-1}{i}^k\left(\genfrac{}{}{0ex}{}{n-1}{i}\right)\\ & =n\cdot 2^{\left(\genfrac{}{}{0ex}{}{n-1}{2}\right)}\sum _{i=0}^{n-1}\left(\genfrac{}{}{0ex}{}{n-1}{i}\right)\sum _{j=0}^{\min (i,k)}\left(\genfrac{}{}{0ex}{}{i}{j}\right)\left\{\begin{array}{c}k\\ j\end{array}\right\}j!\\ & =n\cdot 2^{\left(\genfrac{}{}{0ex}{}{n-1}{2}\right)}\sum _{j=0}^{\min (n-1,k)}\left\{\begin{array}{c}k\\ j\end{array}\right\}j!\sum _{i=j}^{n-1}\left(\genfrac{}{}{0ex}{}{n-1}{i}\right)\left(\genfrac{}{}{0ex}{}{i}{j}\right)\\ & =n\cdot 2^{\left(\genfrac{}{}{0ex}{}{n-1}{2}\right)}\sum _{j=0}^{\min (n-1,k)}\left\{\begin{array}{c}k\\ j\end{array}\right\}j!\left(\genfrac{}{}{0ex}{}{n-1}{j}\right)\sum _{i=j}^{n-1}\left(\genfrac{}{}{0ex}{}{n-j-1}{i-j}\right)\\ & =n\cdot 2^{\left(\genfrac{}{}{0ex}{}{n-1}{2}\right)}\sum _{j=0}^{\min (n-1,k)}\left\{\begin{array}{c}k\\ j\end{array}\right\}j!\left(\genfrac{}{}{0ex}{}{n-1}{j}\right)\sum _{i=0}^{n-j-1}\left(\genfrac{}{}{0ex}{}{n-j-1}{i}\right)\\ & =n\cdot 2^{\left(\genfrac{}{}{0ex}{}{n-1}{2}\right)}\sum _{j=0}^{\min (n-1,k)}\left\{\begin{array}{c}k\\ j\end{array}\right\}j!\left(\genfrac{}{}{0ex}{}{n-1}{j}\right)2^{n-j-1}\end{array}$$
由于本题没有提交地址，因此笔者偷懒没有写代码，望见谅～

斯特林反演

常用公式

在前面的学习中，我们知道有如下两个等式：
$$\begin{gathered} (-x{)}^{\overline{n}}=(-1{)}^n{x}^{\underline{n}} \\ {x}^{\overline{n}}=\sum _{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right]x^i \end{gathered}$$
那么有：
$$(-x{)}^{\overline{n}}=\sum _{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right](-x{)}^i$$
即：
$$(-1{)}^n{x}^{\underline{n}}=\sum _{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right](-1{)}^i{x}^i$$
所以有：
$$x^{\underline{n}}=\sum _{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right](-1{)}^{n-i}{x}^i$$
类似的，我们可以由如下两个公式：
$$\begin{gathered} (-x{)}^{\underline{n}}=(-1{)}^n{x}^{\overline{n}} \\ {x}^n=\sum _{i=0}^n\left\{\begin{array}{c}n\\ i\end{array}\right\}{x}^{\underline{i}} \end{gathered}$$
推入如下的公式：
$$x^n=\sum _{i=0}^n\left\{\begin{array}{c}n\\ i\end{array}\right\}(-1{)}^{n-i}{x}^{\overline{i}}$$
请读者自行推导。

总结一下，我们已经得到了所有的六个上升幂、下降幂和普通幂之间的转换公式：
$$\begin{gathered} (-x{)}^{\overline{n}}=(-1{)}^n{x}^{\underline{n}} \\ (-x{)}^{\underline{n}}=(-1{)}^n{x}^{\overline{n}} \\ {x}^{\overline{n}}=\sum _{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right]x^i \\ {x}^n=\sum _{i=0}^n\left\{\begin{array}{c}n\\ i\end{array}\right\}{x}^{\underline{i}} \\ {x}^{\underline{n}}=\sum _{i=0}^n\left[\begin{array}{c}n\\ i\end{array}\right](-1{)}^{n-i}{x}^i \\ {x}^n=\sum _{i=0}^n\left\{\begin{array}{c}n\\ i\end{array}\right\}(-1{)}^{n-i}{x}^{\overline{i}} \end{gathered}$$
下文有可能会分别称它们为公式一～公式六。

如果我们将公式三代入公式六，可以得到：
$$\begin{array}{rl}{x}^n& =\sum _{i=0}^n\left\{\begin{array}{c}n\\ i\end{array}\right\}(-1{)}^{n-i}{x}^{\overline{i}}\\ & =\sum _{i=0}^n\left\{\begin{array}{c}n\\ i\end{array}\right\}(-1{)}^{n-i}\sum _{j=0}^i\left[\begin{array}{c}i\\ j\end{array}\right]x^j\\ & =\sum _{j=0}^n{x}^j\sum _{i=j}^n\left\{\begin{array}{c}n\\ i\end{array}\right\}\left[\begin{array}{c}i\\ j\end{array}\right](-1{)}^{n-i}\end{array}$$
可以发现有：
$$\sum _{i=j}^n\left\{\begin{array}{c}n\\ i\end{array}\right\}\left[\begin{array}{c}i\\ j\end{array}\right](-1{)}^{n-i}=[j=n]$$
类似地，将公式四代入公式五也可以得到十分类似的结果，这里就把结论摆出来了：
$$\sum _{i=j}^n\left[\begin{array}{c}n\\ i\end{array}\right]\left\{\begin{array}{c}i\\ j\end{array}\right\}(-1{)}^{n-i}=[j=n]$$
这俩公式合称反转公式。

注意一点：$-1$ 的指数 $n-i$ 也可以写成 $j+i$。当 $j=n$ 时，这样不会有任何影响；当 $j\ne n$ 时，整个式子的值为 $0$，也不会受到影响。

当 $j=1$ 时有：
$$\sum _{i=1}^n(-1{)}^{n-1}(i-1)!\left\{\begin{array}{c}n\\ i\end{array}\right\}=[n=1]$$
这个公式在斯特林反演中会经常用到。

由反转公式，我们还可以得到斯特林反演的另一种形式：
$$\begin{gathered} f_n=\sum _{i=0}^n\left\{\begin{array}{c}n\\ i\end{array}\right\}{g}_i \\ \Downarrow \\ {g}_n=\sum _{i=0}^n(-1{)}^{n-i}\left[\begin{array}{c}n\\ i\end{array}\right]f_i \end{gathered}$$
这个形式十分类似二项式反演，显得有许些亲切感。

例题

• BZOJ 4671

题解：

直接判连通并不好入手。相反，强制不联通却简单得多。

考虑容斥，设 $f_i$ 为把 $n$ 个点划分为 $i$ 个互相独立且互不相交的点集的方案数，$g_i$ 为图中恰好有 $i$ 个连通块的方案数。

那么对于 $g_j$，它对 $f_i$ 的贡献为：$\left\{\begin{array}{c}j\\ i\end{array}\right\}$。

因为 $g_j$ 中的 $j$ 个连通块互不相同，同时 $f_i$ 中的 $i$ 个点集又不考虑顺序，这恰好满足了第二类斯特林数的要求。

即：
$$f_i=\sum _{j=i}^n\left\{\begin{array}{c}j\\ i\end{array}\right\}{g}_j$$
反演一下就有：
$$g_i=\sum _{j=i}^n(-1{)}^{j-i}\left[\begin{array}{c}j\\ i\end{array}\right]f_j$$
依照题意，现在我们只需求出 $g_1={\sum }_{j=1}^n(-1{)}^{j-1}(j-1)!f_j$，那么最大的问题是求 $f_j$。

首先我们可以枚举子集划分（贝尔数级别，不会超时），然后我们强制让两个点集之间不连任何一条边。

由于一条边的选择情况取决于包含这条边的图的选择情况，因此对于一条横跨两个点集的边 $(u,v)$，我们设包含它的图为 $G_{1\sim m}^{\prime }$，同时设每个图的选择情况为 $x_{1\sim m}$（$0$ 表示不选，$1$ 表示选），那么我们可以列出方程：
$${\mathrm{xor}}_{i=1}^m{x}_i=0$$
枚举完每条边之后，我们可以得到一个异或方程组，那么解的数量就是这个子集划分对 $f_j$ 的贡献。

求解方程组的办法当然是用高斯消元。不过，如何求异或方程组解的数量呢？

如果您阅读过我的文章《线性空间和OI中的线性基》，那么这个问题是就易如反掌了。

由于线性基的构建过程本质上是高斯消元，因此当我们把一个方程插入线性基后，这个方程会被自动进行高斯消元，并且由于增广矩阵是一个零向量，所以无论怎样消都是没有任何影响的。

在插入所有方程后，我们可以发现，线性基中可能存在一些空的位置。这些空的位置，是高斯消元过程中可以被抵消掉的元，即自由元。这些自由元可以等于值域内的任意值（这里是 $0$ 和 $1$），并且所有自由元的取值同时也决定了剩下的主元的取值，也就是说，每一组自由元的取值都对应原方程的一组解。

所以说，我们只要把方程转化为二进制数插入线性基，再统计有多少个位置等于 $0$ 即可。设这个值为 $cnt$，那么我们要求的答案就是 $2^{cnt}$。

当然，这道题线性基的构建方法不能使用高斯消元法（会被卡常），用普通的构建方法即可。

代码：

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

#define MAXN 11
#define MAXM 61

using LL = long long;
using namespace std;

int s, n, mp[MAXN], in[MAXM];
LL fac[MAXN], ans;
bool t[MAXM][MAXN][MAXN];
char g[MAXN * MAXN];

namespace Linear_Basis
{
	int cnt;
	LL b[MAXM];

	inline void Insert(LL val)
	{
		for(register int i = s - 1; i >= 0; i--)
		{
			if((val >> i & 1LL) ^ 1) continue;
			if(b[i]) { val ^= b[i]; continue; }
			++cnt, b[i] = val;
			break;
		}
		return;
	}
}

using namespace Linear_Basis;

inline void DFS(int i, int j)
{
	if(i == n + 1)
	{
		cnt = 0, memset(b, 0LL, sizeof b);
		for(register int a = 1; a < n; a++)
		{
			for(register int c = a + 1; c <= n; c++)
			{
				if(in[a] == in[c]) continue;
				LL val = 0LL;
				for(register int q = 0; q < s; q++) if(t[q][a][c]) val |= 1LL << q;
				Insert(val);
			}
		}
		LL f = 1LL << (s - cnt);
		ans += (j & 1 ? 1LL : -1LL) * fac[j - 1] * f;
		return;
	}
	for(register int k = 1; k <= j; k++) in[i] = k, DFS(i + 1, j); 
	in[i] = j + 1, DFS(i + 1, j + 1);
	return;
}

int main()
{
	for(register int i = 2; i < MAXN; i++) mp[i * (i - 1) / 2] = i;
	scanf("%d", &s);
	for(register int i = 0; i < s; i++)
	{
		scanf("%s", g);
		n = mp[(int)strlen(g)];
		int tot = 0;
		for(register int j = 1; j < n; j++)
		{
			for(register int k = j + 1; k <= n; k++)
			{
				if(g[tot] == '1') t[i][j][k] = true;
				++tot;
			}
		}
	}
	fac[0] = 1LL; for(register int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i;
	DFS(1, 0);
	printf("%lld\n", ans);
	return 0;
}

• CF961G Partitions

抛开 $w_i$ 不谈，可以发现单个物品的贡献是一定的，所以我们只要把 $w_i$ 求和，乘上单个物品的贡献 $\delta$ 即可。

现在考虑计算 $\delta$：
$$\begin{array}{rl}\delta =& \sum _{i=1}^{n}i\left(\genfrac{}{}{0ex}{}{n-1}{i-1}\right)\left\{\begin{array}{c}n-i\\ k-1\end{array}\right\}\\ =& \sum _{i=1}^{n}i\left(\genfrac{}{}{0ex}{}{n-1}{i-1}\right)\sum _{j=0}^{k-1}\frac{(-1{)}^{k-j-1}}{(k-j-1)!}\frac{j^{n-i}}{j!}\\ =& \sum _{j=0}^{k-1}\frac{(-1{)}^{k-j-1}}{(k-j-1)!j!}\sum _{i=1}^{n}i{j}^{n-i}\left(\genfrac{}{}{0ex}{}{n-1}{i-1}\right)\end{array}$$
前面的式子没有什么问题，考虑如何求后面的式子：
$$\begin{array}{rl}& \sum _{i=1}^{n}i{j}^{n-i}\left(\genfrac{}{}{0ex}{}{n-1}{i-1}\right)\\ =& \sum _{i=1}^n(i-1+1)j^{n-i}\left(\genfrac{}{}{0ex}{}{n-1}{i-1}\right)\\ =& \sum _{i=1}^n(i-1)j^{n-i}\left(\genfrac{}{}{0ex}{}{n-1}{i-1}\right)+\sum _{i=1}^n{j}^{n-i}\left(\genfrac{}{}{0ex}{}{n-1}{i-1}\right)\\ =& \sum _{i=1}^n(i-1)j^{n-i}\left(\genfrac{}{}{0ex}{}{n-1}{i-1}\right)+(j+1{)}^{n-1}\\ =& (n-1)\sum _{i=1}^n{j}^{n-i}\left(\genfrac{}{}{0ex}{}{n-2}{i-2}\right)+(j+1{)}^{n-1}\\ =& (n-1)(j+1{)}^{n-2}+(j+1{)}^{n-1}\\ =& (j+1{)}^{n-2}(n+j)\end{array}$$
这样就做完了。

不过，这可是 $\mathrm{CF}$ 诶！有多少人能够在如此紧张的环境下推出这么一长串式子呢？

有没有更简单的做法？当然有！

组合意义天地灭，代数推导保平安。 ——$\mathrm{t}\mathrm{i}\mathrm{g}\mathrm{e}\mathrm{r}0133$

我们从组合意义思考一下，集合大小的本质是什么？不就是集合里的每一个数都贡献 $1$ 吗！

所以说，还是考虑计算单个物品 $i$ 的贡献：

首先，对于所有的 $\left\{\begin{array}{c}n\\ k\end{array}\right\}$ 个划分方案，自己都会对自己造成 $1$ 的贡献。

其次，对于其它的每一个物品 $j$，抛开这个物品 $j$ 不谈，我们把剩下的 $n-1$ 个物品分成 $k$ 组（一共 $\left\{\begin{array}{c}n-1\\ k\end{array}\right\}$ 种方案），再把物品 $j$ 加入到 $i$ 所在的组内，这样 $j$ 就对 $i$ 造成了 $1$ 的贡献。

所以单个物品贡献为：
$$\left\{\begin{array}{c}n\\ k\end{array}\right\}+(n-1)\left\{\begin{array}{c}n-1\\ k\end{array}\right\}$$
代码：

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

#define MAXN 200005
#define MOD 1000000007

using namespace std;

int n, k, sum, val1, val2, fac, inv[MAXN];

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

int main()
{
	scanf("%d%d", &n, &k);
	for(register int i = 1; i <= n; i++)
	{
		int w; scanf("%d", &w);
		sum = (sum + w) % MOD;
	}
	fac = 1;
	for(register int i = 1; i <= k; i++) fac = 1LL * fac * i % MOD;
	inv[k] = Pow(fac, MOD - 2);
	for(register int i = k - 1; i >= 0; i--) inv[i] = 1LL * inv[i + 1] * (i + 1) % MOD;
	for(register int i = 0, w = 1; i <= k; i++)
	{
		val1 = (val1 + 1LL * w * inv[i] % MOD * Pow(k - i, n) % MOD * inv[k - i] % MOD) % MOD;
		val2 = (val2 + 1LL * w * inv[i] % MOD * Pow(k - i, n - 1) % MOD * inv[k - i] % MOD) % MOD;
		w = 1LL * w * (MOD - 1) % MOD;
	}
	printf("%lld\n", 1LL * sum * (val1 + 1LL * val2 * (n - 1) % MOD) % MOD);
	return 0;
}

---

$ToBeContinued\cdots \cdots$