Combinatorics |

2021 年计数题康复训练

Sat, 24 Jun 2023 11:00:56 +0000

技巧收集

将要计数的总体分成很多个部分，每个部分分别计算贡献。
有些时候一个集合 \(S\) 联合产生贡献，为了避免算重，可以将这个集合的贡献放在其中的某个元素上计算，比如标号最小的那一个。
可以考虑划分阶段，每次加入一个元素时计算答案增量。
如果需要计算在一个大的部分中选择一些状态的方案数，可以将这个大的部分分为几个，枚举在这几个部分中选择的状态数量，再分别计算并相乘。
可以先计算每一部分的答案，用某种数据结构维护，合并的时候考虑两个部分联合产生的答案。
如果子问题的答案容易计算，并且原问题与子问题之间存在容斥关系，可以用 \(\rm DP\) 计算，转移的时候容斥。

好题选做

方法一：

首先有一个直观的想法，计算每条线段对答案的贡献。

考虑将每个连通块的贡献放到这个连通块最左边的线段上去计算，于是我们发现在一种选择方案中，一条线段 \([l_{i},r_{i}]\) 有 \(1\) 的贡献当且仅当不存在另一条同时被选择的线段 \([l_{j},r_{j}]\) 满足 \(l_{j}\lt l_{i}\lt r_{j}\)，即其左端点不能被覆盖。

因为题目保证了所有端点互不相同，所以我们不需要经过比较复杂的分类讨论，直接将线段按左端点排序，右端点用线段树维护即可。

用线段树求出与当前线段不能同时选择的线段数，记为 \(x\)，则这条线段的贡献为 \(2^{n-x-1}\)。

总时间复杂度 \(\Theta(n\log n)\)。

#include<bits/stdc++.h>
using namespace std;

#define rep(i, l, r) for (int i = l; i <= r; i++)
#define dep(i, r, l) for (int i = r; i >= l; i--)

const int N = 1e5 + 10, mod = 1e9 + 7;

int n, Pow[N], ans;
pair <int, int> seg[N];

namespace ST {
#define LS (p << 1)
#define RS (p << 1 | 1)
int sum[N << 3], l[N << 3], r[N << 3];

void Build (int p, int L, int R) {
 l[p] = L, r[p] = R, sum[p] = 0;
 if (L == R) return;
 int mid = (L + R) >> 1;
 Build(LS, L, mid), Build(RS, mid + 1, R);
}

void add (int p, int pos) {
 if (l[p] == pos && r[p] == pos) {
 sum[p]++; return;
 }
 pos <= r[LS] ? add(LS, pos) : add(RS, pos);
 sum[p] = sum[LS] + sum[RS];
}

int Query (int p, int L, int R) {
 if (l[p] >= L && r[p] <= R) return sum[p];
 int res = 0;
 if (L <= r[LS]) res += Query(LS, L, R);
 if (R >= l[RS]) res += Query(RS, L, R);
 return res;
}
}

int main () {

 scanf("%d", &n);
 rep(i, 1, n) scanf("%d%d", &seg[i].first, &seg[i].second);

 Pow[0] = 1;
 rep(i, 1, n) Pow[i] = (Pow[i - 1] << 1) % mod;

 sort(seg + 1, seg + n + 1);
 ST::Build(1, 1, 2 * n);
 rep(i, 1, n) {
 ans = (ans + Pow[n - ST::Query(1, seg[i].first + 1, 2 * n) - 1]) % mod;
 ST::add(1, seg[i].second);
 }
 printf("%d\n", ans);

 return 0;
}

方法二：

还是考虑将线段按左端点排序后一个个加入并计算贡献，但是我们这次只考虑已经枚举了的 \(i\) 条线段的答案，记为 \(f_{i}\)。

可以发现，如果当前枚举的线段不选，那么答案为 \(f_{i-1}\)，否则在选择某一个集合的时候答案会 \(+1\)，而这个集合中的线段即为右端点小于当前线段左端点的线段，记其数量为 \(x\)。由于这个线段集合的每一个子集的答案都相比原来 \(+1\)，所以这种情况下的答案为 \(f_{i-1}+2^{x}\)。故总的转移式为 \(f_{i}=2f_{i-1}+2^{x}\)。

至于 \(x\) 的值可以很方便地在最开始用前缀和求出。

#include<bits/stdc++.h>
using namespace std;

#define rep(i, l, r) for (int i = l; i <= r; i++)
#define dep(i, r, l) for (int i = r; i >= l; i--)

const int N = 2e5 + 10, mod = 1e9 + 7;

int n, sum[N], Pow[N], ans;
pair <int, int> seg[N];

int main () {

 scanf("%d", &n);
 rep(i, 1, n) scanf("%d%d", &seg[i].first, &seg[i].second);

 Pow[0] = 1;
 rep(i, 1, n) Pow[i] = (Pow[i - 1] << 1) % mod;
 rep(i, 1, n) sum[seg[i].second]++;
 rep(i, 1, (n << 1)) sum[i] += sum[i - 1];

 sort(seg + 1, seg + n + 1);
 rep(i, 1, n) ans = (2 * ans % mod + Pow[sum[seg[i].first - 1]]) % mod;
 printf("%d\n", ans);

 return 0;
}

看上去很简单，代码也很简洁，但如果要证明而非直接打表的话是一个有一定难度的题。

首先观察到题目限制等价于 \(\forall i'\leqslant i,j'\leqslant j,A_{i,j}\subseteq A_{i',j'}\)。

又观察到如果对每个元素分开考虑，那么一定存在一条从左下到右上的分界线，使分界线左边的集合都有这个元素，而右边都没有，形如下图：

容易发现，对于每个元素，这样的路径与每种方案一一对应，并且路径数为 \(2^{n}\)。

进一步的，容易发现每个元素的方案相互独立，于是将每个元素的方案数相乘即为最终答案 \(2^{nk}\)。

总时间复杂度 \(\Theta(\log n)\)。

#include<bits/stdc++.h>
using namespace std;

const int mod = 1e9 + 7;

int n, k;

int Pow (int a, int k) {
 if (k == 1) return a;
 int S = Pow(a, k >> 1);
 if (k & 1) return 1ll * S * S % mod * a % mod;
 else return 1ll * S * S % mod;
}

int main () {

 scanf("%d%d", &n, &k);
 printf("%d\n", Pow(Pow(2, n), k));

 return 0;
}

首先考虑在一个 \(k\times k\) 的矩形上放置 \(k\) 个车的方案数，显然为 \(k!\)。

然后考虑在一个 \(n\times m\) 的矩形上放置 \(k\) 个车的方案数，可以先从 \(n\) 行 \(m\) 列中分别选出 \(k\) 行 \(k\) 列，再按照 \(k\times k\) 矩形的方式计算，方案数为 \(\binom{n}{k}\binom{m}{k}k!\)。

考虑将原图形划分成右边一个 \(c\times d\) 的矩形和左边一个 \(a\times (b+d)\) 的矩形，然后枚举在右边放置多少个车，可以发现右边每放置一个车都可以使左边能放置车的行减少一个，于是容易独立计算两边的方案数，故答案为 :

\[ \sum_{i=0}^d \dbinom{c}{i}\dbinom{d}{i}i!\dbinom{a}{k-i}\dbinom{b+d-i}{k-i}(k-i)! \]

总时间复杂度 \(\Theta(n)\)。

#include<bits/stdc++.h>
using namespace std;

#define rep(i, l, r) for (int i = l; i <= r; i++)
#define dep(i, r, l) for (int i = r; i >= l; i--)

const int N = 2e3 + 10, mod = 1e5 + 3;

int a, b, c, d, k, fac[N], inv[N], ans;

int Pow (int a, int k) {
 if (k == 0) return 1;
 if (k == 1) return a;
 int S = Pow(a, k >> 1);
 if (k & 1) return 1ll * S * S % mod * a % mod;
 else return 1ll * S * S % mod;
}

int C (int n, int m) {
 if (n < m) return 0;
 return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
}

int main () {

 fac[0] = 1;
 rep(i, 1, N - 1) fac[i] = 1ll * fac[i - 1] * i % mod;
 inv[N - 1] = Pow(fac[N - 1], mod - 2);
 dep(i, N - 2, 0) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;

 cin >> a >> b >> c >> d >> k;
 rep(i, 0, k) ans = (ans + 1ll * C(c, i) * C(d, i) % mod * fac[i] % mod * C(a, k - i) % mod * C(b + d - i, k - i) % mod * fac[k - i]) % mod;
 printf("%d\n", ans);

 return 0;
}

想这题时思路容易往如何建图上跑偏，但其实完全不用建图，直接对着原模型考虑即可。

考虑从底层往上加水的过程，容易发现一些联通块会逐渐被连接在一起，可以考虑用并查集维护，两个连通块合并的答案显然为原本答案的乘积加上 \(1\)，因为所有的点都加上水也是一种方案。

最终的答案即为所有连通块的方案数之积。

总时间复杂度 \(\Theta(nm\log (nm))\)。

#include<bits/stdc++.h>
using namespace std;

#define int long long
#define rep(i, l, r) for (int i = l; i <= r; i++)
#define dep(i, r, l) for (int i = r; i >= l; i--)
#define idx(x, y) ((x - 1) * m + y)

const int N = 1e3 + 10, mod = 1e9 + 7;

int n, m, fa[N * N], f[N * N], ans = 1;
char s[N][N];

int Find (int x) {
 if (x != fa[x]) fa[x] = Find(fa[x]);
 return fa[x];
}

signed main () {

 cin >> n >> m;
 rep(i, 1, n) cin >> s[i] + 1;

 rep(i, 1, n * m) fa[i] = i, f[i] = 1;
 dep(i, n - 1, 2) {
 rep(j, 3, m - 1) if (s[i][j] == '.' && s[i][j - 1] == '.') fa[Find(idx(i, j))] = Find(idx(i, j - 1));
 rep(j, 2, m - 1) if (s[i][j] == '.' && s[i + 1][j] == '.' && Find(idx(i, j)) != Find(idx(i + 1, j)))
 f[Find(idx(i, j))] = f[Find(idx(i, j))] * f[Find(idx(i + 1, j))] % mod, fa[Find(idx(i + 1, j))] = Find(idx(i, j));
 rep(j, 2, m - 1) if (s[i][j] == '.' && Find(idx(i, j)) == idx(i, j)) f[idx(i, j)]++;
 }

 rep(i, 2, n - 1) rep(j, 2, m - 1) if (Find(idx(i, j)) == idx(i, j)) ans = ans * f[idx(i, j)] % mod;
 cout << ans << endl;

 return 0;
}

运用插板法和捆绑法易得答案即为：

\[ (n + 2)! A_{n + 3}^{m} - 2 (n + 1)! A_{n + 2}^{m} \]

高精差评。

#include<bits/stdc++.h>
using namespace std;

#define rep(i, l, r) for (int i = l; i <= r; i++)
#define dep(i, r, l) for (int i = r; i >= l; i--)

const int N = 2e3 + 10;

namespace BigInt_Class {
const int MaxL = 5e3 + 10;

struct BigInt {
 int len, bit[MaxL];
 void Clear () {
 for (int i = 1; i <= len; i++) bit[i] = 0;
 len = 1;
 }
};

void read (BigInt &x) {
 char s[MaxL];
 scanf("%s", s + 1), x.len = strlen(s + 1);
 for (int i = 1; i <= x.len; i++)
 x.bit[i] = s[x.len - i + 1] - '0';
}

void Write (BigInt x, char End) {
 for (int i = x.len; i >= 1; i--)
 printf("%d", x.bit[i]);
 putchar(End);
}

bool operator < (BigInt a, BigInt b) {
 if (a.len != b.len) return a.len < b.len;
 for (int i = a.len; i >= 1; i--)
 if (a.bit[i] != b.bit[i])
 return a.bit[i] < b.bit[i];
 return false;
}

BigInt Change (int x) {
 BigInt res;
 res.Clear();
 if (x == 0) return res;
 else res.len = 0;
 while (x) res.bit[++res.len] = x % 10, x /= 10;
 return res;
}

BigInt operator + (BigInt a, BigInt b) {
 BigInt res;
 res.Clear();
 res.len = max(a.len, b.len);
 for (int i = 1; i <= res.len; i++)
 res.bit[i] = a.bit[i] + b.bit[i];
 for (int i = 1; i <= res.len; i++)
 if (res.bit[i] >= 10)
 res.bit[i] -= 10, res.bit[i + 1]++;
 if (res.bit[res.len + 1] > 0) res.len++;
 return res;
}

BigInt operator - (BigInt a, BigInt b) {
 BigInt res;
 res.Clear();
 res.len = max(a.len, b.len);
 for (int i = 1; i <= res.len; i++)
 res.bit[i] = a.bit[i] - b.bit[i];
 for (int i = 1; i <= res.len; i++)
 if (res.bit[i] < 0)
 res.bit[i] += 10, res.bit[i + 1]--;
 while (res.bit[res.len] == 0 && res.len > 1) res.len--;
 return res;
}

BigInt operator * (BigInt a, BigInt b) {
 BigInt res;
 res.Clear();
 res.len = a.len + b.len;
 for (int i = 1; i <= a.len; i++)
 for (int j = 1; j <= b.len; j++)
 res.bit[i + j - 1] += a.bit[i] * b.bit[j];
 for (int i = 1; i <= res.len; i++)
 if (res.bit[i] >= 10)
 res.bit[i + 1] += res.bit[i] / 10, res.bit[i] %= 10;
 while (res.bit[res.len] == 0 && res.len > 1) res.len--;
 return res;
}

BigInt operator / (BigInt a, BigInt b) {
 BigInt res, tmp;
 res.Clear();
 if (a < b) return res;
 res.len = a.len - b.len + 1;
 for (int i = a.len; i >= b.len; i--) {
 tmp.Clear(), tmp.len = i;
 for (int j = 1; j <= b.len; j++)
 tmp.bit[j + i - b.len] = b.bit[j];
 while (!(a < tmp)) a = a - tmp, res.bit[i - b.len + 1]++;
 }
 while (res.bit[res.len] == 0 && res.len > 1) res.len--;
 return res;
}

BigInt operator % (BigInt a, BigInt b) {
 BigInt tmp;
 if (a < b) return a;
 for (int i = a.len; i >= b.len; i--) {
 tmp.Clear(), tmp.len = i;
 for (int j = 1; j <= b.len; j++)
 tmp.bit[j + i - b.len] = b.bit[j];
 while (!(a < tmp)) a = a - tmp;
 }
 return a;
}
}
using namespace BigInt_Class;

int n, m;
BigInt fac[N];

BigInt A (int n, int m) { return n < m ? Change(0) : fac[n] / fac[n - m]; }

int main () {

 cin >> n >> m;

 fac[0] = Change(1);
 rep(i, 1, n + 3) fac[i] = fac[i - 1] * Change(i);

 Write(fac[n + 2] * A(n + 3, m) - Change(2) * fac[n + 1] * A(n + 2, m), '\n');

 return 0;
}

看到题目一眼二项式反演，但事实上是不行的。

考虑钦点 \(m\) 个位置 \(a_{i}=i\)，剩下的显然是 \(n - m\) 个数的错排问题。

记 \(D_{n}\) 表示 \(n\) 个数的错排问题方案数，推导其递推式：

考虑在 \(n\) 个数的基础上再加入第 \(n + 1\) 个数，不妨设 \(a_{n+1}=k\)。

接下来对 \(a_{k}\) 做分类讨论：

如果 \(a_{k}=n+1\)，那么 \(k\) 和 \(n+1\) 互相占用，剩下的方案数为 \(D_{n-1}\)。
如果 \(a_{k}\not = n + 1\)，那么除了 \(a_{n + 1}\) 已经被确定之外，其它所有位置都有且仅有一个数不能填（位置 \(k\) 不能填的数为 \(n + 1\)），于是方案即为 \(D_{n}\)。

再考虑到选取 \(k\) 的方式有 \(n\) 种，故 \(\{D_{n}\}\) 的递推式为：

\[ D_{n + 1} = n(D_n + D_{n - 1}) \]

根据错排数列的定义易知 \(D_{0} = 1, D_{1} = 0,D_{2} = 1\)。

综上，答案即为 \(\binom{n}{m}D_{n-m}\)。

总时间复杂度 \(\Theta(T+n)\)。

#include<bits/stdc++.h>
using namespace std;

#define rep(i, l, r) for (int i = l; i <= r; i++)
#define dep(i, r, l) for (int i = r; i >= l; i--)

const int N = 1e6 + 10, mod = 1e9 + 7;

int T, n, m, fac[N], inv[N], D[N];

int Pow (int a, int k) {
 if (k == 0) return 1;
 if (k == 1) return a;
 int S = Pow(a, k >> 1);
 if (k & 1) return 1ll * S * S % mod * a % mod;
 else return 1ll * S * S % mod;
}

int C (int n, int m) {
 if (n < m) return 0;
 return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
}

int main () {

 fac[0] = 1;
 rep(i, 1, N - 1) fac[i] = 1ll * fac[i - 1] * i % mod;
 inv[N - 1] = Pow(fac[N - 1], mod - 2);
 dep(i, N - 2, 0) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;

 D[0] = 1, D[1] = 0, D[2] = 1;
 rep(i, 3, N - 1) D[i] = 1ll * (i - 1) * (D[i - 1] + D[i - 2]) % mod;

 scanf("%d", &T); while (T--) {
 scanf("%d%d", &n, &m);
 printf("%lld\n", 1ll * C(n, m) * D[n - m] % mod);
 }

 return 0;
}

考虑到一段区间内的方案数是独立的，于是使用区间 \(\rm DP\) 求解。

可以发现我们关心的状态除了区间端点 \(l,r\) 外，还有上一个填入值的大小，因为这关系到现在这个数填在左边还是右边。同时，我们观察到，上一个数只有可能填在区间的左端点或右端点，于是记 \(f_{l,r,0/1}\) 表示在 \([l,r]\) 这段区间内，上一次填的数在左端点\(/\)右端点的方案数。

转移是简单的，分 \(4\) 种情况：

\(a_{i}\lt a_{i + 1},f_{i,j,0}\leftarrow f_{i+1,j,0}\)
\(a_{i}\lt a_{j},f_{i,j,0}\leftarrow f_{i+1,j,1}\)
\(a_{j}\gt a_{i},f_{i,j,1}\leftarrow f_{i,j-1,0}\)
\(a_{j}\gt a_{j-1},f_{i,j,1}\leftarrow f_{i,j-1,1}\)

需要注意的是，赋初值时，可以钦点 \([i,j]\) 的数是从左端点填进去的，即 \(f_{i,i,0} = 1\)，如果不这样做的话会算重。

总时间复杂度 \(\Theta(n^{2})\)。

#include<bits/stdc++.h>
using namespace std;

#define rep(i, l, r) for (int i = l; i <= r; i++)
#define dep(i, r, l) for (int i = r; i >= l; i--)

const int N = 1e3 + 10, mod = 19650827;

int n, a[N], f[N][N][2];

int main () {

 cin >> n;
 rep(i, 1, n) cin >> a[i];

 rep(i, 1, n) f[i][i][0] = 1;
 rep(len, 2, n) for (int i = 1; i + len - 1 <= n; i++) {
 int j = i + len - 1;
 if (a[i] < a[i + 1]) f[i][j][0] = (f[i][j][0] + f[i + 1][j][0]) % mod;
 if (a[i] < a[j]) f[i][j][0] = (f[i][j][0] + f[i + 1][j][1]) % mod;
 if (a[j] > a[i]) f[i][j][1] = (f[i][j][1] + f[i][j - 1][0]) % mod;
 if (a[j] > a[j - 1]) f[i][j][1] = (f[i][j][1] + f[i][j - 1][1]) % mod;
 }

 cout << (f[1][n][0] + f[1][n][1]) % mod << endl;

 return 0;
}

形式化题意：

定义全集 \(U=\{1,2,3,\cdots ,n\}\)，要从中选出 \(m\) 个子集，满足：

任意子集非空。
子集互不相同。
在选出的 \(m\) 个子集中，\(1\sim n\) 中每个数的出现次数均为偶数。

求方案数对 \(10^{8} + 7\) 取模后的值。

保证 \(n,m\leqslant 10^{6}\)。

考虑计算选出子集有序的方案数，容易发现最后将方案数除以 \(m!\) 就与原问题等价。

记 \(f_{i}\) 表示从 \(U\) 中选出 \(i\) 个合法子集的方案数，转移考虑容斥：

如果前面的 \(i - 1\) 个集合已经确定，那么这个集合中每个元素是否存在就已经被确定了，并且一定存在一种选择这个集合的方案，故在不考虑子集非空和子集互不相同的情况下，方案数为 \(A_{2^{n} - 1}^{i - 1}\)。

考虑将第 \(i\) 个集合为空的方案去除。可以发现在第 \(i\) 个集合为空的情况下，不合法方案与 \(f_{i - 1}\) 中的每种合法方案一一对应，故第 \(i\) 个集合为空的方案数为 \(f_{i - 1}\)。

考虑将第 \(i\) 个集合与前面某个集合 \(S_{j}\) 相同的方案去除。可以发现，将 \(S_{i}\) 和 \(S_{j}\) 同时去除后的方案还是合法的，且数量为 \(f_{i - 2}\)。 \(j\) 有 \(i - 1\) 种取值，\(S_{i}\) 和 \(S_{j}\) 由于不能与另外 \(i - 2\) 个集合相同，所以有 \((2^{n} - 1) - (i - 2)\) 种取法。故第 \(i\) 个集合与之前某个集合相同的方案数为 \(f_{i - 2}\times (i - 1)\times (2^{n} - i + 1)\)。

故转移方程为：

\[ f_{i} = A_{2^n - 1}^{i - 1} - f_{i - 1} - f_{i - 2}\times (i - 1)\times (2^n - i + 1) \]

经过一些预处理后可以做到 \(\Theta(n)\)。

#include<bits/stdc++.h>
using namespace std;

#define rep(i, l, r) for (int i = l; i <= r; i++)
#define dep(i, r, l) for (int i = r; i >= l; i--)

const int N = 1e6 + 10, mod = 1e8 + 7;

int n, m, A[N], f[N], M;

int Pow (int a, int k) {
 if (k == 0) return 1;
 if (k == 1) return a;
 int S = Pow(a, k >> 1);
 if (k & 1) return 1ll * S * S % mod * a % mod;
 else return 1ll * S * S % mod;
}

int main () {

 cin >> n >> m;

 A[0] = Pow(2, n), A[1] = A[0] - 1;
 rep(i, 2, m) A[i] = 1ll * A[i - 1] * (A[0] - i) % mod;

 f[0] = 1;
 rep(i, 2, m) f[i] = (A[i - 1] - f[i - 1] - 1ll * f[i - 2] * (i - 1) % mod * (A[0] - i + 1)) % mod;

 M = 1;
 rep(i, 1, m) M = 1ll * M * i % mod;

 cout << (1ll * f[m] * Pow(M, mod - 2) % mod + mod) % mod << endl;

 return 0;
}

可以发现是这个题的弱化版，但区别不算很大。

考虑依据偏序关系连边，可以发现构成一颗满足小根堆性质的树。

记 \(f_{i}\) 表示以点 \(i\) 为根的子树的方案数，显然子树内答案独立，故只需要考虑乘上分配给子树的方案数即可得：

\[ siz_i = siz_{2i} + siz_{2i + 1} + 1 \]\[ f_i = f_{2i}\times f_{2i + 1}\times \dbinom{siz_i - 1}{siz_{2i}} \]

因为模数有可能小于 \(n\)，所以求组合数需要用到 \(\rm Lucas\) 定理。

需要注意的是，在预处理阶乘逆元的时候最多预处理到 \(\rm mod - 1\)，否则会出现为 \(0\) 的情况。

总时间复杂度 \(\Theta(n\log n)\)。

#include<bits/stdc++.h>
using namespace std;

#define rep(i, l, r) for (int i = l; i <= r; i++)
#define dep(i, r, l) for (int i = r; i >= l; i--)

const int N = 2e6 + 10;

int n, mod, Min, fac[N], inv[N], siz[N], f[N];

int Pow (int a, int k) {
 if (k == 0) return 1;
 if (k == 1) return a;
 int S = Pow(a, k >> 1);
 if (k & 1) return 1ll * S * S % mod * a % mod;
 else return 1ll * S * S % mod;
}

int Lucas (int n, int m) {
 if (n < mod && m < mod) {
 if (n < m) return 0;
 return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
 }
 return 1ll * Lucas(n / mod, m / mod) * Lucas(n % mod, m % mod) % mod;
}

int main () {

 cin >> n >> mod, Min = min(n, mod - 1);

 fac[0] = 1;
 rep(i, 1, Min) fac[i] = 1ll * fac[i - 1] * i % mod;
 inv[Min] = Pow(fac[Min], mod - 2);
 dep(i, Min - 1, 0) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;

 rep(i, 1, n) siz[i] = 1;
 dep(i, n, 1) siz[i] += siz[i << 1] + siz[i << 1 | 1];
 rep(i, ((n + 1) >> 1), n) f[i] = 1;
 dep(i, ((n + 1) >> 1) - 1, 1) {
 f[i] = 1ll * f[i << 1] * f[i << 1 | 1] % mod * Lucas(siz[i] - 1, siz[i << 1]) % mod;
 }

 printf("%d\n", f[1]);

 return 0;
}

Prufer 序列

Sat, 24 Jun 2023 11:00:56 +0000

Prufer 序列的定义

\(\rm Prufer\) 序列可以将一颗结点数为 \(n\) 的有标号无根树用一个长度为 \(n-2\)，值域为 \([1,n]\) 的数列唯一表示，即有标号无根树和 \(\rm Prufer\) 序列呈双射关系。

具体来说，有标号无根树的构建方式如下：

选择一个编号最小的叶子节点，并将其删除。
将这个叶子节点所连接的点的编号加入 \(\rm Prufer\) 序列中。
重复以上步骤 \(n-2\) 次，直到树上只剩下 \(2\) 个点。

这是某一颗点数为 \(n\) 的有标号无根树的 \(\rm Prufer\) 序列的构造过程：

快速求解 Prufer 序列

由其过程，显然有一个使用堆优化的 \(\Theta(n\log n)\) 做法，但 \(\rm Prufer\) 序列其实可以线性构造。

记录所有点的度数和一个指针 \(p\) 指向编号最小的叶子节点，进行以下操作：

将 \(p\) 指向的结点删除，检查是否出现了新的叶结点。
如果产生了新的叶结点，记其编号为 \(x\)。若 \(x\gt p\)，则不做任何操作，否则将其删除，并检查删除 \(x\) 以后是否出现了新的叶结点，重复这一步操作直到没有产生新的叶结点或新产生的结点编号大于 \(p\)。
让 \(p\) 自增直到遇见下一个叶结点为止。
重复以上操作直到结点数为 \(2\) 可以得到这棵树的 \(\rm Prufer\) 序列。

可以发现，在算法流程中，每条边只在其连接的外层结点被删除时被遍历过一次，并且 \(p\) 单调递增，树中的节点数单调递减，所以每个点也只被遍历过一次。

总时间复杂度 \(\Theta(n)\)。

快速还原 Prufer 序列

显然还是有一个堆优化的 \(\Theta(n\log n)\) 做法。

从前到后枚举 \(\rm Prufer\) 序列中的每一个数，维护不在序列中的结点编号的最小值。显然不在序列中的是叶子节点，并且其最小值为最后一个加入的，于是将其与当前枚举的序列中的数连边。连边后若序列中已没有枚举的这个数，那么将其踢出序列作为新的叶子结点。

考虑以与之前构造 \(\rm Prufer\) 序列相同的方法构造线性做法。

记一个指针 \(p\) 指向不在序列中的最小结点，如果将其连向序列中枚举的位置，并将枚举的位置删除。序列中没有这个结点了，那么如果被删除的结点比 \(p\) 小，直接将其与现在序列中枚举的数连边后将其删除，重复操作。如果这个结点的值大于 \(p\)，那么不用管它，在后面它一定会被枚举到。

显然，这种算法的时间复杂度为 \(\Theta(n)\)。

Prufer 序列的应用

Cayley 公式

完全图 \(K_{n}\) 有 \(n^{n-2}\) 颗生成树。

证明方法很多，其中最简单的应该是利用 \(\rm Prufer\) 序列。

考虑到任何一个长度为 \(n-2\) 的 \(\rm Prufer\) 序列唯一对应一颗大小为 \(n\) 的有标号无根树，于是考虑计算长度为 \(n-2\) 的 \(\rm Prufer\) 序列的数量，又因为其值域为 \([1,n]\)，故总方案数为 \(n^{n-2}\)。

限定度数的有标号无根树计数

求有 \(n\) 个结点，且第 \(i\) 个结点的度数为 \(d_{i}\) 的有标号无根树的数量。

考虑到一个点的度数为其在 \(\rm Prufer\) 序列中出现次数 \(+1\)，于是对于一个度数为 \(d_{i}\) 的点，其在 \(\rm Prufer\) 序列中的出现次数应为 \(d_{i}-1\)，故存在这样的有标号无根树当且仅当 \(\sum_{i=1}^{n} d_{i}-1=n-2\)，并且这样的树的数量为：

\[ \dbinom{n-2}{d_1-1,d_2-1,\cdots ,d_n-1}=\frac{(n-2)!}{(d_1-1)!(d_2-1)!\cdots (d_n-1)!} \]

十二类基本组合问题

Sat, 24 Jun 2023 11:00:56 +0000

小球入盒问题是所有组合问题的基础，它计算的是形如 “\(n\) 个球放进 \(m\) 个盒子的方案数” 的一类问题，在这类问题中一般存在三种限制：

小球是否有编号。
盒子是否有编号。
盒子中球的数量是无限制，至少一个还是至多一个。

记有编号为 \(L\rm(labelled)\)，无编号为 \(U\rm(unlabelled)\)，盒子中球的数量限制分别为 \(A,B,C\)，这样我们就可以将一个问题用三个字母简记，如 \(\rm LUB\) 表示将 \(n\) 个有标号小球放进 \(m\) 个无标号盒子里，每个盒子中至少有一个球的方案数。

可以发现问题共有 \(12\) 类，现在我们来一个个分析。

Part1 LLA

将 \(n\) 个有标号的球放进 \(m\) 个有标号的盒子里，每个盒子中球的数量没有限制的方案数。

可以看作每次从 \(m\) 个盒子里任选一个，一共要放 \(n\) 次，没有其他限制，故方案数为：

\[ \boxed{m^n} \]

Part2 ULA

将 \(n\) 个无标号的球放进 \(m\) 个有标号的盒子里，每个盒子中球的数量没有限制的方案数。

在这个问题中我们只关心对每个盒子里面球的数量，所以这个问题的方案数等于方程 \(x_{1}+x_{2}+\cdots +x_{m}=n\) 非负整数解的数量，用隔板法可以求得其为：

\[ \boxed{\dbinom{n+m-1}{m-1}} \]

Part3 ULB

将 \(n\) 个无标号的球放进 \(m\) 个有标号的盒子里，每个盒子中球的数量至少为 \(1\) 的方案数。

这个问题与上个问题相似，方案数等于方程 \(x_{1}+x_{2}+\cdots +x_{m}=n\) 正整数解的数量，用隔板法可以求得其为：

\[ \boxed{\dbinom{n-1}{m-1}} \]

Part4 LLC

将 \(n\) 个有标号的球放进 \(m\) 个有标号的盒子里，每个盒子中球的数量至多为 \(1\) 的方案数。

我们发现这个问题等价于依次为每个球选择一个盒子，故答案为：

\[ \boxed{m^{\underline{n}}} \]

Part5 ULC

将 \(n\) 个无标号的球放进 \(m\) 个有标号的盒子里，每个盒子中球的数量至多为 \(1\) 的方案数。

相当于是为每一个盒子选择数量，等价于从 \(m\) 个盒子中选出 \(n\) 个，让它的数量为 \(1\)，故方案数为：

\[ \boxed{\dbinom{m}{n}} \]

Part6 LUC

将 \(n\) 个有标号的球放进 \(m\) 个无标号的盒子里，每个盒子中球的数量至多为 \(1\) 的方案数。

盒子顺序可以任意交换，所以任意一种方案都等价，发现当球数超过盒子数时无解，故方案数为：

\[ \boxed{[n\leqslant m]} \]

Part7 UUC

将 \(n\) 个无标号的球放进 \(m\) 个无标号的盒子里，每个盒子中球的数量至多为 \(1\) 的方案数。

理由同上，方案数为：

\[ \boxed{[n\leqslant m]} \]

Part8 LLB

将 \(n\) 个有标号的球放进 \(m\) 个有标号的盒子里，每个盒子中球的数量至少为 \(1\) 的方案数。

考虑使用容斥原理，枚举有多少个盒子为空，剩下的盒子随便填，故方案数为：

\[ \boxed{\sum_{i=0}^m(-1)^i\dbinom{m}{i}(m-i)^n} \]

利用 \(\rm Part9\) 中讲到的第二类斯特林数也可以 \(\rm LLB\) 问题的方案数表示为：

\[ \boxed{\begin{Bmatrix}n\\ m\end{Bmatrix}m!} \]

Part9 LUB

将 \(n\) 个有标号的球放进 \(m\) 个无标号的盒子里，每个盒子中球的数量至少为 \(1\) 的方案数。

只需要将 \(m\) 个盒子排序产生的方案去除即可，故方案数为 :

\[ \boxed{\sum_{i=0}^m\frac{(-1)^i(m-i)^n}{i!(m-i)!}} \]

\(\rm LUB\) 问题的答案被定义为 “第二类斯特林数”，递推式如下：

\[ \boxed{\begin{Bmatrix}n\\ m\end{Bmatrix}=m\begin{Bmatrix}n-1\\ m\end{Bmatrix}+\begin{Bmatrix}n-1\\ m-1\end{Bmatrix}} \]

其含义为考虑新加入一个有标号小球，可以将其加入之前的任意一个盒子，也可以为它单独开一个盒子，方案数相加。

Part10 LUA

将 \(n\) 个有标号的球放进 \(m\) 个无标号的盒子里，每个盒子中球的数量无限制的方案数。

记 \(\rm LUA\) 问题的方案数为 \(B_{n}\)，读作贝尔数。因为若某个盒子为空可以看作没有这个盒子，故 \(B_{n}\) 表示将 \(n\) 个数划分成任意个集合的方案数，有：

\[ \boxed{B_n=\sum_{i=1}^n\begin{Bmatrix}n\\ i\end{Bmatrix}} \]

同时，我们发现它也可以递推，有递推式：

\[ \boxed{B_{n+1}=\sum_{i=0}^n\dbinom{n}{i}B_i} \]

其含义为第 \(n+1\) 个数若和之前的 \(i\) 个数放在一起，方案数为 \(\tbinom{n}{i}B_{n-i}\)。

Part11 UUA

将 \(n\) 个无标号的球放进 \(m\) 个无标号的盒子里，每个盒子中球的数量无限制的方案数。

我们发现其实这就是划分数，求法如下：

记 \(f_{i,j}\) 表示将 \(i\) 划分成不超过 \(j\) 的数的方案数，当计算 \(f_{i,j}\) 时，其方案数可以从 \(f_{i-j,j}\) 继承，表示分出去一个大小为 \(j\) 的数，其方案数也可以从 \(f_{i,j-1}\) 继承，表示不选大小为 \(j\) 的数。故有转移方程：

\[ f_{i,j}=f_{i-j,j}+f_{i,j-1} \]

我们发现 \(f\) 的转移就是一个完全背包，所以考虑将其改写为一维形式，即：

\[ f_j=\sum_{i=1}^nf_{j-i} \]

记 \(g_{i,j}\) 表示将 \(i\) 划分成 \(j\) 个数的方案，当计算 \(g_{i,j}\) 时，其方案数可以从 \(g_{i-j,j}\) 继承，表示将所有数 \(+1\)，其方案数也可以从 \(g_{i-1,j-1}\) 继承，表示新增一个大小为 \(1\) 的数。我们发现后增加的数一定比前增加的数小，所以不重，这样一定能遍历到所有合法的划分，所以不漏，故有转移方程：

\[ g_{i,j}=g_{i-j,j}+g_{i-1,j-1} \]

这两种方式都可以做到 \(\Theta(n^{2})\)。

我们分析两种方式的优劣，发现第一种算法主要依赖于划分成的数大小的上界，第二种算法主要依赖于划分成数的数量，于是考虑根号分治。将问题看成一个完全背包，物品按照占用空间小于等于 \(\sqrt{n}\) 和大于 \(\sqrt{n}\) 分类即可。

同时，由于 \(g\) 计算的只有物品占用空间大于 \(\sqrt{n}\) 的情况，所以转移方程要改写成 :

\[ g_{i,j}=g_{i-j,j}+g_{i-\sqrt{n},j-1} \]

每次加入一个 \(\sqrt{n}\) 就可以保证所有数都大于 \(\sqrt{n}\) 了。

最后统计答案的时候直接枚举 \(i\)，然后将 \(f_{i}\) 和 \(g_{n-i,k}\) 乘起来即可。

时间复杂度 \(\Theta(n\sqrt{n})\)。

Part12 UUB

将 \(n\) 个无标号的球放进 \(m\) 个无标号的盒子里，每个盒子中球的数量至少为 \(1\) 的方案数。

我们发现只需要先在每个盒子中放 \(1\) 个球就可以了，等价于 \(\rm UUA\) 问题中 \(n-m\) 个球，\(m\) 个盒子的情况。

生成函数

Sat, 24 Jun 2023 11:00:56 +0000

普通生成函数

序列 \(a\) 的普通生成函数 \(\rm(Ordinary\ Generating\ Function,OGF)\) 被定义为形式幂级数：

\[ F(x) = \sum _n a_n x ^ n \tag{1.0.1} \]

\(a\) 既可以是有穷序列也可以是无穷序列，\(x\) 不具有实际意义，仅作为一个形式上的变量参与运算。

两种基本形式

加法与乘法

假设两个序列 \(a,b\) 的 \(\rm OGF\) 分别为 \(F(x),G(x)\)。

加减不必多说：

\[ F(x) \pm G(x) = \sum _n (a_n \pm b_n) x ^ n \tag{1.1.1} \]

乘法用卷积定义：

\[ F(x)G(x) = \sum _n x ^ n \sum _{i = 0} ^n a_ib_{n - i} \tag{1.1.2} \]

封闭形式

在使用生成函数的过程中，我们不会一直使用形式幂级数形式，有时候会为了计算方便将其替换成封闭形式。

\(F(x) = \sum_{n} x^{n}\)

\[ F(x) - xF(x) = 1 \]\[ F(x) = \frac{1}{1 - x} \tag{1.2.1} \]

\(F(x) = \sum_{n} q^{n} x^{n}\)

\[ F(x) - qxF(x) = 1 \]\[ F(x) = \frac{1}{1 - qx} \tag{1.2.2} \]

\(F(x) = \sum_{n} (n + 1)x^{n}\)

\[ \begin{aligned} F(x) &= \sum _{n \geqslant 1} nx ^ {n - 1}\\ &= \sum _ {n} (x ^ n)'\\ &= \left(\frac{1}{1 - x}\right)' \end{aligned} \]\[ F(x) = \frac{1}{(1 - x) ^ 2} \tag{1.2.3} \]

\(F(x) = \sum_{n} \binom{m}{n} x^{n}\)

\[ F(x) = (1 + x) ^ m \tag{1.2.4} \]

\(F(x) = \sum_{n} \binom{n + m}{n} x^{n}\)

\[ F(x) = \frac{1}{(1 - x) ^ {m + 1}} \tag{1.2.5} \]

考虑归纳证明：

显然当 \(m = 0\) 时，有 \(F(x) = \sum_{n} \binom{n}{n} x^{n} = \frac{1}{1 - x}\)。

当 \(m \gt 0\) 时：

\[ \begin{aligned} \frac{1}{(1 - x) ^ {m + 1}} &= \frac{1}{(1 - x) ^ m}\frac{1}{1 - x}\\ &= \left[\sum _ n \dbinom{m + n - 1}{n} x ^ n\right] \left(\sum _n x ^ n\right)\\ &= \sum _ n x ^ n \sum _ {i = 0} ^ n \dbinom{m + i - 1}{i}\\ &= \sum _ n \dbinom{m + n}{n} x ^ n \end{aligned} \]

关于上述推导过程中最后一步用到的组合恒等式：

\[ \sum _ {i = 0} ^ n \dbinom{m + i - 1}{i} = \dbinom{m + n}{n} \tag{1.2.6} \]

考虑其组合意义，左边相当于将 \(i\) 个无标号石子放进 \(m\) 个有标号盒子里，盒子允许为空的方案数。

考虑将 \(n\) 个石子放进 \(m + 1\) 个盒子中的方案数，规则同上，显然方案数为 \(\binom{m + n}{n}\)。假设从 \(m + 1\) 个盒子中取出一个，枚举要将 \(n\) 个石子中的多少个放入剩下的 \(m\) 个盒子中，剩余的石子就只能放进取出的盒子中了，则方案数为 \(\sum_{i = 0}^{n} \binom{m + i - 1}{i}\)。故组合恒等式 \((1.2.6)\) 得证。

还有另一种仅通过组合意义证明式 \((1.2.5)\) 的方法：

可以发现 \(\frac{1}{(1 - x)^{m + 1}} = \left(\frac{1}{1 - x}\right)^{m + 1}\)，相当于将初始仅有 \(a_{0} = 1\) 的序列做了 \(m + 1\) 遍前缀和。又因为每做一遍前缀和的组合意义是一个位置可以走到任意一个不在自己左边的位置，所以实际上 \(\frac{1}{(1 - x)^{m + 1}}\) 的第 \(n\) 项系数即为从 \(0\) 开始，每次向右走非负整数步，走 \(m + 1\) 步到达 \(n\) 的方案数。归约到一个更加经典的问题，就是不定方程 \(\sum_{i = 1}^{m + 1} x_{i} = n\) 的非负整数解数量，众所周知，其值为 \(\binom{m + n}{n}\)。

部分分式定理

在上文中，我们已经知道了形如 \(F(x) = \frac{1}{(1 - qx)^{m}}\) 的部分分式可以简单地被转换为形式幂级数形式，于是我们想找到一种方法能够将形如 \(\frac{P(x)}{Q(x)}\) 的一般分式拆成若干个部分分式之和。

部分分式定理指出，如果 \(\deg P \lt \deg Q\)，那么可以先将 \(Q(x)\) 因式分解，然后使用待定系数法构造若干个形如 \(\frac{A}{(1 - ax)^{p}}\) 的式子，使它们的和为 \(\frac{P(x)}{Q(x)}\)。

例如 \(F(x) = \frac{P(x)}{(x - 1)^{2} (x + 2)}\)，那么构造 \(\frac{A}{x - 1} + \frac{B}{(x - 1)^{2}} + \frac{C}{x + 2} = \frac{P(x)}{(x - 1)^{2} (x + 2)}\)。

两个经典数列的生成函数

斐波那契数列

斐波那契数列 \(\rm(Fibonacci\ Sequence)\) 被定义为 \(a_{0} = 0, a_{1} = 1,a_{n} = a_{n - 1} + a_{n - 2}(n \gt 1)\)。

设 \(F(x) = \sum_{n} a_{n} x^{n}\)，显然有：

\[ F(x) = xF(x) + x ^ 2 F(x) - a_0x + a_1x + a_0 \]

解得：

\[ F(x) = \frac{x}{1 - x - x ^ 2} \tag{1.3.1} \]

考虑使用部分分式定理，观察到分母多项式次数为 \(2\)，那么设：

\[ \frac{A}{1 - ax} + \frac{B}{1 - bx} = \frac{x}{1 - x - x ^ 2} \]

解得：

\[ \begin{aligned} F(x) &= \frac{x}{1 - x - x ^ 2}\\ &= \frac{\frac{\sqrt{5}}{5}}{1 - \frac{1 + \sqrt{5}}{2}x} + \frac{-\frac{\sqrt{5}}{5}}{1 - \frac{1 - \sqrt{5}}{2}x}\\ &= \sum _ n x ^ n \frac{\sqrt{5}}{5}\left[\left(\frac{1 + \sqrt{5}}{2}\right) ^ n - \left(\frac{1 - \sqrt{5}}{2}\right) ^ n\right] \end{aligned} \]

于是上式即为斐波那契数列的形式幂级数形式和通项。

卡特兰数

首先引入牛顿二项式定理。

让我们重定义组合数的运算：

\[ \dbinom{r}{k} = \frac{r ^ {\underline{k}}}{k!}~~(r \in \mathbb{C}, k \in \mathbb{N}) \tag{1.3.3} \]

在这种情况下，对于 \(\alpha \in \mathbb{C}\)，有：

\[ (1 + x) ^ {\alpha} = \sum _n \dbinom{\alpha}{n} x ^ n \tag{1.3.4} \]

对于卡特兰数序列，令 \(a_{0} = a_{1} = 1, a_{n} = \sum\limits_{i = 0}^{n - 1} a_{i} \times a_{n - i - 1}(n \gt 1)\)

令其 \(\rm OGF\) 为 \(F(x) = \sum\limits_{n} a^{n} x^{n}\)。

不难发现其递推式是一个卷积的形式，于是有：

\[ xF ^ 2(x) + 1 = F(x) \]

解之得：

\[ F(x) = \frac{1 \pm \sqrt{1 - 4x}}{2x} \tag{1.3.5} \]

要保留哪个根呢？

求解上式在 \(x \to 0\) 时的极限可以发现，当 \(F(x) = \dfrac{1 + \sqrt{1 - 4x}}{2x}\) 时不收敛。

原因是：

\[ F(x) = \dfrac{1 + \sqrt{1 - 4x}}{2x} = \frac{2}{1 - \sqrt{1 - 4x}} \]

则有：

\[ \lim\limits_{x \to 0 ^ {+}} \frac{2}{1 - \sqrt{1 - 4x}} = \infty \]\[ \lim\limits_{x \to 0 ^ {-}} \frac{2}{1 - \sqrt{1 - 4x}} = -\infty \]

故此时 \(x \to 0\) 时极限不存在。

因此可以得到：

\[ F(x) = \dfrac{1 - \sqrt{1 - 4x}}{2x} \tag{1.3.6} \]

将分子部分单独拿出来考虑，令 \(G(x) = 1 - \sqrt{1 - 4x} = 1 - (1 - 4x)^{\frac{1}{2}}\)，使用牛顿二项式定理展开：

\[ \begin{aligned} G(x) &= 1 - \sum\limits_{n \geqslant 0} \dbinom{\frac{1}{2}}{n} (-4x) ^ n \\ &= 1 - \sum\limits_{n \geqslant 0} \frac{\frac{1}{2} ^ {\underline n}}{n!} (-4x) ^ n \\ &= 1 - \sum\limits_{n \geqslant 0} \frac{\frac{1}{2} \times (-\frac{1}{2}) \times (-\frac{3}{2}) \times \cdots \times (-\frac{2n - 3}{2})}{n!} (-4x) ^ n \\ \end{aligned} \]

特别要注意的是 \(\binom{\frac{1}{2}}{0} = \frac{\frac{1}{2}^{0}}{0!} = 1\) 但是用上面那个式子是不正确的，因此需要特别考虑：

\[ \begin{aligned} G(x) &= \sum\limits_{n \geqslant 1} (-1) ^ {2n - 1} \frac{(2n - 3)!!}{n!2 ^ n} (4x) ^ n \\ &= \sum\limits_{n \geqslant 1} \frac{(2n - 2)!}{n!(2n - 2)!!2 ^ n} (4x) ^ n \\ &= \sum\limits_{n \geqslant 1} \frac{2(2n - 2)!}{n!(n - 1)!} x ^ n \\ &= \sum\limits_{n \geqslant 1} \frac{\binom{2n - 1}{n}}{2n - 1} 2x ^ n \end{aligned} \]

带回原式有：

\[ \begin{aligned} F(x) &= \frac{\sum\limits_{n \geqslant 1} \frac{\binom{2n - 1}{n}}{2n - 1} 2x ^ n}{2x} \\ &= \sum\limits_{n \geqslant 0} \frac{\binom{2n + 1}{n + 1}}{2n + 1} x ^ n \\ &= \sum\limits_{n \geqslant 0} \frac{\binom{2n}{n}}{n + 1} x ^ n \end{aligned} \tag{1.3.9} \]

因此可知 \(a_{n} = \dfrac{\binom{2n}{n}}{n + 1}\)。

欧拉变换

考虑求解形如下式的 \(\rm OGF\) ：

\[ F_i(x) = \left(\sum _ j x ^ {ji}\right) ^ {f _ i} = \left(\frac{1}{1 - x ^ i}\right) ^ {f _ i} \tag{2.3.1} \]\[ \varepsilon\circ F(x) = \prod _ i F_i(x) = \prod _ i \left(\frac{1}{1 - x ^ i}\right) ^ {f _ i} \tag{2.3.2} \]

这个 \(\rm OGF\) 的组合意义是将 \(n\) 个互不区分的小球分进若干个非空集合，大小为 \(i\) 的集合有 \(f_{i}\) 种方案的总方案数。

注意到式 \((2.3.2)\) 右边是连乘，于是对其取 \(\ln :\)

\[ \begin{aligned} \ln \varepsilon \circ F(x) &= \sum _ i \ln \left(\frac{1}{1 - x ^ i}\right) ^ {f _ i}\\ &= \sum _ i f_i \times \ln\left(\frac{1}{1 - x ^ i}\right)\\ &= -\sum _ i f_i \times \ln (1 - x ^ i)\\ &= \sum _ i \sum _ j \frac{f_i}{j + 1} x ^ {i(j + 1)} \end{aligned} \]

关于上式中化简 \(\ln (1 - x^{i})\) 的步骤可以参考后文中式 \((2.1.5)\)。

由于我们一般只需求生成函数的前 \(n\) 项，观察到 \(i\) 和 \(j\) 的枚举构成了调和级数的关系，可以直接暴力计算。

最后将求出的幂级数 \(\rm exp\) 回去即可得到 \(\varepsilon \circ F(x)\)。

时间复杂度 \(\Theta(n \log n)\)。

指数型生成函数

序列 \(a\) 的指数型生成函数 \(\rm(Exponential\ Generating\ Function,EGF)\) 被定义为形式幂级数：

\[ \hat{F}(x) = \sum _n a_n \frac{x ^ n}{n!}\tag{2.0.1} \]

两种基本形式

加法与乘法

形式幂级数形式的加减法与 \(\rm OGF\) 基本相同，也是对应系数相加。

乘法被定义为：

\[ \begin{aligned} \hat{F}(x)\hat{G}(x) &= \sum _ i a _ i \frac{x ^ i}{i!} \sum _ j b _ j \frac{x ^ j}{j!}\\ &= \sum _ n x ^ n \sum _ {i = 0} ^ n a _ i b _ {n - i} \frac{1}{i!(n - i)!}\\ &= \sum _ n \frac{x ^ n}{n!} \sum _ {i = 0} ^ n\dbinom{n}{i} a _ i b _ {n - i} \end{aligned} \]

麦克劳林级数

众所周知有泰勒展开：

\[ F(x) = \sum _ n \frac{F^{(n)}(x _ 0)}{n!}(x - x _ 0) ^ n \tag{2.1.2} \]

取 \(x_{0} = 0\) 时的特殊情况可以得到麦克劳林级数：

\[ F(x) = \sum _ n F^{(n)}(0)\frac{x ^ n}{n!} \tag{2.1.3} \]

有 \(\exp(0) = 1\)，故 \(e^{x}\) 的 \(\rm EGF\) 为：

\[ \hat{\exp}(x) = \sum _ n \frac{x ^ n}{n!} \tag{2.1.4} \]

常见幂级数的封闭形式

\[ \begin{aligned} e ^ {qx} &= \sum _ n q ^ n \frac{x ^ n}{n!}\\ \frac{e^{x}+e^{-x}}{2}&=\sum_{n}\frac{x^{2 n}}{(2 n) !} \\ \frac{e^{x}-e^{-x}}{2}&=\sum_{n}\frac{x^{2 n+1}}{(2 n+1) !} \\ \ln (1-x)&=-\sum_{n} \frac{x ^ {n + 1}}{n + 1}\\ \ln (1+x)&=\sum_{n}(-1)^{n} \frac{x^{n+1}}{n+1} \\ (1+x)^{\alpha}&=\sum_{n} \alpha^{\underline{n}} \frac{x^{n}}{n !} \end{aligned} \]

组合意义

结论：设 \(\hat{G}(x)\) 表示集合内部分配方案数关于集合大小的 \(\rm EGF\)，\(\hat{F}(x)\) 表示将问题划分成若干个无标号非空子问题，子问题的方案数为 \(\hat{G}(x)\) 的关于问题总规模的方案数的 \(\rm EGF\)。那么有关系式：

\[ \hat{F}(x) = \exp \hat{G}(x) \tag{2.2.1} \]

考虑证明上述结论，设 \(f_{i, j}\) 表示将 \(j\) 个有标号小球放进 \(i\) 个有标号盒子中的方案数，\(g_{i}\) 表示集合内有 \(i\) 个元素的方案数，显然有：

\[ f_{i, j} = \sum _{k = 1} ^ {j - i + 1} \dbinom{j}{k} f_{i - 1, j - k} \times g_k \]

考虑到 \(f_{i - 1, j - k}\) 在 \(k \gt j - i + 1\) 时的值为 \(0\)，所以可以将 \(k\) 的枚举上界换成 \(j\)，发现有：

\[ \hat{F}_i(x) = \hat{F}_{i - 1}(x)\hat{G}(x) \]

化简得到并根据 \(\hat{F}_{i}(x)\) 的定义得到：

\[ \hat{F}_i(x) = \sum _ j f_{i, j} \frac{x ^ j}{j!} = \hat{G}^i(x) \tag{2.2.2} \]

于是有：

\[ \begin{aligned} \exp \hat{G}(x) &= \sum_n \frac{\hat{G}^n(x)}{n!}\\ &= \sum _ n \frac{1}{n!} \sum _ i f_{n, i} \frac{x ^ i}{i!}\\ &= \sum _ i \left(\sum _ n \frac{f _ {n, i}}{n!}\right) \frac{x ^ i}{i!} \end{aligned} \]

这恰好对应了 \(\hat{F}(x)\) 的定义，于是 \(\hat{F}(x) = \exp \hat{G}(x)\)。

生成函数强化训练

Sat, 24 Jun 2023 11:00:56 +0000

考虑 \(\rm EGF\) 的组合意义，可以发现若设任意图方案数的 \(\rm EGF\) 为 \(F(x)\)，连通图的 \(\rm EGF\) 为 \(G(x)\)，显然任意图计数可以被看做先将 \(n\) 个点分进若干个非空子集，然后做连通图计数的方案数，那么根据之前的结论，有：

\[ F(x) = \exp G(x) \iff G(x) = \ln F(x) \]

显然有 \(F(x) = \sum_{n} 2^{\binom{n}{2}} x^{n}\)，于是只需直接对其求 \(\ln\) 即可。

时间复杂度 \(\Theta(n \log n).\)

首先可以考虑一个 \(\rm DP\)，设 \(f_{S}\) 表示点权之和为 \(S\) 的二叉树数量，迭代时可以考虑枚举左子树的权值和 \(S_{l}\)，右子树的权值和 \(S_{r}\) 和根节点的权值 \(w\)，那么有 \(f_{S_{l} + S_{r} + w} = \sum_{S_{l}} \sum_{S_{r}} \sum_{w \in C} f_{S_{l}} f_{S_{r}}.\)

容易发现，这个式子可以用三个多项式的卷积来拟合，设 \(F(x) = \sum_{n} f_{n} x^{n}, G(x) = \sum_{n} [n \in C] x^{n}\)，于是有：

\[ F = F ^ 2 G + 1 \]

最后的 \(+1\) 是为了补齐常数项，因为 \(f_{0}\) 为 \(1.\)

解方程可以得到：

\[ F = \frac{1 \pm \sqrt{1 - 4G}}{2G} \]

由于有两个解，显然不可能都成立，于是考虑 \(x \to 0\) 时的特殊情况。

当 \(x \to 0\) 时，\(F(x) \to 1,G(x) \to 0.\)

\[ \lim _ {x \to 0} \frac{1 + \sqrt{1 - 4G}}{2G} = +\infty \not= \lim _ {x \to 0} F \]\[ \lim _ {x \to 0} \frac{1 - \sqrt{1 - 4G}}{2G} = 1 = \lim _ {x \to 0} F \]

于是选取 \(F= \frac{1 - \sqrt{1 - 4G}}{2G}\) 作为方程的解。

到这一步，我们发现一个问题，因为 \(G(x)\) 的常数项为 \(0\)，所以 \(G(x)\) 不可以求逆。

考虑对解做变换，这里选取分子有理化：

\[ F = \frac{\left(1 - \sqrt{1 - 4G}\right)\left(1 + \sqrt{1 - 4G}\right)}{2G\left(1 + \sqrt{1 - 4G}\right)} = \frac{2}{1 + \sqrt{1 - 4G}} \]

可以发现分母的常数项必定不为 \(0\)，于是做多项式开方和多项式求逆即可。

时间复杂度 \(\Theta(n \log n).\)

设 \(\{f_{n}\},\{g_{n}\}\) 分别为斐波那契数列和答案序列，\(F(x)\) 和 \(G(x)\) 分别为它们的生成函数。

显然有斐波那契数列的生成函数：

\[ F(x) = \frac{x}{1 - x - x ^ 2} \]

而对于 \(G(x)\)，可以发现如果 \(g_{i}\) 已经被求出来了，那么给所有的拆分加上一个数 \(n - i\) 即可得到 \(g_{n}\) 的所有拆分，\(g_{i}\) 对 \(g_{n}\) 的贡献为 \(g_{i} \times f_{n - i}.\) 于是有 \(g_{n}\) 的递推式：

\[ g_n = \sum _ {i = 0} ^ {n- 1} g_i \times f_{n - i} \]

将 \(\{g_{n}\}\) 带入 \(G(x)\) 可得：

\[ G(x) = \sum _ n x ^ n \sum _ {i = 0} ^ {n - 1} g_i f_{n - i} \]

可以发现等式右边实际上是卷积的形式，于是有：

\[ G = GF \]

但是我们发现这样的话 \(G(x) = 0\)，原因是 \(g_{0} = 0\)，于是我们强制 \(g_{0} = 1\)，得到：

\[ G = GF + 1 \]\[ G(x) = \frac{1}{1 - F(x)} = 1 + \frac{x}{1 - 2x - x ^ 2} \]

可以发现现在求出的 \(G(x)\) 比实际值多了 \(1\)，因为我们将 \(g_{0} = 0\) 强制变成了 \(g_{0} = 1\)，修正后有：

\[ G(x) = \frac{x}{1 - 2x - x ^ 2} = \frac{\frac{\sqrt{2}}{4}}{1 - (1 + \sqrt{2})x} + \frac{-\frac{\sqrt{2}}{4}}{1 - (1 - \sqrt{2})x} \]\[ [x ^ n]G(x) = \frac{\sqrt{2}}{4}(1 + \sqrt{2}) ^ n - \frac{\sqrt{2}}{4}(1 - \sqrt{2}) ^ n \]

最后求出 \(\sqrt{2}\) 在模 \(10^{9} + 7\) 意义下的二次剩余，并且用拓展欧拉定理即可计算出答案。

时间复杂度 \(\Theta(\log n).\)

首先考虑二项式反演：

设 \(f_{i}\) 表示恰好有 \(i\) 个数的数量为 \(S\) 的方案数，\(g_{i}\) 表示钦点 \(i\) 个数的数量为 \(S\) 的方案数，显然有：

\[ g_k = \dbinom{m}{k} \times \frac{n ^ {\underline{kS}}}{(S!) ^ k} \times (m - k) ^ {n - kS} \]\[ g_k = \sum_{i = k} ^ m \dbinom{i}{k} f_i \iff f_k = \sum _ {i = k} ^ m (-1) ^ {i - k} \dbinom{i}{k} g_i \]\[ Ans = \sum _ {i = 0} ^ m w_if_i \]

于是我们考虑如何对于每个 \(i \in [0, m]\) 求出 \(f_{i}\)，这里有个技巧：

\[ \begin{aligned} f_k &= \sum _ {i = k} ^ m (-1) ^ {i - k} \frac{i!}{k!(i - k)!} g_i\\ &= k! \sum _ {i = k} ^ m i! g_i \times \frac{(-1) ^ {i - k}}{(i - k)!} \end{aligned} \]

容易发现上式可以用差值卷积计算，时间复杂度 \(\Theta(n \log n).\)

容易发现若设每种大小的物品的数量为 \(f_{i}\)，那么答案的生成函数为：

\[ \prod _ i \left (\sum _ j x ^ {ji}\right) ^ {f _ i} = \prod _ i \left(\frac{1}{1 - x ^ i}\right) ^ {f _ i} \]

可以直接使用欧拉变换的求解方式。

时间复杂度 \(\Theta(n \log n).\)

考虑设 \(f_{n}\) 表示大小为 \(n\) 的无标号有根树的方案数，\(F(x)\) 为数列 \(f\) 的生成函数。

可以发现，如果将一颗大小为 \(n\) 的无标号有根树的根去除，那么剩下的子树是一个个相同的子问题，只要子树大小的和为 \(n - 1\)，再加上根结点就可以唯一确定地拼出一颗无标号有根树。于是有生成函数方程：

\[ F(x) = x \cdot \varepsilon \circ F(x) \]

求解这个生成函数方程有两种方法，第一种是直接化简，分治多项式乘法求解：

\[ F(x) = x \prod _ i (1 - x ^ i) ^ {-f_i} \]

考虑对两边取 \(\ln\)，将连乘转连加：

\[ \ln F(x) = \ln x - \sum _ i f_i \ln (1 - x ^ i) \]

对数不好处理，考虑求导：

\[ \frac{F'(x)}{F(x)} = \frac{1}{x} + \sum _ i if_i \times \frac{x ^ {i - 1}}{1 - x ^ i} \]

将两边同时乘以 \(xF(x)\) ：

\[ xF'(x) = F(x) + F(x) \sum _ i if_i \frac{x ^ i}{1 - x ^ i} \]

考虑将右半部分还原成 \(F(x)\) 表示：

\[ xF'(x) = F(x) + F(x)\left(\sum _ {i \geqslant 1} x ^ i F'(x ^ i)\right) \]

设 \(G(x) = \sum_{k} x^{k} F'(x^{k})\)，简单推一推：

\[ G(x) = \sum _ k x ^ k \sum _ {i\geqslant 1} if _ i \left(x ^ {k}\right) ^ {i - 1} = \sum _ k \sum _ i i f _ i x ^ {ik} = \sum _ n x ^ n \sum _ {d | n} d f _ d \]

故 \(g_{n} = \sum_{d | n} df_{d},g_{1} = f_{1} = 1.\)

因此：

\[ f_n = \frac{1}{n - 1} \sum _ {k = 1} ^ {n - 1} f _ k g _ {n - k} \]

\(f\) 使用分治多项式乘法求解，\(g\) 暴力求解即可做到 \(\Theta(n \log^{2} n).\)

另一种方法是使用牛顿迭代：

显然我们要求解方程 \(G \circ F(x) = F(x) - x \cdot \varepsilon \circ F(x) = 0\).

假设当前已经求出了方程在模 \(x^{n}\) 意义下的解 \(F_{0}(x)\)，设方程在模 \(x^{2n}\) 意义下的解为 \(F(x)\)，众所周知有：

\[ F(x) = F_0(x) - \frac{G \circ F_0(x)}{G' \circ F_0(x)} \]

我们知道，\(\varepsilon \circ F(x)\) 可以在 \(\Theta(n \log n)\) 的时间复杂度内求出，\(F'(x)\) 可以 \(\Theta(n)\) 求，所以可以在 \(\Theta(n \log n)\) 的时间复杂度内求下式：

\[ F(x) = F_0(x) - \frac{F_0(x) - x \cdot \varepsilon \circ F_0(x)}{[F_0(x) - x \cdot \varepsilon \circ F_0(x)]'} \]

用上式迭代即可算出 \(F(x)\)，时间复杂度 \(\Theta(n \log n).\)

现在我们已经求出了无标号有根树的方案数，考虑将无标号无根树的方案数容斥出来。

考虑钦点无标号无根树的根是它的重心，于是只需要去掉根不是重心的无标号有根树的方案数可以了，分类讨论：

如果重心唯一，那么一定存在一颗子树的大小大于 \(\left\lfloor\frac{n}{2}\right\rfloor\)，考虑枚举它的大小 \(i\)，容易发现这颗子树的方案数和将它切除后树的方案数都是无标号有根树计数问题，其答案我们已经算出，于是总方案数需要减去 \(\sum_{i = \left\lfloor\frac{n}{2}\right\rfloor + 1}^{n - 1} f_{i} \times f_{n - i}.\)

如果重心不唯一，那么一棵树还会在两个重心上分别被计算，这种方案只会在 \(n\) 为偶数的情况下出现。考虑到这两个重心一定相连，于是将它们之间的连边断开后形成的两个子树的方案数是独立的。但是我们发现，当两颗子树完全相同时，分别以它的两个重心为根时形成的有根树是同构的，所以我们还是只会将它计算一次，故算重的方案中不包括两颗子树相同的情况，于是总方案数还需要减去 \(\binom{f_{\frac{n}{2}}}{2}.\)

综上，问题得到解决，时间复杂度为 \(\Theta(n \log^{2} n)\) 或 \(\Theta(n \log n).\)

考虑构造 \(F_{i}(x) = \sum_{j = 0}^{m_{i}} x^{j}\)，容易发现题目要求的就是 \(\prod_{i = 1}^{n} F_{i}(x)\) 的系数前缀和。

于是再构造 \(F_{0}(x) = \sum_{i} x^{i}\)，将它和原本的 \(n\) 个幂级数卷在一起，现在考虑求 \(F(x) = \prod_{i = 0}^{n} F_{i}(x)\) 的第 \(L\) 项系数。

容易发现有：

\[ F(x) = \frac{(1 - x ^ {m_1 + 1})(1 - x ^ {m_2 + 1})\cdots(1 - x ^ {m_n + 1})}{(1 - x) ^ {n + 1}} \]

观察到 \(n\) 很小，考虑暴力将分子拆开，于是分式变成了 \(2^{n}\) 个形如 \(\frac{x^{k}}{(1 - x)^{n + 1}}\) 的部分之和。

容易发现：

\[ [x ^ L]\frac{x ^ k}{(1 - x) ^ {n + 1}} = \dbinom{n + L - k}{n} \]

于是只需要求 \(2^{n + 1}\) 次形如 \(\binom{t}{n}\) 的组合数即可。

到这里我们又发现模数 \(p\) 不是质数，于是考虑将式子变形：

\[ \dbinom{t}{n}~\bmod~p = \frac{t^{\underline{n}}}{n!}~\bmod~p = \frac{t ^ {\underline{n}}~\bmod~n!\cdot p}{n!}~\bmod~p \]

于是这样就可以 \(\Theta(n)\) 求解组合数了，总时间复杂度 \(\Theta(2^{n} n).\)

简化题意：求有多少个从 \(\{1,2,\cdots,n\}\) 到 \(\{1,2,\cdots,n\}\) 的映射 \(f\)，满足：

\[ \underbrace{f \circ f \circ \cdots \circ f}_{k}=\underbrace{f \circ f \circ \cdots \circ f}_{k-1} \]

保证 \(nk \leqslant 2 \times 10^{6},1\leqslant k \leqslant 3.\)

可以发现这题本质上就是在求深度不超过 \(k\)，环大小为 \(1\) 的基环内向树森林的数量，进一步发现其等价于树高不超过 \(k\) 的有标号有根树森林的数量。

考虑设树高不超过 \(k\) 的有标号有根树数量的 \(\rm EGF\) 为 \(\hat{F}_{k}(x).\) 计算考虑递推，深度不超过 \(k\) 的树可以看作若干棵深度不超过 \(k - 1\) 的树全部接在一个点上，于是有：

\[ \hat{F}_k(x) = x\cdot \exp \hat{F}_{k - 1}(x) \]

考虑到需要求的是森林的数量，于是答案的指数型生成函数为 \(\exp \hat{F}_{k}(x).\)

时间复杂度 \(\Theta(kn\log n).\)

考虑一次对 \(x\) 的操作造成的影响，他会使 \(a_{x}\) 减少 \(1\)，答案增加 \(\prod_{i \not= x} a_{i}\)，\(\prod_{i} a_{i}\) 减少 \(\prod_{i \not= x} a_{i}.\)

于是我们可以发现，一次操作对答案的贡献等于 \(\prod_{i} a_{i}\) 的变化量。进一步的，最终答案等于 \(k\) 次操作进行完后 \(\prod_{i} a_{i}\) 的变化量。假设第 \(a_{i}\) 被操作了 \(b_{i}\) 次，那么答案为 \(\prod_{i} a_{i} - \prod_{i} (a_{i} - b_{i}).\)

考虑计算所有情况下 \(\prod_{i} (a_{i} - b_{i})\) 的和，最后再将答案除以 \(n^{k}.\)

假设有两个集合 \(S,T,S \cap T = \varnothing\)，\(f_{i}\) 表示 \(\sum b_{k} = i,k\in S\) 对答案的贡献，\(g_{i}\) 表示 \(\sum b_{k} = i,k\in T\) 对答案的贡献，\(h_{i}\) 表示 \(\sum b_{k} = i,k\in S \cup T\) 对答案的贡献，那么显然有：

\[ g_n = \sum _ {i = 0} ^ n \dbinom{n}{i} f_i \times g_{n - i} \]

因为 \(f_{i}\) 和 \(g_{n - i}\) 联合起来的贡献是它们的乘积，并且由于操作有序，所以将 \(n\) 次操作分配到它们还导致要乘上 \(\binom{n}{i}\) 的方案数。

很明显，这个式子可以用 \(\rm EGF\) 来拟合，设 \(\hat{F}_{i}(x) = \sum_{j} (a_{i} - j) \frac{x^{j}}{j!}\)，那么答案的生成函数为：

\[ \begin{aligned} \hat{F}(x) &= \prod _ i F_i(x)\\ &= \prod _ i \left( \sum _ j (a_i - j) \frac{x ^ j}{j!} \right)\\ &= \prod _ i \left( a_i \sum _ j \frac{x ^ j}{j!} - \sum _ {j} \frac{x ^ {j + 1}}{j!} \right)\\ &= \prod _ i (a_i - x)e ^ x\\ &= e ^ {nx} \prod _ i (a_i - x) \end{aligned} \]

\(\prod_{i} (a_{i} - x)\) 直接分治乘可以做到 \(\Theta(n \log^{2} n)\)，\(e^{nx}\) 的系数可以直接求，由于 \(\prod_{i} (a_{i} - x)\) 的最高次数为 \(n\)，所以直接枚举计算即可。

总时间复杂度 \(\Theta(n \log^{2} n).\)

简单的代数反演

Sat, 24 Jun 2023 11:00:56 +0000

二项式反演

数列形式

\[ g(x)=\sum_{i=x}^n\dbinom{i}{x}f(i)\iff f(x)=\sum_{i=x}^n (-1)^{i-x}\dbinom{i}{x}g(i) \]

\(\large\rm Proof:\)

将上式带入下式得 \(:\)

\[ f(x)=\sum_{i=x}^n (-1)^{i-x}\dbinom{i}{x}\sum_{j=i}^n\dbinom{j}{i}f(j) \]

整理得 \(:\)

\[ f(x)=\sum_{i=x}^n\sum_{j=i}^n(-1)^{i-x}\dbinom{j}{i}\dbinom{i}{x}f(j) \]

根据组合恒等式 \(\dbinom{i}{j}\dbinom{j}{k}=\dbinom{i}{k}\dbinom{i-k}{j-k}\) 得 \(:\)

\[ f(x)=\sum_{i=x}^n\sum_{j=i}^n(-1)^{i-x}\dbinom{j}{x}\dbinom{j-x}{i-x}f(j) \]

交换枚举顺序得 \(:\)

\[ f(x)=\sum_{j=x}^n\sum_{i=x}^j(-1)^{i-x}\dbinom{j}{x}\dbinom{j-x}{i-x}f(j) \]

改变代表字母，整理得 \(:\)

\[ f(x)=\sum_{i=x}^n\dbinom{i}{x}f(i)\sum_{j=x}^i(-1)^{j-x}\dbinom{i-x}{j-x} \]

将靠后的 \(\sum\) 枚举的 \(j\) 替换成 \(j+x\) 得 \(:\)

\[ f(x)=\sum_{i=x}^n\dbinom{i}{x}f(i)\sum_{j=0}^{i-x}(-1)^{j}\dbinom{i-x}{j} \]\[ \because \sum_{i=0}^k(-1)^i\dbinom{k}{i}=(1-1)^k \]\[ \therefore \sum_{i=0}^k(-1)^i\dbinom{k}{i}=[k=0] \]

所以此式不为 \(0\) 当且仅当 \(i=x\)，故 \(:\)

\[ f(x)=\sum_{i=x}\dbinom{x}{x}f(i)=f(x) \]

原式得证。

我们来看看二项式反演的数列形式有什么应用：

乱序排列问题： 求有多少种不同的长度为 \(n\) 的排列 \(p\)，使得 \(\forall i\in [1,n],p_{i}\not = i\)。

令 \(g(i)\) 表示钦定有 \(i\) 个数一定在自己的位置上，剩下的随便排的方案数，显然有 :

\[ g(i)=\dbinom{n}{i}(n-i)! \]

令 \(f(i)\) 表示恰好有 \(i\) 个数在自己的位置上的方案数，考虑到 \(f(i)\) 会被 \(g(j)\ (j\leqslant i)\) 计算 \(\dbinom{i}{j}\) 次，于是有 \(:\)

\[ g(i)=\sum_{j=i}^n\dbinom{j}{i}f(j) \]

根据二项式反演 \(:\)

\[ f(i)=\sum_{j=i}^n(-1)^{j-i}\dbinom{j}{i}g(j) \]

将 \(g(i)=\dbinom{n}{i}(n-i)!\) 带入得 \(:\)

\[ f(i)=\sum_{j=i}^n(-1)^{j-i}\dbinom{j}{i}\dbinom{n}{j}(n-j)! \]

根据组合恒等式 \(\dbinom{i}{j}\dbinom{j}{k}=\dbinom{i}{k}\dbinom{i-k}{j-k}\)，整理得 \(:\)

\[ f(i)=\dbinom{n}{i}\sum_{j=i}^n(-1)^{j-i}\dbinom{n-i}{j-i}(n-j)! \]

考虑到当 \(i=0\) 时为答案，所以 \(:\)

\[ \begin{aligned} Ans=f(0)&=\sum_{i=0}^n(-1)^i\dbinom{n}{i}(n-i)!\\ &=\sum_{i=0}^n(-1)^i\dfrac{n!}{i!}\\ &=(n+1)!\sum_{i=0}^n(-1)^i(i!)^{-1} \end{aligned} \]

集合形式

\[ f(S)=\sum_{S\subseteq T}g(T)\iff g(S)=\sum_{S\subseteq T} (-1)^{|T|-|S|}f(T) \]

\(\large\rm Proof:\)

同样考虑带入证明：

\[ \begin{aligned} f(S)&=\sum_{S\subseteq T}\sum_{T\subseteq R}(-1)^{|R|-|T|}f(R)\\ &=\sum_{S\subseteq R}f(R)\sum_{S\subseteq T\subseteq R}(-1)^{|R|-|T|} \end{aligned} \]

考虑枚举 \(T-S\) 的大小：

\[ \begin{aligned} f(S)&=\sum_{S\subseteq R}f(R)\sum_{i=0}^{|R|-|S|}\dbinom{|R|-|S|}{i}(-1)^{|R|-(|S|+i)}\\ &=\sum_{S\subseteq R}[|S|=|R|]\\ &=f(S) \end{aligned} \]

原式得证。

我们来看看二项式反演的集合形式有什么应用：

有向图无环子图计数： 给定一张 \(n\) 个点的有向图，求其无环子图的数量。

考虑动态规划，设 \(f_{S}\) 表示点集 \(S\) 导出子图的答案。

由于是 \(\rm DAG\) 计数，所以我们可以很自然地想到枚举入度为 \(0\) 的点，假设 \(T\) 是 \(S\) 的子集，并且其中的每个点都没有入边，那么显然有转移：

\[ f_S=\sum_{T\subseteq S,T\not = \varnothing}2^{cnt_{T,S-T}}\times f_{S-T} \]

其中 \(cnt_{S,T}\) 表示集合 \(S\) 到集合 \(T\) 的连边总数。

但我们发现这样做实际上是错的，因为 \(T\) 不一定包含了 \(S\) 中所有入度为 \(0\) 的点，我们考虑容斥。

设 \(q_{T}=2^{cnt_{T,S-T}}\times f_{S-T}\)，\(p_{T}\) 表示 \(S\) 中恰好有 \(T\) 作为入度为 \(0\) 的点的方案数，有 \(q_{T}=\sum\limits_{T\subseteq S} p_{S}\)。

由二项式反演的集合形式可以得到：

\[ p_S=\sum_{S\subseteq T}(-1)^{|T|-|S|}q_T \]

回到原本的 \(\rm DP\)，我们需要求：

\[ \begin{aligned} f_S&=\sum_{T\subseteq S,T\not= \varnothing}p_T\\ &=\sum_{T\subseteq S,T\not= \varnothing}\sum_{T\subseteq R\subseteq S}(-1)^{|R|-|T|}q_R\\ &=\sum_{R\subseteq S,R\not= \varnothing}q_R \sum_{T\subseteq R,T\not=\varnothing}(-1)^{|R|-|T|}\\ &=\sum_{R\subseteq S,R\not= \varnothing}q_R (-1)^{|R|}\left(\sum_{T\subseteq R}(-1)^{-|T|}-1\right)\\ &=\sum_{T\subseteq S,T\not= \varnothing}(-1)^{|T|-1}q_T \end{aligned} \]

于是转移方程为：

\[ f_S=\sum_{T\subseteq S,T\not= \varnothing}(-1)^{|T|-1}2^{cnt_{T,S-T}}f_{S-T} \]

现在只需要 \(\Theta(1)\) 计算 \(cnt_{T,S-T}\) 即可做到 \(\Theta(3^{n})\) 计算计算答案，考虑预处理。

可以在枚举了每个 \(S\) 做转移的时候再算这个东西，此时只需要记 \(cnt_{T}\ (T\subseteq S,T\not=\varnothing)\) 表示 \(T\) 恰好作为 \(S\) 中没有入度的点集的路径数。考虑在进行所有计算之前预处理 \(A_{i,S}\) 表示 \(i\) 到 \(S\) 中的边数，\(D_{i,S}\) 表示 \(S\) 中的点到 \(i\) 的边数和，这两个数组都可以 \(\Theta(n2^{n})\) 预处理。

计算 \(cnt\) 时考虑从小到大枚举每个 \(T\) 计算答案，可以发现 \(T\) 的每个真子集的答案都已经被计算出来了，于是任取一个点从 \(T\) 中移到 \(S-T\) 即可算出答案，这里考虑 \(\Theta(1)\) 枚举 lowbit. 可以发现，转移式为：

\[ cnt_T=cnt_{T-\{u\}}+A_{u,S-T}-D_{T-\{u\},u} \]

于是本题到此，可以做到时间复杂度 \(\Theta(3^{n})\)，空间复杂度 \(\Theta(n2^{n})\)。

子集反演

\[ f(S)=\sum_{T\subseteq S}g(T)\iff g(S)=\sum_{T\subseteq S}(-1)^{|S|-|T|}f(T) \]

\(\large\rm Proof:\)

还是考虑带入证明，与二项式反演的集合形式类似 \(:\)

\[ \begin{aligned} f(S)&=\sum_{T\subseteq S}\sum_{R\subseteq T}(-1)^{|T|-|R|}f(R)\\ &=\sum_{R\subseteq S}f(R)\sum_{R\subseteq T\subseteq S}(-1)^{|T|-|R|}\\ &=\sum_{R\subseteq S}f(R)\sum_{i=0}^{|S|-|R|}\dbinom{|S|-|R|}{i}(-1)^{(|S|-i)-|R|}\\ &=\sum_{R\subseteq S}[|R|=|S|]\\ &=f(S) \end{aligned} \]

原式得证。

斯特林反演

第二类斯特林数

定义

定义 \(\begin{Bmatrix}n \ m\end{Bmatrix}\) 为将 \(n\) 个有标号小球放入 \(m\) 个无标号盒子，每个盒子不能为空的方案。

递推式

\[ \begin{Bmatrix}n \ m\end{Bmatrix} = \begin{Bmatrix}n - 1 \ m - 1\end{Bmatrix} + m \times \begin{Bmatrix}n - 1 \ m\end{Bmatrix} \]

根据组合意义不难证明。

求一行第二类斯特林数

考虑以下第二类斯特林数的组合意义，我们考虑使用容斥描述第二类斯特林数的答案。

首先我们求出将 \(n\) 个有标号小球放入 \(m\) 个有标号盒子，盒子不能为空的方案，根据这个问题的特殊性，任意一种无标号盒子的方案恰好双向对应 \(m!\) 中有标号盒子的方案，最后除 \(m!\) 即可。

对于盒子是否为空进行容斥：

\[ \begin{Bmatrix}n \ m\end{Bmatrix} = \frac{1}{m!} \sum\limits_i ^ m (-1) ^ i \dbinom{m}{i}(m - i) ^ n \]

显然是一个卷积的形式，\(\rm NTT\) 即可做到 \(\mathcal{O(n \log n)}\)。

求一列第二类斯特林数

不难发现第二类斯特林数的定义与 \(\exp\) 的组合意义很相似，于是我们考虑 \(\rm EGF:\) \(\widehat F(x) = \sum\limits_{i = 1}^{\infty} \frac{x^{i}}{i!} = e^{x} - 1\)。

那么根据 \(\rm EGF\) 相乘的组合意义，\([\dfrac{x^{n}}{n!}]\widehat F^{m}(x) = [\dfrac{x^{n}}{n!}](e^{x} - 1)^{m} = \begin{Bmatrix}n \ m\end{Bmatrix}\)。

使用多项式快速幂即可做到 \(\mathcal{O(n \log n)}\)。

第一类斯特林数

定义

定义 \(\begin{bmatrix}n \ m\end{bmatrix}\) 为将 \(n\) 个数划分成 \(m\) 个互不区分的非空置换的方案数。

递推式

\[ \begin{bmatrix}n \ m\end{bmatrix} = \begin{bmatrix}n - 1 \ m - 1\end{bmatrix} + (n - 1) \times \begin{bmatrix}n - 1 \ m\end{bmatrix} \]

由组合意义不难证明。

求一行第一类斯特林数

因为第一类斯特林数不具有较好的组合意义，因此不能像第二类斯特林数那样使用另一种方式来描述其，因此我们直接考虑第一类斯特林数的 \(\rm OGF\)：

\[ \begin{aligned} F_i(x) &= \sum\limits_j ^ \infty \begin{bmatrix}i \ j\end{bmatrix} x ^ j \\ &= x \times F_{i - 1}(x) + (i - 1) F_{i - 1}(x) \\ &= (i + x - 1) F_{i - 1}(x) \\ &= \prod\limits_j ^ {i - 1} (x + j) \end{aligned} \]

那么就有：

\[ F_n(x) = \prod\limits_i ^ {n - 1} (x + i) \]

当然可以直接使用启发式合并做到 \(\mathcal{O(n \log^{2n})}\)，但还存在一个更加优秀的方法：倍增法。

\[ F_{2n}(x) = F_n(x) \times F_n(x + n) \]

只需快速计算 \(F_{n}(x + n)\) 即可，令 \(F_{n}(x) = \sum\limits_{i}^{\infty} f_{i} x^{i}\)：

\[ \begin{aligned} F_n(x + n) &= \sum\limits_i ^ n f_i(x + n) ^ i \\ &= \sum\limits_i ^ n f_i\sum\limits_j ^ i x ^ j n ^ {i - j} \end{aligned} \]

后者很明显是一个卷积的形式，直接计算即可，根据倍增的复杂度，可以做到 \(\mathcal{O(n \log n)}\)。

求一列第一类斯特林数

类似于求一列第二类斯特林数的方法，考虑 \(\rm EGF:\) \(\widehat F(x) = \sum\limits_{i}^{\infty} \dfrac{(i - 1)!x^{i}}{i!} = \sum\limits_{i}^{\infty} \dfrac{x^{i}}{i} = \ln\left(\dfrac{1}{1 - x}\right)\)

那么就有：

\[ \begin{bmatrix}n \ m\end{bmatrix} = [\frac{x ^ n}{n!}]\widehat F ^ m(x) \]

使用多项式快速幂即可，复杂度 \(\mathcal{O(n \log n)}\)。

普通幂, 上升幂, 下降幂的转换

先介绍两个最简单的：上升幂和下降幂的转换：

\[ x ^ {\underline{n}} = (-1) ^ n (-x) ^ {\overline n} \]\[ x ^ {\overline{n}} = (-1) ^ n (-x) ^ {\underline n} \]

再根据我们求一行斯特林数的方法，可以得到上升幂转普通幂公式：

\[ x ^ {\overline n} = \sum\limits_i ^ n \begin{bmatrix} n \ i \end{bmatrix} x ^ i \]

而根据第二类斯特林数的组合意义，再根据普通幂 \(x^{n}\) 的组合意义，可以得到普通幂转下降幂公式：

\[ x ^ n = \sum\limits_i ^ x \dbinom{x}{i} \begin{Bmatrix} n \ i \end{Bmatrix} i! = \sum\limits_i ^ x \begin{Bmatrix} n \ i \end{Bmatrix} x ^ {\underline{i}} \]

再利用最开始提到的下降幂转上升幂公式变形，我们可以得到普通幂转上升降幂公式：

\[ \begin{aligned} (-x) ^ n &= \sum\limits_i ^ x \begin{Bmatrix} n \ i \end{Bmatrix} (-x) ^ {\underline{i}} \\ &= \sum\limits_i ^ x \begin{Bmatrix} n \ i \end{Bmatrix} (-1) ^ i x ^ {\overline{i}} \end{aligned} \]\[ \Longleftrightarrow x ^ n = \sum\limits_i ^ x (-1) ^ {n - i}\begin{Bmatrix} n \ i \end{Bmatrix}x ^ {\overline{i}} \]

同理可得下降幂转普通幂公式：

\[ x ^ {\underline{n}} = \sum\limits_i ^ x (-1) ^ {n - i} \begin{bmatrix} n \ i \end{bmatrix} x ^ i \]

总结一下四个公式，普通幂转出去使用第二类斯特林数，转回来使用第一类斯特林数。阶数上升（下转普，普转上）加 \(-1\)。

通过这四个公式，我们也能完成一般多项式和上升幂下降幂多项式的互相转化。

我们来看看这几个式子有什么应用：

例题： 给定 \(k\) 次多项式 \(f(x)\) 的各项系数和一个整数 \(n\)，求以下式子对 \(998244353\) 取模后的值：

\[ \sum_{i=0}^n\dbinom{n}{i}2^{n-i}f(i) \]

我们发现带 \(f(x)\) 的式子没有前途，于是将其拆开：

\[ \sum_{i=0}^n\dbinom{n}{i}2^{n-i}\sum_{j=0}^ka_ji^j \]

这里有个套路是将整数幂转第二类斯特林数：

\[ \begin{aligned} m^n&=\sum_{k=0}^m\dbinom{m}{k}\begin{Bmatrix}n\\ m-k\end{Bmatrix}(m-k)!\\ &=\sum_{k=0}^m\begin{Bmatrix}n\\ k\end{Bmatrix}m^{\underline{k}} \end{aligned} \]

转化的含义是将 \(m^{n}\) 看作 \(\rm LLA\) 问题的方案数，我们发现 \(\small\begin{Bmatrix}n\\ m\end{Bmatrix}\) 是 \(\rm LUB\) 问题的方案数，于是枚举 \(m\) 个集合中有 \(k\) 个 \(0\)，然后用第二类斯特林数将 \(\rm LUA\) 算出来后乘上 \((m-k)!\) 得到 \(\rm LLA\) 的方案数。

于是就可以开始推式子了：

\[ \begin{aligned} &\quad~\sum_{i=0}^n\dbinom{n}{i}2^{n-i}f(i)\\ &=\sum_{i=0}^n\dbinom{n}{i}2^{n-i}\sum_{j=0}^ka_ji^j\\ &=\sum_{i=0}^n\dbinom{n}{i}2^{n-i}\sum_{j=0}^ka_j\sum_{p=0}^i\dbinom{i}{p}\begin{Bmatrix}j\\ p\end{Bmatrix}p!\\ &=\sum_{i=0}^n\sum_{j=0}^k\sum_{p=0}^i\dbinom{n}{i}\dbinom{i}{p}2^{n-i}a_j\begin{Bmatrix}j\\ p\end{Bmatrix}p!\\ &=\sum_{j=0}^ka_j\sum_{p=0}^n\begin{Bmatrix}j\\ p\end{Bmatrix}p!\sum_{i=p}^n\dbinom{n}{i}\dbinom{i}{p}2^{n-i}\\ &=\sum_{j=0}^ka_j\sum_{p=0}^n\begin{Bmatrix}j\\ p\end{Bmatrix}p!\sum_{i=p}^n\dbinom{n}{p}\dbinom{n-p}{i-p}2^{n-i}\\ &=\sum_{j=0}^ka_j\sum_{p=0}^n\dbinom{n}{p}\begin{Bmatrix}j\\ p\end{Bmatrix}p!\sum_{i=0}^{n-p}\dbinom{n-p}{i}2^{n-p-i}\\ &=\sum_{j=0}^k\sum_{p=0}^na_j\begin{Bmatrix}j\\ p\end{Bmatrix}\dbinom{n}{p}p!3^{n-p}\\ &=\sum_{j=0}^k\sum_{p=0}^j\begin{Bmatrix}j\\ p\end{Bmatrix}a_j\times n^{\underline{p}}\times 3^{n-p} \end{aligned} \]

最后这个式子可以通过预处理第二类斯特林数，\(3\) 的次幂和 \(n\) 的 \(p\) 阶下降幂做到 \(\Theta(k^{2})\)。

斯特林反演

非常类似二项式反演的形式，有：

\[ f_n = \sum\limits_i ^ n \begin{Bmatrix} n \ i \end{Bmatrix} g_i \Longleftrightarrow g_n = \sum\limits_i ^ n (-1) ^ {n - i} \begin{bmatrix} n \ i \end{bmatrix} f_i \]

我们首先需要了解斯特林反演基于的恒等式 \(-\) 反转公式：

\[ \sum\limits_{i = m} ^ n (-1) ^ {n - i} \begin{Bmatrix} n \ i \end{Bmatrix} \begin{bmatrix} i \ m \end{bmatrix} = [n = m] \]\[ \sum\limits_{i = m} ^ n (-1) ^ {n - i} \begin{bmatrix} n \ i \end{bmatrix} \begin{Bmatrix} i \ m \end{Bmatrix} = [n = m] \]

不难发现两式的形式非常类似，我们只证明第一条式子，第二条式子是类似的。

\[ \begin{aligned} x ^ n &= \sum\limits_i ^ n \begin{Bmatrix} n \ i \end{Bmatrix} x ^ {\underline{i}} \\ &= \sum\limits_i ^ n \begin{Bmatrix} n \ i \end{Bmatrix} (-1) ^ i (-x) ^ {\overline{i}} \\ &= \sum\limits_i ^ n (-1) ^ i \begin{Bmatrix} n \ i \end{Bmatrix} \sum\limits_j ^ i (-1) ^ j \begin{bmatrix} i \ j \end{bmatrix} x ^ j \\ &= \sum\limits_i ^ n \left( \sum\limits_{j = i} ^ n (-1) ^ {i - j} \begin{Bmatrix} n \ j \end{Bmatrix} \begin{bmatrix} j \ i \end{bmatrix}\right) x ^ i \end{aligned} \]

根据多项式恒等原理即可证明第一条反转公式。

有了这两条反转公式，就可以直接将斯特林反演左式带入右式以及右式带入左式来证明正确性了，过程是不难的。

Min-Max 反演

令 \(\max\limits_{k}(S)\) 表示有限集 \(S\) 中的最大值，\(\min\limits_{k}(S)\) 表示有限集中的最小值。

基本形式

\[ \max(S)=\sum\limits_{T\subseteq S}(-1)^{|T|-1}\min(T) \]

可以发现，对于所有 \(T\subseteq S-\{\max(S)\}\)，均存在 \(T+\max(S)\subseteq S\) 与之一一对应，且 \(\min(T)=\min(T+\max(S))\)。由于它们的大小恰好相差 \(1\)，故对每个集合 \(S\) 配上 \((-1)^{|S|}\) 的系数可以恰好它们消掉，最后仅剩下集合 \(\{\max(S)\}\)，它的最小值恰好等于 \(\max(S)\)。

同理：

\[ \min(S)=\sum\limits_{T\subseteq S}(-1)^{|T|-1}\max(T) \]

拓展形式

\[ \max_k(S)=\sum_{T\subseteq S,|T|\geqslant k}(-1)^{|T|-k}\dbinom{|T|-1}{k-1}\min(T) \]

考虑 \(S\) 中的第 \(i\) 大数，它作为最小值被包含在大小为 \(|T|\) 的集合中共 \(\binom{i-1}{|T|-1}\) 次，每次出现会乘上 \(\binom{|T|-1}{k-1}\) 的权值，故一个数 \(\max\limits_{i}(S)\) 的总贡献为：

\[ \begin{aligned} val_i&=\max_i(S)\sum_{|T|=k}^i(-1)^{|T|-k}\dbinom{i-1}{|T|-1}\dbinom{|T|-1}{k-1}\\ &=\max_i(S)\dbinom{i-1}{k-1}\sum_{|T|=k}^i(-1)^{|T|-k}\dbinom{i-k}{|T|-k}\\ &=\max_i(S)\dbinom{i-1}{k-1}[i=k] \end{aligned} \]

所有数的贡献之和即为 \(\sum\limits_{i=1}^{|S|}val_{i}=\max\limits_{k}(S)\)，故原式成立。

另外，由于期望具有线性性，所以上面的式子在期望意义下也成立。

我们来看看 \(\rm Min-Max\) 反演有什么应用：

：你需要收集 \(n\) 种物品中的任意 \(k\) 种，每个时刻会有一种物品被生成，第 \(i\) 种物品被生成的概率为 \(\frac{p_{i}}{m}\)，如果你还没有收集这种物品则可以收集它，求你收集到这 \(n\) 个物品中任意 \(k\) 个的期望时间。

保证 \(k\leqslant n\leqslant 10^{3},|n-k|\leqslant 10,0\leqslant p_{i}\leqslant m,\sum p=m,m\leqslant 10^{4}\)。

首先可以发现所有物品出现的时间不重，故构成一个集合，所以题目要求的为 \(E\left(\max (S)_{k}\right)\)。

套用拓展 \(\rm Min -Max\) 得到:

\[ E\left(\max (S)_{k}\right)=\sum_{T \subseteq S}\left(\begin{array}{c} |T|-1 \\ k-1 \end{array}\right)(-1)^{|T|-k} E(\min (T)) \]

我们知道原来要求的是全集合中出现时间排第 \(k\) 的元素，由于变成了正过来看，此时的 \(k\) 变成了 \(n-k+ 1\) ，它的值非常小。

我们知道一个集合每次操作出现一个属于它的元素的概率为:

\[ e(S)=\sum_{i \in S} \frac{p_{i}}{m} \]

于是我们知道期望时间为:

\[ \sum_{i=1}^{\infty} e(S)(1-e(S))^{i-1}=\frac{1}{e(S)} \]

于是现在我们得到了一个复杂度为 \(\Theta\left(2^{n}\right)\) 的做法，暴力枚举子集，对于每个集合求出此式子并计算贡献。

然后我们来看这个式子:

\[ E\left(\max (S)_{k}\right)=\sum_{T \subseteq S}\left(\begin{array}{c} |T|-1 \\ k-1 \end{array}\right)(-1)^{|T|-k} E(\min (T)) \]

考虑一个固定的集合大小 \(|T|\) ，其分配的系数相同均为 \(\left(\begin{array}{c}|T|-1 \ k-1\end{array}\right)(-1)^{|T|-k}\)

则我们只需要求出 \(\sum_{|T|=x} E(\min (T))\)

注意到 \(E(\min (T))=\frac{1}{e(S)}\)，于是我们可以给 \(d p\) 加一个维度记录 \(\sum p=e(S)\), 这样只需要统计有多少个点满足 \(\sum p=i,|T|=j\)。

于是不妨记 \(d p_{i, j, k}\) 表示考虑到前 \(i\) 个数，满足 \(|T|=j, \sum p=k\) 的集合数，则可以得到转移:

\[ d p_{i, j, k}=d p_{i-1, j, k}+d p_{i-1, j-1, k-p_{i}} \]

这样便可以得到一个复杂度为 \(\Theta\left(n^{2} m\right)\) 的做法了。

现在问题在于如何优化复杂度 \(?\)

我们发现转移已经是最优了，不能从这里下手，于是只能从状态下手。由于 \(k\) 这一维附带了一个 \(\frac{1}{k}\)，于是肯定定是不能省略的，唯一的办法是把记录中的 \(|T|\) 给去掉试试。

换而言之我们只统计到第 \(i\) 个数，任意放满足 \(\sum p=k\) 的数前面安排的系数之和。考虑系数为:

\[ \sum\left(\begin{array}{c} |T|-1 \\ k-1 \end{array}\right)(-1)^{|T|-k} \]

拆开试试 ?

\[ \sum \frac{(|T|-1) !}{(k-1) !(|T|-k) !}(-1)^{|T|-k} \]

好像还是不行……

但是这个时候可以得到转移大致为：

\[ d p_{i, j}=d p_{i-1, j}+\ldots \]

这个奇怪的东西应该表示为:

对于 \(d p_{i-1, j-p i}\) 的:

\[ \sum\left(\begin{array}{c} |T|-1 \\ k-1 \end{array}\right)(-1)^{|T|-k} \]

首先可以注意到所有 \(|T| \rightarrow|T|+1\) 于是整体需要乘一个 \(-1\)，注意到 \(|T| \rightarrow|T|+1\)，于是组合数变成了:

\[ \left(\begin{array}{c} |T| \\ k-1 \end{array}\right) \]

但是我们知道组合数可以递推所以有:

\[ \left(\begin{array}{c} |T| \\ k-1 \end{array}\right)=\left(\begin{array}{c} |T|-1 \\ k-1 \end{array}\right)+\left(\begin{array}{c} |T|-1 \\ k-2 \end{array}\right) \]

然而真正有趣的是这个式子可以放在一起一起递推，因为考虑计算 \(dp\) 时强制放入一个数则等价于 \(|T|\) 必然变大 \(1\)，于是我们可以给 \(dp\) 增加一个维度 \(k\) 来计算 \(dp\) 系数

\[ d p_{i, j, k}=d p_{i-1, j, k}+(-1) \times d p_{i-1, j-p i, k}+(-1)^{2} \times d p_{i-1, j-p i, k-1} \]

即:

\[ d p_{i, j, k}=d p_{i-1, j, k}-d p_{i-1, j-p i, k}+d p_{i-1, j-p i, k-1} \]

接下来考虑边界条件，这个好像有点难，因为我们的 \(dp\) 是按照转移的需求设计，所以它存在的实际意义也是为了方便转移而存在的。

我们知道 \(d p_{0, j, k}\) 的意义应该是: \(\sum_{\sum p=j}\left(\begin{array}{c}|T|-1 \ k-1\end{array}\right)\)，于是考虑前面的数，唯一的一个 \(\sum p=j\) 是空集，即 \(\sum p=0\)，此时有 \(|T|=0\) 求的则是:

\[ dp_{0,0, k}=\dbinom{-1}{k-1} \]

这个时候我们需要拓宽组合数的意义, 你可以认为 \(\binom{-1}{-1}=1\) 而 \(\binom{x}{y}\) 在 \(x\lt y\) 的时候为 \(0\)，\(x=y\) 的时候为 \(1\)。所以 \(dp\) 的边界为 \(dp_{0,0,0}=1\)。

转移的时候可以用滚动数组，总时间复杂度为 \(\Theta(nm(n-k))\)。

Gcd-Lcm 反演

一般地，求 \(\rm lcm\) 通常转化为求解 \(\gcd\)，因为 \(\gcd\) 的性质更为优秀，也可以借助莫比乌斯反演。

通用形式为：

\[ \mathrm{lcm}(S) = \prod\limits_{T \subseteq S, T \ne \varnothing} \gcd(T) ^ {(-1) ^ {|T| - 1}} \]

证明考虑使用 \(\rm Min-Max\) 容斥，考虑每个质因子 \(p\) 对左右的贡献：

\[ \begin{aligned} p ^ {\max(p, S)} &= p ^ {\sum\limits_{T \subseteq S, T \ne \varnothing} (-1) ^ {|T| - 1} \min(p, T)} \\ &= \prod\limits_{T \subseteq S, T \ne \varnothing} p ^ {(-1) ^ {|T| - 1} \min(p, T)} \\ &= \prod\limits_{T \subseteq S, T \ne \varnothing} \left(p ^ {\min(p, T)}\right) ^ {(-1) ^ {|T| - 1} } \end{aligned} \]

那么有：

\[ \begin{aligned} \mathrm{lcm}(S) &= \prod\limits_p p ^ {\max(p, S)} \\ &= \prod\limits_{p} \prod\limits_{T \subseteq S, T \ne \varnothing} \left(p ^ {\min(p, T)}\right) ^ {(-1) ^ {|T| - 1} } \\ &= \prod\limits_{T \subseteq S, T \ne \varnothing} \left(\prod\limits_p p ^ {\min(p, T)}\right) ^ {(-1) ^ {|T| - 1} } \\ &= \prod\limits_{T \subseteq S, T \ne \varnothing} \gcd(T) ^ {(-1) ^ {|T| - 1}} \end{aligned} \]

我们来看看 \(\rm Gcd-Lcm\) 反演有什么应用：

前路（出题人：本校学长 @\(\rm remoon\)）:

给定 \(A,B,C\)，求：

\[ \sum_{i=1}^A\sum_{j=1}^B\sum_{k=1}^C\mathrm{lcm}(i,j,k) \]

保证 \(A,B,C\leqslant 5\times 10^{4}\)，答案对 \(10^{9}+7\) 取模。

首先给出一个复杂度估界为 \(\Theta(n^{2})\) 的做法，但实测非常快。

请注意，以下的推导遵循一个原则，对 \(i, j, k\) 做相同变换，不会先处理一部分再处理一部分。

\[ \begin{aligned} Ans &= \sum\limits_{i = 1} ^ A \sum\limits_{j = 1} ^ B \sum\limits_{k = 1} ^ C \mathrm{lcm}(i, j, k) \\ &= \sum\limits_{i = 1} ^ A \sum\limits_{j = 1} ^ B \sum\limits_{k = 1} ^ C \frac{ijk(i, j, k)}{(i, j)(j, k)(k, i)} \qquad (\mathrm{Min-Max} ~ for ~ index) \\ &= \sum\limits_{i = 1} ^ A \sum\limits_{j = 1} ^ B \sum\limits_{k = 1} ^ C \frac{ijk}{(i, j)(j, k)(k, i)} \left( f \times \mu \times I \left((i, j, k)\right)\right) \qquad (f(i) = i)\\ &= \sum\limits_{d = 1} ^ A f \times \mu (d) \sum\limits_{i = 1} ^ {A / d} \sum\limits_{i = 1} ^ {B / d} \sum\limits_{i = 1} ^ {C / d} \frac{ijk}{(i, j)(j, k)(k, i)} \end{aligned} \]

令 \(F(A, B, C) = \sum\limits_{i = 1}^{A} \sum\limits_{i = 1}^{B} \sum\limits_{i = 1}^{C} \dfrac{ijk}{(i, j)(j, k)(k, i)}, g(i) = \dfrac{1}{i}, h = g \times \mu\) 则：

\[ \begin{aligned} F(A, B, C) &= \sum\limits_{i = 1} ^ A \sum\limits_{i = 1} ^ B \sum\limits_{i = 1} ^ C ijk ( f \times \mu \times I ((i, j)))( f \times \mu \times I ((j, k)))( f \times \mu \times I ((k, i))) \\ &= \sum\limits_{i = 1} ^ A \sum\limits_{i = 1} ^ B \sum\limits_{i = 1} ^ C ijk \sum\limits_{x \mid (i, j)} g \times \mu(x) \sum\limits_{y \mid (j, k)} g \times \mu(y) \sum\limits_{z \mid (k, i)} g \times \mu(z) \\ &= \sum\limits_{x = 1} ^ A \sum\limits_{y = 1} ^ B \sum\limits_{z = 1} ^ C h(x) h(y) h(z) \sum\limits_{x, z \mid i} i \sum\limits_{x, y \mid j} j \sum\limits_{y, z \mid k} k \\ &= \sum\limits_{x = 1} ^ A \sum\limits_{y = 1} ^ B \sum\limits_{z = 1} ^ C h(x) h(y) h(z) \sum\limits_{i = 1} ^ {A / \mathrm{lcm}(x, z)} i \times \mathrm{lcm}(x, z) \sum\limits_{j = 1} ^ {B / \mathrm{lcm}(x, y)} j \times \mathrm{lcm}(x, y) \sum\limits_{k = 1} ^ {C / \mathrm{lcm}(y, z)} k \times \mathrm{lcm}(y, z) \\ &= \sum\limits_{x = 1} ^ A \sum\limits_{y = 1} ^ B \sum\limits_{z = 1} ^ C h(x) h(y) h(z) S(A, \mathrm{lcm}(x, z)) S(B, \mathrm{lcm}(x, y)) S(C, \mathrm{lcm}(y, z)) \end{aligned} \]

可以发现，后者 \(x \rightarrow y \rightarrow z \rightarrow x\) 构成了一个三元环，我们可以大概给出估界为 \(\mathcal{O(n \log n \log \log n)}\)。因此暴力找出所有三元环的复杂度为：\(\mathcal{O(n \log n \log \log n\sqrt{n \log n \log \log n})}\)。

同时，因为这个在 \(n = 5000\) 时与 \(n^{2}\) 无区别，因此连边可以使用暴力。但也可以枚举 \(\mathrm{Lcm}\) 再枚举其约数，使用 \(\mathcal{O(n \log^{3n})}\) 连边。

此时我们算完了 \(F\)，可知总共需要算的 \(F\) 只有 \(\sqrt{n}\) 种，若将单次复杂度看作 \(n^{2}\)，因此总复杂度：

\[ \mathcal{O(n ^ 2\sum\limits_{i = 1} ^ {n} \frac{1}{i ^ 2})} = O(n ^ 2) \]

经过卡常之后，效率提升大约五倍多，以下是如何卡常的：

我写了一个大范围内的打表程序，发现实际原做法的连边数量大约是 \(n \log n \log \log n\) 级别的，因此这个做法很有卡常前途。

我们把暴力连边换掉，枚举其约数，使用 \(\mathcal{O(n \log^{3n})}\) 连边。连边暴力判断时不要求 \(\rm lcm\) 只需要求 \(\gcd(i / d_{j}, i / d_{k})\) 具体参见代码。如果你想要过本题，是一定要优化连边的。
可以发现我们需要调用的 \(\rm lcm\) 只有每条边的两个端点，而在枚举 \(\rm Lcm\) 时是可以 \(\mathcal{O(1)}\) 得知的，因此我们在连边时记录这个值。
可以发现，\(S\) 函数有很多是无用的，有用的第一维只有 \(\sqrt{A}\) 个，因此可以只预处理 \(A \sqrt{A}\) 个值。
\(\gcd\) 请不要暴力求，我们记忆化 \(a, b \leqslant 2e4\) 的部分，并用 \(\rm short\) 类型存储，减少空间消耗。

然后我们再给出一个复杂度为 \(\Theta(n^{1.5})\) 的正解做法。

方便起见用 \((x, y)\) 代指 \(\operatorname{gcd}(x, y)\)

\[ \sum_{i=1}^{A} \sum_{j=1}^{B} \sum_{k=1}^{C} \frac{(i, j, k) i j k}{(i, j)(j, k)(i, k)} \]

枚举 \(d\), 设 \(F(A, B, C)=\sum_{i=1}^{A} \sum_{j=1}^{B} \sum_{k=1}^{C} \frac{i j k}{(i, j)(j, k)(i, k)}\) 考虑计算:

\[ \sum_{d} \varphi(d) F\left(\frac{A}{d}, \frac{B}{d}, \frac{C}{d}\right) \]

令 \(n=\max (A, B, C)\), 假定我们可以在 \(\mathcal{O}\left(n^{c} \log^{k} n\right)\) 的复杂度计算一组 \(F(A, B, C)\), 则当 \(c\gt 1\) 时，恒有 \(\sum \frac{1}{d^{c}}\) 是收敛的，可以认为其为常数。（不过比较大）

只需要考虑快速计算一组 \(F(A, B, C)\), \(\rm remoon\) 给出的做法是同时反演三组，然后考虑通过三元环计数来计算答案，这里给出略为不同的思路:

\[ \begin{aligned} &F(A, B, C)=\sum_{i=1}^{A} \sum_{j=1}^{B} \sum_{k=1}^{C} \frac{i j k}{(i, j)(j, k)(i, k)} \\ &=\sum_{k} k \sum_{d}(f * \mu)(d) \sum_{d \mid i}^{A} \frac{i}{\operatorname{gcd}(i, k)} \sum_{d \mid j}^{B} \frac{j}{\operatorname{gcd}(j, k)} \\ &=\sum_{k} k \sum_{d}(f * \mu)(d) \frac{d^{2}}{\operatorname{gcd}(k, d)^{2}}\left(\sum_{i=1}^{A / d} \frac{i}{\operatorname{gcd}\left(i, \frac{k}{\operatorname{gcd}(k, d)}\right)}\right)\left(\sum_{i=1}^{B / d} \frac{i}{\operatorname{gcd}\left(i, \frac{k}{\operatorname{gcd}(k, d)}\right)}\right) \end{aligned} \]

不妨设 \(F(t, x)=\sum_{i \leq t} \frac{i}{\operatorname{gcd}(i, x)}\), 记 \(g(d)=(f * \mu)(d) d^{2}\)。

答案等价于：

\[ \sum_{k}^{C} k \sum_{d} \frac{g(d)}{\operatorname{gcd}(k, d)^{2}} F\left(\frac{A}{d}, \frac{k}{\operatorname{gcd}(k, d)}\right) F\left(\frac{B}{d}, \frac{k}{\operatorname{gcd}(k, d)}\right) \]

枚举 \(\frac{k}{\operatorname{gcd}(k, d)}\) 为 \(x\), 此时考虑到我们只需要计算 \(\mathcal{O}(n \sqrt{n})\) 组 \(F(n, x)\)。

考虑到 \(F(n, x)\) 事实上就是:

\[ \begin{aligned} &\sum_{i=1}^{n} \frac{i}{\operatorname{gcd}(i, x)} \\ &=\sum_{d \mid x}(f * \mu)(d) \times d S\left(\frac{n}{d}\right) \end{aligned} \]

枚举这 \(\sqrt{A}\) 种 \(n\), 可以发现后式就是一个高维前缀和的形式，可以在 \(\mathcal{O}\left(n^{1.5} \log \log n \sim n^{1.5} \log n\right)\) 的复杂度完成计算。考虑前半部分，不妨枚举 \(d, \operatorname{gcd}(k, d)\) （设为 \(t\) ) 以及 \(x\), 此时我们知道:

\(k=x t\), 故 \(x t \leq C\)
\(t \mid d\)
\(\operatorname{gcd}\left(\frac{d}{t}, x\right)=1\)
固定了 \(\frac{A}{d}, \frac{B}{d}\) 之后，我们可以发现 \(d\) 属于区间 \([l, r]\), 此时我们考虑将答案差分，简而言之，我们的任务是计算 \(n \sqrt{n}\) 次下式:
\[ \begin{aligned} &x \sum_{d \leq R} g(d) \sum_{t \mid d} \frac{1}{t}[x t \leq C]\left[\operatorname{gcd}\left(x, \frac{d}{t}\right)=1\right] \\ &=x \sum_{c \mid x} \mu(c) \sum_{c \mid d, d \leq R} g(d) \sum_{t \mid \frac{d}{\epsilon}} \frac{1}{t}\left[t \leq \frac{C}{x}\right] \end{aligned} \]

首先，我们不难考虑到本质不同的 \(\frac{C}{x}\) 只有 \(\sqrt{n}\) 种，可以考虑枚举每种 \(\frac{C}{x}=m\) ，并在此时预处理:

\[ g(d) \sum_{t \mid d} \frac{1}{t}[t \leq m] \]

对于某个 \(m\) ，这可以在 \(\mathcal{O}(n \log \log n)\) 的复杂度完成计算，总体而言，此部分可以在 \(\mathcal{O}\left(n^{1.5} \log \log n \sim n^{1.5} \log n\right)\) 完成预处理，设其为 \(G\left(d, \frac{C}{x}\right)\)。

最后，让我们为每个 \(c\) 考虑，穷举可能的 \(\sqrt{n}\) 种 \(m\) ，并为每个 \(c\) 建立大小为 \(\frac{\max R}{c}\) 的表格，显然表格的总大小为 \(n \log n\), 此时单组查询显然可以做到 \(\mathcal{O}(1)\), 由于 \(x\) 穷举 \(1 \sim n\) ，考察其约数个数和显然为 \(\mathcal{O}(n \log n)\), 总体而言我们可以在 \(\mathcal{O}\left(n^{1.5} \log n\right)\) 解决此问题。

一点新的思路:

我们考虑枚举 \(c\), 并为每个 \(c\), 对 \(\frac{C / c}{x}\) 的所有可能的取值进行预处理，不难发现这个部分的复杂度为 \(\sum\left(\frac{n}{c}\right)^{1.5}\)。

通过积分不难证明这部分等效于 \(n^{1.5}\)。

莫比乌斯反演

一些定义和性质

\(\rm Dirichlet\) 卷积 : \(\sum\limits_{d|n}f(d)g(\frac{n}{d})\) 被定义为 \(\rm Dirichlet\) 卷积。

莫比乌斯 \((\mu)\) 函数 :

\[ \mu(n)= \begin{cases} 1 & n=1 \\ 0 & n \text{ 含有平方因子 } \\ (-1)^k & k \text{ 为 } n \text{ 的本质不同质因子个数 } \end{cases} \]

显然，\(\mu\) 是积性函数，且它还有一些更加巧妙的性质，其中最常用的一个是 \(\mu \times 1=\varepsilon\)。

\(\large\rm Proof:\)

此处的乘号表示 \(\rm Dirichlet\) 卷积，\(1\) 表示常数函数 \(\forall x\in [1,+\infty),f(x)=1\)，\(\varepsilon\) 表示单位函数 \(\forall x\in [1,+\infty),f(x)=[x=1]\)。

设 \(n=\prod_{i=1}^{k} p_{i}^{c_{i}}, n^{\prime}=\prod_{i=1}^{k} p_{i}\)。

那么 \(\sum\limits_{d \mid n} \mu(d)=\sum\limits_{d \mid n^{\prime}} \mu(d)=\sum\limits_{i=0}^{k}\tbinom{k}{i}\cdot(-1)^{i}=(1+(-1))^{k}\)。

根据二项式定理，易知该式子的值在 \(k=0\) 即 \(n=1\) 时值为 \(1\) 否则为 \(0\)，这也同时证明了 \(\sum\limits_{d \mid n} \mu(d)=[n=1]=\varepsilon(n)\) 以及 \(\mu * 1=\varepsilon\)。

两个反演式子

\[ [n=1]=\sum_{d|n}\mu(d) \]

\(\large\rm Proof:\)

\[ [n=1]=\varepsilon(n)=\mu \times 1(n)=\sum_{d|n}\mu(d) \]

我们来看看这个式子有什么应用：

给定一个长度为 \(n\) 的序列 \(a\)，给定 \(m\) 个询问 \(l,r,x\)，求 \(a_{l},a_{l+1}......a_{r}\) 中有多少个数与 \(x\) 互质。

保证 \(n,m,a_{i},x\leqslant 10^{5}\)。

考虑莫比乌斯反演: \(\left[\left(a_{i}, x\right)=1\right]=\sum\limits_{\left.d \mid a_{i}, x\right)} \mu(d)=\sum\limits_{d\left|a_{i}, d\right| x} \mu(d)\)。

由于答案求 \(\sum\limits_{i=l}^{r}\left[\left(a_{i}, x\right)=1\right]=\sum\limits_{i=l}^{r} \sum\limits_{d\left|a_{i}, d\right| x} \mu(d)=\sum\limits_{d \mid x} \mu(d) \sum\limits_{i=l}^{r}\left[d \mid a_{i}\right]_{\text {.}}\)

考虑对于每一个数, 预处理出它的倍数出现在哪些位置, 然后询问时枚举所有 \(x\) 的因数, 二分一下即可求出 \([l, r]\) 内它的倍数有多少个。时间复杂度 \(\Theta(n \sigma(\operatorname{maxa}) \log n)\)。

考虑对上述算法进行优化：

我们可以只考虑 \(\mu\) 值不等于 \(0\) 的因数。
考虑预处理出小于 \(\sqrt{maxa}\) 的所有因数的前缀和，这样对于这些因数的询问是 \(\Theta(1)\) 的。
考虑我们相当于要求 \(q\) 个询问不大于 \(x\) 的为某个数的倍数的方案数。先将这些点排个序，然后就可以直接 \(\rm two\ pointers\) 求。时间复杂度可以降到 \(\Theta(n\sigma(maxa))\)。

三者实现其一即可通过本题。

\[ f(n)=\sum_{d|n}g(d)\iff g(n)=\sum_{d|n}\mu(d)f\left(\frac{n}{d}\right) \]

\(\large\rm Proof:\)

\[ \because f=g\times I \]\[ \therefore f\times \mu=g\times I \times \mu \]\[ \therefore f\times \mu=g\times \varepsilon = g \]

我们来看看这个式子有什么应用：

给出 \(n\) 个询问，每个询问给定 \(5\) 个整数 \(a,b,c,d,k\)，求：

\[ \sum_{i=a}^{b}\sum_{j=c}^d[\gcd(i,j)=k] \]

保证 \(n,a,b,c,d,k\leqslant 5\times 10^{4}\)。

根据容斥原理, 原式可以分成 \(4\) 块来处理，每一块的式子都形如：

\[ \sum_{i=1}^{n} \sum_{j=1}^{m}[\operatorname{gcd}(i, j)=k] \]

考虑化简该式子：

\[ \sum_{i=1}^{\left\lfloor\frac{n}{k}\right\rfloor} \sum_{j=1}^{\left\lfloor\frac{m}{k}\right\rfloor}[\operatorname{gcd}(i, j)=1] \]

因为 \(\operatorname{gcd}(i, j)=1\) 时对答案才有贡献，于是我们可以将其替换为 \(\varepsilon(\operatorname{gcd}(i, j))\)，故原式化为：

\[ \sum_{i=1}^{\left\lfloor\frac{n}{k}\right\rfloor} \sum_{j=1}^{\left\lfloor\frac{m}{k}\right\rfloor} \varepsilon(\operatorname{gcd}(i, j)) \]

将 \(\varepsilon\) 函数展开得到：

\[ \sum_{i=1}^{\left\lfloor\frac{n}{k}\right\rfloor} \sum_{j=1}^{\left\lfloor\frac{m}{k}\right\rfloor} \sum_{d \mid \operatorname{gcd}(i, j)} \mu(d) \]

变换求和顺序, 先枚举 \(d \mid \operatorname{gcd}(i, j)\) 可得：

\[ \sum_{d=1}^{\min \left(\left\lfloor\frac{n}{k}\right\rfloor,\left\lfloor\frac{m}{k}\right\rfloor\right)} \mu(d) \sum_{i=1}^{\left\lfloor\frac{n}{k}\right\rfloor}[d \mid i] \sum_{j=1}^{\left\lfloor\frac{m}{k}\right\rfloor}[d \mid j] \]

易知 \(1 \sim\left\lfloor\frac{n}{k}\right\rfloor\) 中 \(d\) 的倍数有 \(\left\lfloor\frac{n}{k d}\right\rfloor\) 个, 故原式化为：

\[ \sum_{d=1}^{\min \left(\left\lfloor\frac{n}{k}\right\rfloor,\left\lfloor\frac{m}{k}\right\rfloor\right)} \mu(d)\left\lfloor\frac{n}{k d}\right\rfloor\left\lfloor\frac{m}{k d}\right\rfloor \]

很显然，式子可以数论分块求解。

时间复杂度 \(\Theta(W+n\sqrt{W})\)。

莫比乌斯反演的非卷积形式

对于数论函数 \(f,g\) 和完全积性函数 \(t\)，满足 \(t(1)=1\)，有：

\[ f(n)=\sum_{i=1}^nt(i)g\left(\left\lfloor\frac{n}{i}\right\rfloor\right)\ \iff g(n)=\sum_{i=1}^n\mu(i)t(i)f\left(\left\lfloor\frac{n}{i}\right\rfloor\right) \]

\(\large\rm Proof:\)

\[ \begin{aligned} g(n) &= \sum_{i=1}^n\mu(i)t(i)f\left(\left\lfloor\frac{n}{i}\right\rfloor\right) \\ &= \sum_{i=1}^n\mu(i)t(i) \sum_{j=1}^{\left\lfloor\frac{n}{i}\right\rfloor}t(j) g\left(\left\lfloor\frac{\left\lfloor\frac{n}{i}\right\rfloor}{j}\right\rfloor\right) \\ &= \sum_{i=1}^n\mu(i)t(i) \sum_{j=1}^{\left\lfloor\frac{n}{i}\right\rfloor}t(j) g\left(\left\lfloor\frac{n}{ij}\right\rfloor\right) \\ &= \sum_{T=1}^n \sum_{i=1}^n\mu(i)t(i) \sum_{j=1}^{\left\lfloor\frac{n}{i}\right\rfloor}[ij=T] t(j)g\left(\left\lfloor\frac{n}{T}\right\rfloor\right) \\ &= \sum_{T=1}^n \sum_{i \mid T}\mu(i)t(i) t\left(\frac{T}{i}\right)g\left(\left\lfloor\frac{n}{T}\right\rfloor\right) \\ &= \sum_{T=1}^n g\left(\left\lfloor\frac{n}{T}\right\rfloor\right) \sum_{i \mid T}\mu(i)t(i)t\left(\frac{T}{i}\right) \\ &= \sum_{T=1}^n g\left(\left\lfloor\frac{n}{T}\right\rfloor\right) \sum_{i \mid T}\mu(i)t(T) \\ &= \sum_{T=1}^n g\left(\left\lfloor\frac{n}{T}\right\rfloor\right)t(T) \sum_{i \mid T}\mu(i) \\ &= \sum_{T=1}^n g\left(\left\lfloor\frac{n}{T}\right\rfloor\right)t(T) \varepsilon(T) \\ &= g(n)t(1) \\ &= g(n) \end{aligned} \]