组合数学笔记-排列与组合

目录

• 排列与组合
  • 排列
    • 排列的定义与基本性质
  • 错位排列
    • 错位排列的定义与基本性质
  • 圆排列
    • 圆排列的定义与基本性质
  • 多重集排列
    • 多重集排列的定义与基本性质
  • 组合
    • 组合的定义与基本性质
    • 二项式定理
    • 范德蒙德卷积
    • 卢卡斯定理
    • 组合数的求法
      • 加法递推
      • 乘法递推
      • 公式法
      • 卢卡斯定理
      • 扩展卢卡斯定理
      • 枚举质因子重数
  • 多重集组合
    • 多重集组合的定义与基本性质
  • 计数技巧
    • 计数的方法与原则
    • 捆绑法
    • 插空法
    • 隔板法

排列与组合

排列

排列的定义与基本性质

定义 设一个集合 $S$ 中有 $n$ 个元素，从中有序地取出 $m(0\leq m \leq n)$ 个元素排成一列， 称为 $S$ 的一个 $m$ 排列。两个排列相同，当且仅当元素相同且顺序相同。我们记 $\text{P}_n^m$ 、 $\text{A}_n^m$ 或 $\text{P}(n,m)$ 表示 $S$ 中 $m$ 排列的总数。

约定 当 $m>n$ 时，$\text{P}_n^m = 0$ 。

全排列的定义 设一个集合 $S$ 中有 $n$ 个元素，其 $n$ 排列称为全排列。

• C++中，next_permutation 函数可以按字典序从小到大遍历数据的全排列，prev_permutation 函数与之相反。

性质1 $\mathrm{P}_n^m = n(n-1)(n-2)\cdots(n-m+1) = \dfrac{n!}{(n-m)!}$ ，其中 $0\leq m \leq n$。

性质2 $\text{P}_n^m = n\text{P}_{n-1}^{m-1}$ 。

性质3 $\text{P}_n^m = m \text{P}_{n-1}^{m-1} + \text{P}_{n-1}^{m}$ 。

性质1的证明：

考虑乘法原理，按顺序选数，第 $i(1\leq i\leq m)$ 个数有 $n-i+1$ 种选法，乘在一起可得原式。

性质2的证明：

考虑乘法原理，第一个数有 $n$ 种选法，再从剩下的 $n-1$ 个数里选 $m-1$ 个有 $\text{P}_{n-1}^{m-1}$ 种排列，所以 $\text{P}_n^m = n\text{P}_{n-1}^{m-1}$ 。

性质3的证明：

考虑加法原理，考虑分两类：

1. 先指定选一个元素，有 $m$ 个位置可放，再从剩下 $n-1$ 元素中选 $m-1$ 个有 $\text{P}_{n-1}^{m-1}$ 种排列。
2. 不选1指定的元素，从其他 $n-1$ 元素里选 $m$ 个，共 $\text{P}_{n}^{m-1}$ 种排列。

因此 $\text{P}_n^m = m \text{P}_{n-1}^{m-1} + \text{P}_{n-1}^{m}$ 。

错位排列

错位排列的定义与基本性质

定义 设 $P=(p_1,p_2,\cdots,p_n)$ 是 $S=\{1,2,\cdots,n\}$ 的一个排列，若对于任意的 $i \in[1,n]$ 满足 $p_i \neq i$ ，则称 $P$ 是 $S$ 的一个错位排列。我们记 $D_n$ 表示 $S$ 的错位排列的总数。

性质1 $D_n$ 满足

$$D_n = \begin{cases} 1 &, n = 0\\ 0 &, n = 1\\ 1 &, n = 2\\ (n-1)(D_{n-1} + D_{n-2}) &, n \geq 3 \end{cases}$$

性质2 $\displaystyle D_n = n!\sum_{k=0}^n \frac{(-1)^k}{k!}$ 。

性质3 $D_n = \left\lfloor \dfrac{n!}{\text{e}} + \dfrac{1}{2} \right\rfloor$ 。

性质4 $\{1,2,\cdots ,n \}$ 的排列是错位排列的概率 $P_n$ 有渐进 $\lim_\limits{n \to \infty} P_n = \lim_\limits{n \to \infty} \dfrac{D_n}{n!} = \dfrac{1}{\text{e}}$ ，表明 $D_n$ 的增长率与 $n!$ 仅相差常数倍。

性质1的证明：

考虑加法原理，设 $n$ 出现在位置 $k(1\leq k\leq n-1)$ ，有两种情况：

1. $k$ 一定出现在位置 $n$ ，那么除去 $k,n$ 剩下 $n-2$ 个数错排即可，共计 $D_{n-2}$ 。
2. $k$ 不能出现在位置 $n$ ，那么可把位置 $n$ 视作 $k$ 的新位置与除了 $n$ 的数进行错排，共计 $D_{n-1}$ 。

因此再根据乘法原理，有 $D_n = (n-1)(D_{n-1}+D_{n-2})$ 。

性质2的证明：

考虑减法原理，设全集 $U$ 为 $[1,n]$ 的全排列，则 $|U| = n!$ ，设满足 $p_i \neq i$ 的排列的集合为 $S_i$ ，那么满足 $p_i = i$ 的集合为 $\overline{S_i}$ ，那么有 $\displaystyle \left| \bigcap_{i=1}^n S_i \right| = |U| - \left| \bigcup_{i=1}^n \overline{S_i} \right|$ ，问题转换为求 $\displaystyle \left| \bigcup_{i=1}^n \overline{S_i} \right|$ 。

考虑容斥原理，有 $\displaystyle \left| \bigcup_{i=1}^n S_i\right| = \sum_{k=1}^n (-1)^{k-1} \sum_{1 \leq i_1<i_2< \cdots < i_k \leq n} \left| \bigcap_{j=1}^k S_{i_j} \right|$ ，其中 $\displaystyle \left| \bigcap_{j=1}^k S_{i_j} \right|$ 为所有 $i \in T$ 满足 $p_i = i$ 的排列数，显然为 $(n-k)!$ ，对于 $1\leq i_1 < i_2 < \cdots < i_k < n$ 共有 $\dbinom{n}{k}$ 种方案，因此 $\displaystyle \left| \bigcup_{i=1}^n S_i\right| = \sum_{k=1}^n (-1)^{k-1} \binom{n}{k}(n-k)! = \sum_{k=1}^n (-1)^{k-1} \frac{n!}{k!}$ 。

最后，错位排列数 $\displaystyle \left| \bigcap_{i=1}^n S_i \right| = |U| - \left| \bigcup_{i=1}^n \overline{S_i} \right| = n! - \sum_{k=1}^n (-1)^{k-1} \frac{n!}{k!} = n!\sum_{k=0}^n \frac{(-1)^k}{k!}$ 。

圆排列

圆排列的定义与基本性质

定义 设一个集合 $S$ 中有 $n$ 个元素，从中有序地取出 $m(0\leq m \leq n)$ 个元素排成不分首尾围成一圈， 称为 $S$ 的一个 $m$ 圆排列。两个圆排列相同，当且仅当元素相同且不分首位地顺序相同。我们记 $\text{Q}_n^m$ 表示 $S$ 的 $m$ 圆排列的总数。

性质1 $\text{Q}_n^m = \dfrac{\text{P}_n^m}{m}$ 。

性质1的证明：

对于每一种圆排列，我们可以规定首尾使其变成标准排列，共有 $m$ 种首尾方案，因此有 $\text{Q}_n^m \cdot m = \text{P}_n^m$ ，所以 $\text{Q}_n^m = \dfrac{\text{P}_n^m}{m}$ 。

多重集排列

多重集排列的定义与基本性质

定义 设多重集 $S = \{n_1 \cdot a_1,n_2 \cdot a_2,\cdots ,n_k \cdot a_k\}$ ，从中任选 $m$ 个元素组成排列，称为 $S$ 的 $m$ 排列。

多重组合数的定义 设多重集 $S = \{n_1 \cdot a_1,n_2 \cdot a_2,\cdots ,n_k \cdot a_k\}$ ， $n = \displaystyle \sum_{i=1}^k n_i$ ，则 $S$ 的 $n$ 排列（即全排列）的总数称为多重组合数，记为 $\dbinom{n}{n_1,n_2,\cdots ,n_k}$ 。

性质1 设多重集 $S = \{n_1 \cdot a_1,n_2 \cdot a_2,\cdots ,n_k \cdot a_k\}$ ，$n = \displaystyle \sum_{i=1}^k n_i$ ，则全排列数为 $\dbinom{n}{n_1,n_2,\cdots ,n_k} = \dfrac{n!}{\displaystyle \prod_{i=1}^k n_i!}$ 。

性质2 设多重集 $S = \{n_1 \cdot a_1,n_2 \cdot a_2,\cdots ,n_k \cdot a_k\}$ ，若 $m$ 满足 $m \leq n_i \leq +\infty(1\leq i\leq k)$ ，则 $m$ 排列数为 $k^m$ 。

性质1的证明：

不考虑元素重复的全排列为 $n!$ ，再对每个元素的全排列 $n_i!(1\leq i\leq k)$ 去重，所以 $\dbinom{n}{n_1,n_2,\cdots ,n_k} = \dfrac{n!}{\displaystyle \prod_{i=1}^k n_i!}$ 。

性质2的证明：

因为选 $m$ 个小于等于任意元素的个数，所以每次都能选 $k$ 个元素，因此总数为 $k^m$ 。

组合

组合的定义与基本性质

定义 设一个集合 $S$ 中有 $n$ 个元素，从中无序地取出 $m(0\leq m \leq n)$ 个元素组成集合， 称为 $S$ 的一个 $m$ 组合。两个组合相同，当且仅当元素相同。我们记 $\text{C}_n^m$ 、 $\dbinom{n}{m}$ 或 $\text{C}(n,m)$ 表示 $S$ 中 $m$ 组合的总数。

约定 当 $m>n$ 时，$\dbinom{n}{m} = 0$ 。

性质1 $\dbinom{n}{m} = \dfrac{\text{P}_n^m}{m!} = \dfrac{n!}{m!(n-m)!}$ 。

性质2 $\dbinom{n}{m} = \dbinom{n}{n-m}$ 。

性质3 $\dbinom{n}{m} = \dfrac{n-m+1}{m} \dbinom{n}{m-1}$ 。

性质4 $\dbinom{n}{m} = \dfrac{n}{m} \dbinom{n-1}{m-1}$ 。

性质5（杨辉三角） $\dbinom{n}{m} = \dbinom{n-1}{m} + \dbinom{n-1}{m-1}$ 。

性质6 $\displaystyle \sum_{i=0}^n \binom{i}{m} = \binom{n+1}{m+1}$ 。

性质7 $\dbinom{n}{m} \dbinom{m}{k} = \dbinom{n}{k} \dbinom{n-k}{m-k}$ 。

性质8 $\displaystyle \sum_{i=0}^n \binom{n-i}{i} = F_{n+1}$ ，其中 $F$ 是斐波那契数列。

性质1的证明：

先考虑顺序得到的总数为 $m$ 排列数 $\text{P}_n^m$ ，而对于一种 $m$ 组合有 $m!$ 种排列方式，所以 $m!\dbinom{n}{m} = \text{P}_n^m$ ，因此根据排列性质1可得 $\dbinom{n}{m} = \dfrac{\text{P}_n^m}{m!} = \dfrac{n!}{m!(n-m)!}$ 。

性质2的证明：

方法1：

由性质1易得。

方法2：

$n$ 个里选 $m$ 个组合，等价于 $n$ 个里选 $n-m$ 不在组合。

性质5的证明：

方法1：

由性质1易得。

方法2：

画出杨辉三角，由数学归纳法易得。

方法3：

指定一个元素，如果一定不选它则有 $\dbinom{n-1}{m}$ 种组合，如果一定选它则有 $\dbinom{n-1}{m-1}$ 种组合，考虑加法原理，得证。

性质6的证明：

方法1：

根据性质5可得

$$\begin{aligned} \sum_{i=0}^n \binom{i}{m} &= \sum_{i=m}^n \binom{i}{m} \\ &= \binom{m+1}{m+1} + \binom{m+1}{m} + \binom{m+2}{m} +\cdots + \binom{n}{m} \\ &= \binom{m+2}{m+1} + \binom{m+2}{m} + \cdots + \binom{n}{m} \\ &= \binom{m+3}{m+1} + \cdots + \binom{n}{m}\\ &= \binom{n+1}{m+1} \end{aligned}$$

方法2：

从 $[0,n]$ 的整数中选出 $m+1$ 个数的组合数为 $\dbinom{n+1}{m+1}$ ，在这些组合中最大数为 $i(0\leq i\leq n)$ 的组合数为 $\dbinom{i}{m}$ ，考虑加法原理得证。

性质7的证明：

方法1：

由性质1可得

$$\begin{aligned} \binom{n}{m} \binom{m}{k} &= \frac{n!}{m!(n-m)!} \cdot \frac{m!}{k!(m-k)!} \\ &= \frac{n!}{k!} \cdot \frac{1}{(m-k)!(n-m)!} \\ &= \frac{n!}{k!(n-k)!} \cdot \frac{(n-k)!}{(m-k)!(n-m)!} \\ &= \binom{n}{k} \binom{n-k}{m-k} \\ \end{aligned}$$

方法2：

左式是正着选，从 $n$ 个元素中选 $m$ 个，对于每个 $m$ 组合再选 $k$ 个的 $k$ 组合的总数的总和。

右式是倒着选，先从 $n$ 个元素中选 $k$ 个，对于每个 $k$ 组合从剩下 $n-k$ 个元素中再选 $m-k$ 个元素，代表这个 $k$ 组合会被所有 $m$ 组合选到的次数，最后总和与左式意义等价。

性质8的证明：

设 $G_n = \displaystyle \sum_{i=0}^n \binom{n-i}{i}$ ，则 $G_0 = 1 = F_1,G_1 = 1 = F_2$ 。

假设当 $n = k+1(k\geq 0)$ 时， $G_k = F_{k+1},G_{k+1} = F_{k+2}$ 成立。

那么当 $n = k+2$ 时，由性质5可得

$$\begin{aligned} G_{k}+G_{k+1} &= \sum_{i = 0}^k \binom{k-i}{i} + \sum_{i = 0}^{k+1} \binom{k+1-i}{i} \\ &= \sum_{i = 1}^{k+1} \binom{k-i+1}{i-1} + \sum_{i = 1}^{k+1} \binom{k+1-i}{i} + 1 \\ &= \sum_{i = 1}^{k+1} \left( \binom{k+1-i}{i-1} + \binom{k+1-i}{i} \right) + 1 \\ &= \sum_{i = 1}^{k+1} \binom{k+2-i}{i} + \binom{k+2}{0} + \binom{0}{k+2}\\ &= \sum_{i = 0}^{k+2} \binom{k+2-i}{i} \\ &= G_{k+2} \end{aligned}$$

同时有 $G_{k}+G_{k+1} = F_{k+1}+F_{k+2} = F_{k+3}$ ，因此 $G_{k+1} = F_{k+2},G_{k+2} = F_{k+3}$ ，得证。

二项式定理

定理1（二项式定理） $\displaystyle (x+y)^n = \sum_{i=0}^n \binom{n}{i}x^{n-i}y^i$ 。

• 推论1（定理1的推论） $\displaystyle \sum_{i=0}^n \dbinom{n}{i} = 2^n$ 。

• 推论2（定理1的推论） $\displaystyle \sum_{i=0}^n (-1)^{i}\dbinom{n}{i} = [n=0]$ 。

• 推论3（推论2的推论） $\displaystyle \binom{n}{0} + \binom{n}{2} + \cdots = \binom{n}{1} + \binom{n}{3} + \cdots = 2^{n-1}$ ，其中 $n \geq 1$ 。

定理2（扩展二项式定理） $\displaystyle \left( \sum_{i = 1}^k x_i \right)^n = \sum_{n_1+n_2+\cdots + n_k = n} \binom{n}{n_1,n_2,\cdots ,n_k}\prod_{i = 1}^k x_i^{n_i}$ 。

广义组合数的定义 设 $\alpha \in \R,m \in \N$ ，则 $\displaystyle \binom{\alpha}{m} = \frac{\displaystyle \prod_{i = 0}^m(\alpha-i)}{m!}$ 。

定理3（广义二项式定理） $\displaystyle (x+y)^\alpha = \sum_{i=0}^{\infty} \binom{\alpha}{i}x^{\alpha-i}y^i$ ，其中 $\alpha \in \R$ 。

定理1的证明：

方法1：

当 $n = 0$ 时显然得证。

假设当 $n = k$ 时， $\displaystyle (x+y)^k = \sum_{i=0}^k \binom{k}{i}x^{k-i}y^i$ 成立。

当 $n = k+1$ 时，根据组合基本性质5有

$$\begin{aligned} (x+y)^{k+1} &= (x+y)\sum_{i=0}^k \binom{k}{i}x^{k-i}y^i \\ &= x\sum_{i=0}^k \binom{k}{i}x^{k-i}y^i + y\sum_{i=0}^k \binom{k}{i}x^{k-i}y^i \\ &= \sum_{i=0}^k \binom{k}{i}x^{k+1-i}y^i + \sum_{i=1}^{k+1} \binom{k}{i-1}x^{k-i+1}y^i \\ &= \binom{k}{0}x^{k+1} + \sum_{i=1}^k \binom{k}{i}x^{k+1-i}y^i + \sum_{i=1}^{k} \binom{k}{i-1}x^{k-i+1}y^i + \binom{k}{k}y^{k+1} \\ &= \binom{k}{0}x^{k+1} + \sum_{i=1}^k \binom{k+1}{i}x^{k+1-i}y^i + \binom{k+1}{k+1}y^{k+1} \\ &= \sum_{i=0}^{k+1} \binom{k+1}{i}x^{k+1-i}y^i \\ \end{aligned}$$

于是得证。

方法2：

我们枚举 $x,y$ 的指数 $i,j$ 满足 $i+j = n$ 的情况，等价于枚举 $i(0\leq i \leq n)$ 得到 $j = n - i$ 。对于一个 $i$ 的情况，需要求在 $n$ 个 $(x+y)$ 括号中有 $i$ 个选 $x$ 和 $n-i$ 个选 $y$ 的方案数。

我们可以 $n$ 选 $i$ 后 $n-i$ 选 $n-i$ 共 $\dbinom{n}{i} \dbinom{n-i}{n-i} = \dbinom{n}{i}$ 种方案。

当然，我们也可以理解为一个多重集的模型，有 $i$ 个选 $x$ 的 $(x+y)$ 和 $n-i$ 个选 $y$ 的 $(x+y)$ ，选择相同的 $(x+y)$ 算相同的元素，不同的顺序算不同的方案，所以是求有限多重集的全排列数，为 $\dbinom{n}{i,n-i} = \dbinom{n}{i}$ 种方案。

因此 $\displaystyle (x+y)^n = \sum_{i=0}^n \binom{n}{i}x^{n-i}y^i$ 。

定理2的证明：

同样可以使用归纳法，但比较复杂，我们使用定理1的证法2，即组合意义证明。

我们枚举 $x_i(1\leq i \leq k)$ 的指数 $n_i$ 满足 $n_1 + n_2 + \cdots + n_k = n$ 的情况。对于一组非负整数解 $n_1,n_2,\cdots ,n_k$ ，需要求在 $n$ 个 $(x_1 + x_2 + \cdots + x_k)$ 括号中有 $n_i(1\leq i \leq k)$ 个括号内选了 $x_i$ 的方案数。

我们设多重集有 $n_i(1\leq i \leq k)$ 个选 $x_i$ 的 $(x_1+x_2+\cdots + x_k)$ ， 其全排列数为 $\dbinom{n}{n_1,n_2,\cdots,n_k}$ 。

因此 $\displaystyle \left( \sum_{i = 1}^k x_i \right)^n = \sum_{n_1+n_2+\cdots + n_k = n} \binom{n}{n_1,n_2,\cdots ,n_k}\prod_{i = 1}^k x_i^{n_i}$ 。

范德蒙德卷积

定理1（范德蒙德卷积） $\displaystyle \sum_{i = 0}^k \dbinom{n}{i} \dbinom{m}{k-i} = \dbinom{n+m}{k}$ 。

• 推论1（定理1的推论） $\displaystyle \sum_{i = -s}^r \dbinom{n}{i+s} \dbinom{m}{r-i} = \dbinom{n+m}{s+r}$ 。
• 推论2（定理1的推论） $\displaystyle \sum_{i = 0}^n \dbinom{n}{i}\dbinom{n}{i-1} = \dbinom{2n}{n-1}$ 。
• 推论3（定理1的推论） $\displaystyle \sum_{i = 0}^n \dbinom{n}{i}^2 = \dbinom{2n}{n}$ 。
• 推论4（定理1的推论） $\displaystyle \sum_{i = 0}^m \dbinom{n}{i} \dbinom{m}{i} = \dbinom{n+m}{m}$ 。

定理1的证明：

方法1：

由二项式定理的定理1可得

$$\begin{aligned} \sum_{k = 0}^{n+m} \binom{n+m}{k} x^k &= (1+x)^{n+m} \\ &= (1+x)^n(1+x)^m \\ &= \left( \sum_{i = 0}^n \binom{n}{i}x^i \right)\left( \sum_{j = 0}^m \binom{m}{j}x^j \right) \\ &= \sum_{i = 0}^n \sum_{j = 0}^m \binom{n}{i} \binom{m}{j} x^{i+j} \\ &= \sum_{k = 0}^{n+m} \sum_{i = 0}^k \binom{n}{i} \binom{m}{k-i} x^k \end{aligned}$$

根据待定系数法 $x^k$ 的系数相同，可得 $\displaystyle \sum_{i = 0}^k \dbinom{n}{i} \dbinom{m}{k-i} = \dbinom{n+m}{k}$ 。

方法2：

一个集合有 $n+m$ 个元素，从中选 $k$ 个元素的方案数为 $\dbinom{n+m}{k}$ 。

其等价于，将集合分成 $n,m$ 两部分，从 $n$ 中选 $i(0 \leq i \leq k)$ 个再从 $m$ 中选 $k-i$ 个，共 $\displaystyle \sum_{i = 0}^k \dbinom{n}{i} \dbinom{m}{k-i}$ 种方案。

推论1的证明：

由定理1简单变换可得

$$\begin{aligned} \sum_{i = 0}^k \binom{n}{i} \binom{m}{k-i} &= \sum_{i=-r}^{k-r} \binom{n}{i+r} \binom{m}{k-i-r}\\ &= \sum_{i=-r}^{s} \binom{n}{i+r} \binom{m}{s-i} \\ &= \binom{n+m}{s+r} \end{aligned}$$

于是得证。

推论2的证明：

由定理1简单变换可得

$$\begin{aligned} \sum_{i = 0}^n \binom{n}{i}\binom{n}{i-1} &= \sum_{i = 0}^n \binom{n}{i}\binom{n}{n-i+1}\\ &= \binom{2n}{n+1} \\ &= \binom{2n}{n-1} \end{aligned}$$

于是得证。

推论3的证明：

由定理1简单变换可得

$$\begin{aligned} \sum_{i = 0}^n \binom{n}{i}^2 &= \sum_{i = 0}^n \binom{n}{i}\binom{n}{n-i}\\ &= \binom{2n}{n} \\ \end{aligned}$$

于是得证。

推论4的证明：

方法1：

由定理1简单变换可得

$$\begin{aligned} \sum_{i = 0}^n \binom{n}{i}\binom{m}{i} &= \sum_{i = 0}^n \binom{n}{i}\binom{m}{m-i}\\ &= \binom{n+m}{m} \\ \end{aligned}$$

于是得证。

方法2：

在 $n \times m$ 的网格图上，从 $(0,0)$ 走到 $(n,m)$ ，只能向右或者向下走，有多少方案。

显然会向右走 $m$ 步和向下走 $n$ 步共 $n+m$ 步，所以方案数是 $\dbinom{n+m}{m} \dbinom{n}{n} = \dbinom{n+m}{m}$ 。

其等价于，将 $n+m$ 步分为 $n,m$ 步，在 $n$ 步中选 $i(0\leq i \leq m)$ 步向右，然后在 $m$ 步选 $m-i$ 步向右，有 $\displaystyle \sum_{i = 0}^m \dbinom{n}{i} \dbinom{m}{i}$ 种方案。

卢卡斯定理

定理1（卢卡斯定理） 若 $p$ 是质数，则 $\dbinom{n}{m} \equiv \dbinom{n \bmod p}{m \bmod p} \dbinom{\lfloor n/p \rfloor}{\lfloor m/p \rfloor} \pmod p$ 。

• 推论1（定理1的推论） 若 $p$ 是质数，整数 $n,m(0\leq m \leq n)$ 的 $p$ 进制表达分别为 $n = a_ka_{k-1}\cdots a_0, m = b_kb_{k-1}\cdots b_0$ ，其中 $a_i,b_i \in[0,p)(0\leq i \le k)$ ，则 $\displaystyle \binom{n}{m} \equiv \prod_{i = 0}^k\binom{a_i}{b_i}\pmod p$ 。

定理1的证明：

先证明 $(x+y)^p \equiv x^p + y^p \pmod p$ ，其中 $p$ 为素数。

考虑二项式 $(x+y)^p$ ，根据二项式定理有 $\displaystyle (x+y)^p = \sum_{i=0}^p \binom{p}{i}x^{p-i}y^i$ ，其中 $\dbinom{p}{i} = \dfrac{p!}{i!(p-i)!}$ ，显然当且仅当 $i = 0$ 或 $i = p$ 时 $\dbinom{p}{i}$ 没有质因子 $p$ 且此时值为 $1$ ，因此 $\dbinom{p}{i} \equiv [i = 0 \or i = p] \pmod p$ ，所以 $(x+y)^p \equiv x^p + y^p \pmod p$ 。

现在我们证明定理。

考虑二项式 $(1+x)^n$ ，我们有

$$\begin{aligned} (1+x)^n &\equiv (1+x)^{p \lfloor n/p \rfloor} (1+x)^{n \, \bmod \, p} \\ &\equiv (1+x^p)^{\lfloor n/p \rfloor}(1+x)^{n \, \bmod \, p} \\ &\equiv \left( \sum_{i=0}^{\lfloor n/p \rfloor} \binom{\lfloor n/p \rfloor}{i}x^{ip} \right) \left( \sum_{j=0}^{n \, \bmod \, p} \binom{n \bmod p}{j}x^j \right) \\ &\equiv \sum_{i=0}^{\lfloor n/p \rfloor} \sum_{j=0}^{n \, \bmod \, p} \binom{\lfloor n/p \rfloor}{i} \binom{n \bmod p}{j} x^{ip+j} \pmod p \end{aligned}$$

其中 $j \in [0,n \bmod p],n \bmod p<p$ ，那么不会有同一组 $(i,j)$ 使得 $ip+j$ 相等，因此和式里的系数就是 $x^{ip+j}$ 的系数。

根据二项式定理 $\displaystyle (1+x)^n = \sum_{i=0}^n \dbinom{n}{i}x^i$ ， $x^m$ 的系数为 $\dbinom{n}{m}$ 。在模 $p$ 下，令 $ip + j = m$ 有 $i = \left\lfloor \dfrac{m}{p} \right\rfloor,j = m \bmod p$ ， $x^m$ 的系数为 $\dbinom{n \bmod p}{m \bmod p} \dbinom{\lfloor n/p \rfloor}{\lfloor m/p \rfloor}$ 。因此，根据待定系数法可得， $\dbinom{n}{m} \equiv \dbinom{n \bmod p}{m \bmod p} \dbinom{\lfloor n/p \rfloor}{\lfloor m/p \rfloor} \pmod p$ 。

推论1的证明：

把定理1的 $n,m$ 持续递推，发现每次得到的都是 $p$ 进制下的数位，因此得证。

组合数的求法

加法递推

根据性质5可得加法递推公式 $\dbinom{n}{m} = \dbinom{n-1}{m} + \dbinom{n-1}{m-1}$ ，依次递推可得 $0 \leq m \leq n$ 的所有组合数。

这个递推在模数为素数时，完全可以被公式法替代，其他情况可以考虑使用。

时间复杂度 $O(n^2) \sim O(1)$

空间复杂度 $O(n^2)$

const int P = 1e9 + 7;
const int N = 2e3 + 7;
int comb[N][N];
void get_comb(int n) {
    for (int i = 0;i <= n;i++)
        for (int j = 0;j <= i;j++)
            comb[i][j] = 0 < j && j < i ? (comb[i - 1][j - 1] + comb[i - 1][j]) % P : 1;
}
int C(int n, int m) {
    if (n == m && m == -1) return 1; //* 隔板法特判
    if (n < m || m < 0) return 0;
    return comb[n][m];
}

乘法递推

根据性质3可得乘法递推公式 $\dbinom{n}{m} = \dfrac{n-m+1}{m} \dbinom{n}{m-1}$ ，可以直接求确定 $n$ 的组合数，注意先乘法后除法。

可以利用性质2 $\dbinom{n}{m} = \dbinom{n}{n-m}$ 去掉一半计算量。

当我们无法保存加法递推的所有组合数，但只需要一行组合数时，可以考虑此法。

注意此法不可直接取模，并且取模情况可以由公式法直接替代。

时间复杂度 $O(n) \sim O(1)$

空间复杂度 $O(n)$

const int N = 34;
int comb_n, comb[N];
void get_comb(int n) {
    comb_n = n;
    comb[0] = comb[comb_n] = 1;
    for (int i = 1;2 * i <= comb_n;i++) comb[i] = comb[comb_n - i] = 1LL * (comb_n - i + 1) * comb[i - 1] / i;
}
int Cn(int m) {
    if (comb_n == m && m == -1) return 1; //* 隔板法特判
    if (comb_n < m || m < 0) return 0;
    return comb[m];
}

公式法

公式法是组合数取素数模时最好的解法，其利用逆元处理除法求 $\dbinom{n}{m} = \dfrac{n!}{m!(n-m)!}$ ，可以在线性时间内处理出 $0 \leq m \leq n$ 的所有组合数。

公式法在复杂度上优于加法递推，与乘法递推相同；在使用范围上与加法递推相同，优于乘法递推，可以完全替代前两个方法。

时间复杂度 $O(n) \sim O(1)$

空间复杂度 $O(n)$

const int P = 1e9 + 7;
const int N = 1e7 + 7;
int qpow(int a, ll k) {
    int ans = 1;
    while (k) {
        if (k & 1) ans = 1LL * ans * a % P;
        k >>= 1;
        a = 1LL * a * a % P;
    }
    return ans;
}
int fact[N], invfact[N];
void get_inverse(int n) {
    fact[0] = 1;
    for (int i = 1;i <= n;i++) fact[i] = 1LL * i * fact[i - 1] % P;
    invfact[n] = qpow(fact[n], P - 2);
    for (int i = n;i >= 1;i--) invfact[i - 1] = 1LL * invfact[i] * i % P;
}
int C(int n, int m) {
    if (n == m && m == -1) return 1; //* 隔板法特判
    if (n < m || m < 0) return 0;
    return 1LL * fact[n] * invfact[n - m] % P * invfact[m] % P;
}

卢卡斯定理

在模数为不大的素数，但 $n$ 很大时，可以考虑用卢卡斯定理 $\dbinom{n}{m} \equiv \dbinom{n \bmod p}{m \bmod p} \dbinom{\lfloor n/p \rfloor}{\lfloor m/p \rfloor} \pmod p$ 分解组合数，再利用公式法求解。

时间复杂度 $O(p) \sim O(\log n)$

空间复杂度 $O(p)$

const int P = 1e5 + 3;
const int N = 1e5 + 7;
int qpow(int a, ll k) {
    int ans = 1;
    while (k) {
        if (k & 1) ans = 1LL * ans * a % P;
        k >>= 1;
        a = 1LL * a * a % P;
    }
    return ans;
}
int fact[N], invfact[N];
void get_inverse(int n) {
    fact[0] = 1;
    for (int i = 1;i <= n;i++) fact[i] = 1LL * i * fact[i - 1] % P;
    invfact[n] = qpow(fact[n], P - 2);
    for (int i = n;i >= 1;i--) invfact[i - 1] = 1LL * invfact[i] * i % P;
}
int C(int n, int m) {
    if (n == m && m == -1) return 1; //* 隔板法特判
    if (n < m || m < 0) return 0;
    return 1LL * fact[n] * invfact[n - m] % P * invfact[m] % P;
}
int Lucas(int n, int m) {
    int ans = 1;
    while (n) {
        ans = 1LL * ans * C(n % P, m % P) % P;
        n /= P, m /= P;
    }
    return ans;
}

扩展卢卡斯定理

扩展卢卡斯定理解决了卢卡斯定理无法解决的非素数模数情况，其主要利用了CRT将问题分解，又通过威尔逊定理相关解决了质数幂模数的组合数求模问题。

证明：

我们先将问题分解为多个质数幂的模，因为模数互质，所以最后可以用CRT合并，于是有

$$\left\{ \begin{aligned} \binom{n}{m} &\equiv a_1 \pmod {p_1^{c_1}}\\ \binom{n}{m} &\equiv a_2 \pmod {p_2^{c_2}}\\ &\vdots \\ \binom{n}{m} &\equiv a_k \pmod {p_k^{c_k}}\\ \end{aligned} \right.$$

接下来我们要求出 $k$ 个方程中的 $a_i$ 。

不妨我们考虑其中一个方程 $\dbinom{n}{m} \equiv \dfrac{n!}{m!(n-m)!}\equiv a \pmod {p^c}$ ，我们可以对各个阶乘取模后合并，其中分母取逆元。

注意到阶乘可能含有因子 $p$ ，可能导致结果为 $0$ 或者无法求逆元，但实际上在分式中因子 $p$ 会被消除，因此我们可以考虑先将 $p$ 因子全部提出，再对除去所有 $p$ 因子的阶乘求模，于是有 $\dfrac{\dfrac{n!}{p^{v_p(n!)}}}{\dfrac{m!}{p^{v_p(m!)}} \cdot \dfrac{(n-m)!}{p^{v_p((n-m)!)}}}\cdot p^{v_p(n!)-v_p(m!)-v_p((n-m)!)} \equiv a \pmod{p^c}$ 。

不妨考虑 $\dfrac{n!}{p^{v_p(n!)}}$ 的求法，根据威尔逊定理的推论1有 $\dfrac{n!}{p^{v_p(n!)}} \equiv (\pm 1)^{\lfloor n/p^\alpha \rfloor} \dfrac{\lfloor n/p \rfloor!}{p^{v_p(\lfloor n/p \rfloor!)}} ((n \bmod p^c)!)_p \pmod{p^c}$ ，其中 $\pm 1$ 的判定根据威尔逊定理的定理5即可， $((n \bmod p^c)!)_p$ 可以预处理，于是我们可以递归求解。但这是尾递归，我们可以改为迭代形式。因此，我们将分式三部分的余数求完，对分母取逆元变为乘法， $p^{v_p(n!)-v_p(m!)-v_p((n-m)!)}$ 利用快速幂求解，最后相乘即可求出 $a$ 。

最后，求完 $k$ 个方程的余数后，我们通过CRT合并。

这个过程证明相当复杂，初学者可以学个板子略过了。

时间复杂度 $\displaystyle O\left (\sqrt{P} + \sum_i p_i^{c_i}\right) \sim O \left (\log P + \sum_{i}\log n\right)$

空间复杂度 $O\left (\displaystyle \sum_i p_i^{c_i}\right)$

ll exgcd(ll a, ll b, ll &x, ll &y) {
    if (!b) { x = 1, y = 0; return a; }
    ll d = exgcd(b, a % b, x, y);
    x -= (a / b) * y, swap(x, y);
    return d;
}
ll inv(ll a, ll P) {
    ll x, y;
    exgcd(a, P, x, y);
    return (x % P + P) % P;
}
int qpow(int a, ll k, int P) {
    int ans = 1;
    while (k) {
        if (k & 1) ans = 1LL * ans * a % P;
        k >>= 1;
        a = 1LL * a * a % P;
    }
    return ans;
}
ll CRT(const vector<ll> &a, const vector<ll> &p) {
    int k = a.size() - 1;
    ll P = 1, ans = 0;
    for (int i = 1;i <= k;i++) P *= p[i];
    for (int i = 1;i <= k;i++) {
        ll Pi = P / p[i], invPi = inv(Pi, p[i]);
        (ans += (__int128_t)a[i] * Pi * invPi % P) %= P;
    }
    return ans;
}
int fpr(ll n, int p, int P) {
    vector<int> f(P);
    f[0] = 1;
    for (int i = 1;i < P;i++)
        f[i] = 1LL * f[i - 1] * (i % p ? i : 1) % P;
    int ans = 1;
    while (n) {
        if ((p != 2 || P <= 4) && ((n / P) & 1)) ans = P - ans;
        ans = 1LL * ans * f[n % P] % P;
        n /= p;
    }
    return ans;
}
int Cpr(ll n, ll m, int p, int P) {
    int cnt = 0;
    for (ll i = n;i;i /= p) cnt += i / p;
    for (ll i = m;i;i /= p) cnt -= i / p;
    for (ll i = n - m;i;i /= p) cnt -= i / p;
    return 1LL * qpow(p, cnt, P) * fpr(n, p, P) % P *
        inv(fpr(m, p, P), P) % P * inv(fpr(n - m, p, P), P) % P;
}
int exLucas(ll n, ll m, int P) {
    if (n == m && m == -1) return 1; //* 隔板法特判
    if (n < m || m < 0) return 0;
    vector<ll> a(1), p(1);
    for (int i = 2;i * i <= P;i++) {
        if (!(P % i)) {
            p.push_back(1);
            while (!(P % i)) p.back() *= i, P /= i;
            a.push_back(Cpr(n, m, i, p.back()));
        }
    }
    if (P > 1) p.push_back(P), a.push_back(Cpr(n, m, P, p.back()));
    return CRT(a, p);
}

枚举质因子重数

对于不取模的大组合数，直接使用高精度乘除法的复杂度比较大，因此考虑先求出质因子的幂次，再高精度累乘即可。

注意先预处理 $n$ 以内的质数，复杂度玄学，估计下面这个。

时间复杂度 $O(n) \sim O\left(n\log \dbinom{n}{m} \right)$

空间复杂度 $O\left(n + \log \dbinom{n}{m} \right)$

///继承vector解决位数限制(当前最大位数是9倍整型最大值)，操作方便（注意size()返回无符号长整型，尽量不要直接把size放入表达式）
struct Huge_Int :vector<long long> {
 
    static const int WIDTH = 9;///压位数，压9位以下 比较安全
    static const long long BASE = 1e9;///单位基
    static const long long MAX_INT = ~(1 << 31);///最大整型
    bool SIGN;
 
    ///初始化，同时也可以将低精度转高精度、字符串转高精度
    ///无需单独写高精度数和低精度数的运算函数，十分方便
    Huge_Int(long long n = 0) { *this = n; }
    Huge_Int(const string &str) { *this = str; }
 
    ///格式化，包括进位和去前导0，用的地方很多，先写一个
    Huge_Int &format(int fixlen = 1) {//去0后长度必须大于等于fixlen，给乘法用的
        while (size() > fixlen && !back()) pop_back();//去除最高位可能存在的0
        if (!back()) SIGN = 0;
        for (int i = 1; i < size(); ++i) {
            (*this)[i] += (*this)[i - 1] / BASE;
            (*this)[i - 1] %= BASE;
        }//位内进位
        while (back() >= BASE) {
            push_back(back() / BASE);
            (*this)[size() - 2] %= BASE;
        }//位外进位
        return *this;//为使用方便，将进位后的自身返回引用
    }
 
    ///归零
    void reset() {
        clear();
        SIGN = 0;
    }
 
    ///重载等于，初始化、赋值、输入都用得到
    Huge_Int operator=(long long n) {
        reset();
        SIGN = n < 0;
        if (SIGN) n = -n;
        push_back(n);
        format();
        return *this;
    }
    Huge_Int operator=(const string &str) {
        reset();
        if (str.empty()) push_back(0);
        SIGN = str[0] == '-';
        for (int i = str.length() - 1;i >= 0 + SIGN;i -= WIDTH) {
            long long tmp = 0;
            for (int j = max(i - WIDTH + 1, 0 + SIGN);j <= i;j++)
                tmp = (tmp << 3) + (tmp << 1) + (str[j] ^ 48);
            push_back(tmp);
        }
        format();
        return *this;
    }
 
    ///重载输入输出
    friend istream &operator>>(istream &is, Huge_Int &tmp) {
        string str;
        if (!(is >> str)) return is;
        tmp = str;
        return is;
    }
    friend ostream &operator<<(ostream &os, const Huge_Int &tmp) {
        if (tmp.empty()) os << 0;
        else {
            if (tmp.SIGN) os << '-';
            os << tmp[tmp.size() - 1];
        }
        for (int i = tmp.size() - 2;i >= 0;i--) {
            os << setfill('0') << setw(WIDTH) << tmp[i];
        }
        return os;
    }
 
    ///重载逻辑运算符，只需要小于，其他的直接代入即可
    ///常量引用当参数，避免拷贝更高效
    friend bool operator<(const Huge_Int &a, const Huge_Int &b) {
        if (a.SIGN ^ b.SIGN) return a.SIGN;
        if (a.size() != b.size()) return a.SIGN ? a.size() > b.size() :a.size() < b.size();
        for (int i = a.size() - 1; i >= 0; i--)
            if (a[i] != b[i])return a.SIGN ? a[i] > b[i] : a[i] < b[i];
        return 0;
    }
    friend bool operator>(const Huge_Int &a, const Huge_Int &b) { return b < a; }
    friend bool operator>=(const Huge_Int &a, const Huge_Int &b) { return !(a < b); }
    friend bool operator<=(const Huge_Int &a, const Huge_Int &b) { return !(a > b); }
    friend bool operator!=(const Huge_Int &a, const Huge_Int &b) { return a < b || b < a; }
    friend bool operator==(const Huge_Int &a, const Huge_Int &b) { return !(a != b); }
 
    ///重载负号
    friend Huge_Int operator-(Huge_Int a) { return a.SIGN = !a.SIGN, a; }
 
    ///绝对值函数
    friend Huge_Int abs(Huge_Int a) { return a.SIGN ? (-a) : a; }
 
    ///加法，先实现+=，这样更简洁高效
    friend Huge_Int &operator+=(Huge_Int &a, const Huge_Int &b) {
        if (a.SIGN ^ b.SIGN) return a -= (-b);
        if (a.size() < b.size()) a.resize(b.size());
        for (int i = 0; i < b.size(); i++) a[i] += b[i];//被加数要最大位，并且相加时不要用未定义区间相加
        return a.format();
    }
    friend Huge_Int operator+(Huge_Int a, const Huge_Int &b) { return a += b; }
    friend Huge_Int &operator++(Huge_Int &a) { return a += 1; }
    friend Huge_Int operator++(Huge_Int &a, int) {
        Huge_Int old = a;
        ++a;
        return old;
    }
 
    ///减法，由于后面有交换，故参数不用引用
    friend Huge_Int &operator-=(Huge_Int &a, Huge_Int b) {
        if (a.SIGN ^ b.SIGN) return a += (-b);
        if (abs(a) < abs(b)) {
            Huge_Int t = a;
            a = b;
            b = t;
            a.SIGN = !a.SIGN;
        }
        for (int i = 0; i < b.size(); a[i] -= b[i], i++) {
            if (a[i] < b[i]) {//需要借位
                int j = i + 1;
                while (!a[j]) j++;
                while (j > i) a[j--]--, a[j] += BASE;
            }
        }
        return a.format();
    }
    friend Huge_Int operator-(Huge_Int a, const Huge_Int &b) { return a -= b; }
    friend Huge_Int &operator--(Huge_Int &a) { return a -= 1; }
    friend Huge_Int operator--(Huge_Int &a, int) {
        Huge_Int old = a;
        --a;
        return old;
    }
 
 
    ///乘法，不能先实现*=，因为是类多项式相乘，每位都需要保留，不能覆盖
    friend Huge_Int operator*(const Huge_Int &a, const Huge_Int &b) {
        Huge_Int n;
        n.SIGN = a.SIGN ^ b.SIGN;
        n.assign(a.size() + b.size() - 1, 0);//表示乘积后最少的位数(可能会被format消掉，因此添加了format参数)
        for (int i = 0; i < a.size(); i++) {
            for (int j = 0; j < b.size(); j++)
                n[i + j] += a[i] * b[j];
            n.format(n.size());//提前进位
        }
        return n;//最后进位可能会溢出
    }
    friend Huge_Int &operator*=(Huge_Int &a, const Huge_Int &b) { return a = a * b; }
 
    ///带余除法函数，方便除法和模运算，暂时写不出高效的高精与高精的除法
    friend Huge_Int divmod(Huge_Int &a, const Huge_Int &b) {//O(logn)，待修改
        assert(b != 0);
        Huge_Int n;
        if (-MAX_INT - 1 <= b && b <= MAX_INT) {//除数小于等于整型才能用这个，不然会溢出
            n = a;
            n.SIGN = a.SIGN ^ b.SIGN;
            long long rest = 0;
            long long bl = 0;
            for (int i = b.size() - 1;i >= 0;i--) bl = bl * BASE + b[i];
            for (int i = n.size() - 1;i >= 0;i--) {
                rest *= BASE;
                n[i] += rest;
                rest = n[i] % bl;
                n[i] /= bl;
            }
            a = a.SIGN ? (-rest) : rest;
            return n.format();
        }
        else {//考虑倍增或者二分优化
            n.SIGN = a.SIGN ^ b.SIGN;
            for (int i = a.size() - b.size(); abs(a) >= abs(b); i--) {//减法代替除法
                Huge_Int c, d;
                d.assign(i + 1, 0);
                d.back() = 1;
                d.SIGN = n.SIGN;
                c = b * d;//提高除数位数进行减法
                while (abs(a) >= abs(c)) a -= c, n += d;
                d.pop_back();
                if (!d.empty()) {//遍历压的位
                    d.back() = BASE / 10;
                    for (int i = 1;i < WIDTH;i++) {
                        c = b * d;
                        while (abs(a) >= abs(c)) a -= c, n += d;
                        d.back() /= 10;
                    }
                }
            }
            return n;
        }
    }
    friend Huge_Int operator/(Huge_Int a, const Huge_Int &b) { return divmod(a, b); }
    friend Huge_Int &operator/=(Huge_Int &a, const Huge_Int &b) { return a = a / b; }
    friend Huge_Int &operator%=(Huge_Int &a, const Huge_Int &b) { return divmod(a, b), a; }
    friend Huge_Int operator%(Huge_Int a, const Huge_Int &b) { return a %= b; }
};
 
const int N = 1e6 + 7;
bool vis[N];
vector<int> prime;
void get_prime(int n) {
    for (int i = 2;i <= n;i++) {
        if (!vis[i]) prime.push_back(i);
        for (auto j : prime) {
            if (i * j > n) break;
            vis[i * j] = 1;
            if (!(i % j)) break;
        }
    }
}
int legendre_fact(int n, int p) {
    int cnt = 0;
    while (n) {
        cnt += n / p;
        n /= p;
    }
    return cnt;
}
Huge_Int C(int n, int m) {
    if (n == m && m == -1) return 1; //* 隔板法特判
    if (n < m || m < 0) return 0;
    Huge_Int ans(1);
    for (int i = 0;i < prime.size();i++) {
        int k =
            legendre_fact(n, prime[i]) -
            legendre_fact(m, prime[i]) -
            legendre_fact(n - m, prime[i]);
        int p = prime[i];
        while (k) {
            if (k & 1) ans *= p;
            k >>= 1;
            p *= p;
        }
    }
    return ans;
}

多重集组合

多重集组合的定义与基本性质

定义 设多重集 $S = \{n_1 \cdot a_1,n_2 \cdot a_2,\cdots ,n_k \cdot a_k\}$ ，从中任选 $m$ 个元素组成集合，称为 $S$ 的 $m$ 组合。

性质1 设多重集 $S = \{n_1 \cdot a_1,n_2 \cdot a_2,\cdots ,n_k \cdot a_k\}$ ，若 $m$ 满足 $m \leq n_i \leq +\infty(1\leq i\leq k)$ ，则 $m$ 组合数为 $\dbinom{k+m-1}{m}$ 。

性质1的证明：

可以先将 $m$ 个物品排成一排，然后指定物品的是哪种物品。因为是无序的，我们只需要考虑每种元素有几个即可，因此可以按顺序划分 $k$ 个组别，一个组代表一个种类，同组的元素是同种的。我们用 $k-1$ 个隔板划分 $k$ 个组，如果把隔板也当成一个位置，那么物品和隔板一共 $m+k-1$ 个位置，我们从中选 $m$ 个位置放物品，其他放隔板即可，共 $\dbinom{k+m-1}{m}$ 种方案。这就是隔板法的一种应用。

该问题等价于 $x_1+x_2+\cdots+x_k = n$ 的非负整数解个数，我们有 $k$ 种 $1$ ，第 $i$ 种代表在 $x_i$ 的 $1$ 。每种 $1$ 都是无限的，这对应着 $x_i$ 的范围是 $[0,+\infty)$ 。

计数技巧

计数的方法与原则

方法 将目标方案合理分解为多个简单部分或步骤，利用计数原理合并。

原则 分解的方案应该不重不漏覆盖原方案，即新方案与原方案产生一一映射的关系。

捆绑法

描述 当要求某些元素相邻时，我们可以把它们先看作一个整体与其他元素计数，再对这个整体内部计数，用乘法原理合并。

应用 有 $1,2,3,4,5$ 五个人，其中 $1,2$ 和 $3,4$ 分别相邻，求排列数。我们把 $1,2$ 和 $3,4$ 分别捆绑在一起，先对 $(1,2),(3,4),5$ 排列，共 $\text{P}_3^3$ 种，再分别对两个整体内部排列，分别为 $\text{P}_2^2,\text{P}_2^2$ 种，因此共计 $\text{P}_3^3\text{P}_2^2\text{P}_2^2$ 种排列。

插空法

描述 当要求某些元素两两不相邻时，我们可以先把其他元素放好，再把要求不相邻的元素插入不同的空隙或两端。

应用 有 $1,2,3,4,5,6,7$ 七个人，其中 $1,2,3$ 两两不相邻，求排列数。我们先把 $4,5,6,7$ 先排好，共 $\text{P}_4^4$ 种，再将 $1,2,3$ 插入其中，有 $5$ 个可插入位置，共 $\text{P}_5^3$ 种，因此共计 $\text{P}_4^4 \text{P}_5^3$ 种排列。

隔板法

描述 当需要对相同物品分组时，可以采用隔板法，在物品之间插入隔板表示组与组的分别。

应用 将 $n$ 个球放入 $m$ 个盒子，要求盒子不为空，求方案数。我们可以先给每个盒子一个球保证非空，再对剩下 $n-m$ 个球分成 $m$ 组，即在 $n-m$ 个球之间插入 $m-1$ 个隔板，共 $\dbinom{n-1}{n-m}$ 种方案。