斯特林数

斯特林数一共分为两类，较第一类来说，第二类斯特林数更加常用，接下来分别介绍他们。

第一类斯特林数：

定义：

用 $s(n,m)$ 表示第一类斯特林数，其含义是把 $n$ 个数分成 $m$ 个圆排列的方案数。

递推式：

$s(n,m)$ 由两种构造方式推导而来。

第一种，考虑对于前 $n-1$ 个数形成 $m-1$ 个圆排列，只要将当前处理的第 $n$ 个数单独形成一个圆排列，就可以将这 $n$ 个数分成 $m$ 个圆排列。

第二种，考虑前 $n-1$ 个数形成了 $m$ 个圆排列，此时只需要任选一个圆排列，将第 $n$ 个数插入进去，就可以将这 $n$ 个数分成 $m$ 个圆排列。其中，在将第 $n$ 个元素插入的时候，前 $n-1$ 个元素形成了 $n-1$ 个空位，有 $n-1$ 种插入方法。

综上，第一类斯特林数的递推式为：

$$s[n][m]=s[n-1][m-1]+(n-1)\ast s[n-1][m]$$

边界条件为 $s[n][1]=(n-1)!$ 和 $s[n][n]=1$。

应用：

说实话遇到的需要用第一类斯特林数来解决的题目其实并不是很多……这里还是放几道题来分享学习下。

1.[HDU 3625] Examining the Rooms

酒店里发生了一起谋杀案。作为镇上最好的侦探，您应该立即检查酒店的所有 $N$ 个房间。然而，房间的所有门都被锁上了，钥匙只是锁在房间里，真是一个陷阱！您知道每个房间只有一个密钥，并且所有可能的分布都具有相等的可能性。例如，如果 $N=3$，则有 $6$ 个可能的分布，每个分布的可能性为 $1/6$。为了方便起见，我们将房间从 $1$ 编号到 $N$，房间 $1$ 的钥匙编号为钥匙 $1$，房间 $2$ 的钥匙是钥匙 $2$，依此类推，
要检查所有房间，你必须用力摧毁一些门。但是你不想破坏太多，所以你采取以下策略：起初，你手里没有钥匙，所以你随机摧毁一扇锁着的门，进入房间，检查它，然后拿到里面的钥匙。然后，也许你可以用新钥匙打开另一个房间，检查它并得到第二把钥匙。重复此操作，直到您无法打开任何新房间。如果仍然有房间未检查，您必须随机选择另一扇未打开的门以强制销毁，然后重复上述过程，直到所有房间都检查完毕。
现在，你最多只能用武力摧毁 $k$ 扇门。更重要的是，$1$ 号房间里有一个非常重要的人。你不被允许破坏 $1$ 号房间的门，也就是说，检查 $1$ 号房间的唯一方法是用相应的钥匙打开它。你想知道你最终能检查所有房间的概率。

分析：

炸开一扇门，拿走里面的钥匙，开启另一扇门，再拿走这个房间里面的钥匙，再打开一扇门……如此循环下去，直到打开的房间里面的钥匙对应的是已经打开过的房间的钥匙。这个过程其实就了一个圆排列。对于 $N$ 个房间，$K$ 个炸门机会，如果能打开所有门，那么 $N$ 个房间所形成的能满足条件的圆排列方案数为：

$$\sum _{i=0}^{k}s[n][i]$$

因为不能使第一个房间单独成为一个圆排列，因此还要将这种情况减去，最终答案为：

$$\sum _{i=1}^{k}s[n][i]-s[n-1][i-1]$$

Code:

点击查看代码

#include
#define int long long
using namespace std;
const int MAXN = 20;
long long s[MAXN + 5][MAXN + 5],n;
int fact(int a){
	int ret = 1;
	while(a){
		ret = (long long)a * ret;
		a--;
	}
	return ret;
}
int t,k;
signed main(){
	s[0][0] = 1;
	for(int i = 1; i <= MAXN; i++){
		s[i][i] = 1;
		s[i][1] = fact(i - 1);
	}
	for(int i = 1; i <= MAXN; i++){
		for(int j = 2; j < i; j++){
			s[i][j] = (s[i - 1][j - 1] + (long long)(i - 1) * s[i - 1][j]);; 
			//cout << s[i][j] << "\n";
		}
	} 		
	cin >> t;
	while(t--){
		cin >> n >> k;
		int ans = 0;
		for(int i = 1; i <= k; i++){
			ans += s[n][i] - s[n - 1][i - 1];
		}
		double an = 1.0 * ans / fact(n);
		printf("%.4lf\n",an);
	}

	return 0;
} 

2.HDU 4372 Count the Buildings

城市中有 $N$ 座建筑物直线站立，编号从 $1$ 到 $N$。所有建筑物的高度都是不同的，介于 $1$ 和 $N$ 之间。当你站在第一栋建筑前面向前看时，你可以看到 $F$ 栋，当你站在最后一栋建筑后面向后看时，你可以看到 $B$ 栋建筑。如果建筑物比您与其之间的任何建筑物都高，则可以看到建筑物。
现在，给定 $N$，$F$，$B$，你的任务是弄清楚所有建筑物可以有多少种方式。

无论从那个方向看，最高的楼都是会被看见的。因此问题变为将剩下的 $N-1$ 个数划分成 $F-1+B-1$ 个集合，保证该集合里最大的元素在前面，求一共有多少方案，并从这 $F+B-2$ 个集合中选取 $F-1$ 个放到最高楼的左边即可。就是求裸的第一类斯特林数。

点击查看代码

#include
using namespace std;
const int MAXN = 2e3;
const int MOD = 1e9 + 7; 
int f[MAXN + 5],inv[MAXN + 5],s[MAXN + 5][MAXN + 5],n;
int qpow(int a,int n){
	int ret = 1;
	while(n){
		if(n & 1){
			ret = (long long)ret * a % MOD;
		}
		n /= 2;
		a = (long long)a * a % MOD;
	}
	return ret;
} 

void init(){
	f[0] = 1;
	for(int i = 1;i <= MAXN; i++){
		f[i] = (long long)f[i - 1] * i % MOD;
	}
	inv[MAXN] = qpow(f[MAXN],MOD - 2);
	for(int i = MAXN; i >= 1; i--){
		inv[i - 1] = (long long)inv[i] * i % MOD;
	}
}
int c(int a,int b){
	return (long long)f[a] * inv[b] % MOD * inv[a - b] % MOD;;
}
int t,ff,b;
int main(){
	cin >> t;
	s[0][0] = 1;
	init();
	for(int i = 1; i <= MAXN; i++){
		s[i][i] = 1;
		s[i][1] = f[i - 1];
	}
	for(int i = 1; i <= MAXN; i++){
		for(int j = 2; j < i; j++){
			s[i][j] = (s[i - 1][j - 1] + (long long)(i - 1) * s[i - 1][j]) % MOD;; 
			//cout << s[i][j] << "\n";
		}
		
	} 
	while(t--){
		cin >> n >> ff >> b;
		if(ff + b - 1 > n || max(ff,b) <= 1) {
			printf("0\n");
			continue;
		}
		cout << (long long)s[n - 1][b + ff - 2] * c(b + ff - 2,b - 1) % MOD << "\n";;
	}
	return 0;
} 

第二类斯特林数：

定义：令 $S(n,m)$ 表示将 $n$ 个元素划分成 $m$ 个集合的方案数。

递推式：

仍按照递推第一类斯特林数的方法进行思考。如果前 $n-1$ 个数形成 了 $m-1$ 个集合，那么直接将第 $n$ 个数单独形成一个集合即可。如果前 $n-1$ 个数形成了 $m$ 个集合，只需要将第 $n$ 个数插入其中任意一个集合中即可。递推式为：

$$S[n][m]=S[n-1][m-1]+m\ast S[n-1][m]$$

边界条件为 $S[n][n]=1$ 和 S[n][1] = 1$。

第二类斯特林数还有一个重要的通项公式：

$$S[n][m]=\frac{1}{m!}\times \sum _{i=0}^m\{(-1{)}^i\times (\genfrac{}{}{0ex}{}{m}{i})\ast (m-i{)}^n\}$$

至于怎么得出的，我也不知道。知道的可以在评论区里分享一下。

习题：

1.CF1342E Placing Rooks

有这样一个问题：
在 $n\times n$ 的国际象棋棋盘上放 $n$ 个车，要求满足两个条件：
所有的空格子都能被至少一个车攻击到。
恰好有 $k$ 对车可以互相攻击到。
答案对 $998244353998244353$ 取模。

分析：

好题。
保证每一个格子都要被攻击到，换句话说，就是要每一行都有一个棋子，这就大大简化了问题了。

一个重要的结论：如果有 $k$ 对棋子能互相攻击，那么所有棋子应该分成 $n-k$ 列。

那么，只是求 $S[n][n-k]$ 就结束了吗？这 $n-k$ 列在 $n$ 列中的放置方案并不只有一种，且排列方式也不止一种（有 $(n-k）!$ 种排列方式）。

综上，答案为：

$$S[n][n-k]\ast (\genfrac{}{}{0ex}{}{n}{n-k})\ast (n-k)!$$

假如当前方案并不只是一列，那么还可以将其旋转一次得到新的方案，此时就应该将答案乘 $2$。

Code：

点击查看代码

#include
using namespace std;
const int MAXN = 2e5;
const int MOD =  998244353;
int inv[MAXN  + 5],f[MAXN + 5];
int qpow(int a,int n){
	int ret = 1;
	while(n){
		if(n & 1){
			ret = (long long)ret * a % MOD;
		}
		n /= 2;
		a = (long long)a * a % MOD; 
	}
	return ret;
} 
void init(){
	f[0] = 1;
	for(int i = 1; i <= MAXN; i++){
		f[i] = (long long)f[i - 1] * i % MOD;
		//cout << f[i] << "\n";
	}
	inv[MAXN] = qpow(f[MAXN],MOD - 2);
	for(int i = MAXN; i > 0; i--){
		inv[i - 1] = (long long)inv[i] * i % MOD; 
	}
} 
int c(int a,int b){
	return (long long)f[a] * inv[b] % MOD * inv[a - b] % MOD;;
}
int s(int n,int m){
	long long ans = 0;
	for(int i = 0; i <= m; i++){
		int t = (i % 2 == 0) ? 1 : -1;
		ans = (1ll * ans % MOD + t * ((long long)c(m,i) % MOD  * qpow(m - i,n) % MOD)) % MOD;
		ans %= MOD;
	//	cout <<  c(m,i) << " " << qpow(m - i,n) << " " << c(m,i) * qpow(m - i,n) %  MOD << " " << ans << "\n";
	}
	ans = 1ll * ans * inv[m] % MOD;
	return ans;
}
signed main(){
	init();
	int a,b;
	cin >> a >> b;
	if(a - 1 < b){
		cout << "0";
		return 0;
	}
	cout << (((b == 0) ? 1 : 2) * (long long)s(a,a - b) * c(a,a - b) % MOD * f[a - b] % MOD + MOD) % MOD;;
} 

2.第二类斯特林数的奇偶性分析：

给定 $n$ $m$，求 $S[n][m]\mathrm{mod}2$
（借鉴了大佬@LuckyGlass的思想）

考虑对 $m$ 的奇偶情况进行分类讨论。

当 $m$ 为偶数时，用 $2m$ 表示 $m$。在这种情况下，因为只用关注奇偶性，可以将递推式变成如下形式：

$$s[n][2m]=s[n-1][2m-1]$$

当 $m$ 为奇数时，用 $2m+1$ 表示 $m$。同样只因为关注奇偶性，将递推式变为：

$$s[n][2m+1]=s[n-1][2m]+s[n-1][2m+1]$$

注意到，这两种转移在图上是这样表现的：

可以看出，这个问题就相当于求点 $(n,m)$ 到点 $(0,0)$ 的路径的总数。

再细致观察，图中的点大体上分为十字交叉的蓝点和一条直线上的黄点两种点。这两种点分别对应 $m$ 为奇数和偶数两种情况。

容易证明，从 $(0,0)$ 移动到 $(n,m)$ 只能移动 $n$ 步，且只有两种移动方式：

• 从 $(x,y)$ 移动到 $(x+1,y+1)$
• 从 $(x,y)$ 移动到 $(x+1,y)$

当 $y$ 为奇数时，只能选择第一种移动方式，当 $y$ 为偶数时，可以同时选择两种移动方式。

并且，除了第一步以外，所有第一种移动方式都是成对出现的，因为你会移动到 $y$ 为奇数的点，这样你又只能选择第一种移动方式。

所以，你采用的移动方式必然为：第一种移动方式，若干次第二种移动方式，第一种移动方式，第一种移动方式，若干次第二种移动方式…………第一种移动方式。

由于第一种移动方式是两两一组的，那么在它们之间的间隔，可以放零到若干次第二种移动方式。这样的间隔一共有 $\frac{m+1}{2}$ 个。

令 $a=n-m,b=\frac{m+1}{2}$，则答案为：$(\genfrac{}{}{0ex}{}{a+b-1}{b-1})$

接下来，我们只需要判断组合数的奇偶性即可。这里需要用到一个结论，即如果 $n\mathrm{\&}m==m$ 那么 $(\genfrac{}{}{0ex}{}{n}{m})$ 为奇数。

Code:

点击查看代码

#include
using namespace std;
int t,m,n;
int main(){
	cin >> t;
	while(t--){
		cin >> n >> m;
		if((m  & 1) == 0){
			m--,n--;
		}
		n = n - m / 2;
		m = (m + 1) / 2;
		n--,m--;
		if((n & m) == m)cout << "1\n";
		else cout << "0\n";
	}
}