当前位置：首页 > news >正文

Part05 数学

news 2025/9/17 9:22:38

CSP-J 初赛常考知识点总结 - 数学篇

1.初等数论

1.1 整除、因数、倍数、指数

整除：如果整数 $a$ 除以整数 $b$ ( $\neq 0$ ) 的商是整数且余数为 0，则称 $b$ 整除 $a$ ，记作 $\mid a$
因数与倍数：如果 $\mid a$ ，则 $b$ 是 $a$ 的因数， $a$ 是 $b$ 的倍数
指数：表示相同因数连乘的运算，如 $an=a×a×⋯×aa^n = a \times a \times \cdots \times a$ （n 个 a 相乘）

1.2 取整运算

向下取整（地板函数）： $⌊x⌋\lfloor x \rfloor$ 表示不超过 $x$ 的最大整数
向上取整（天花板函数）： $⌈x⌉\lceil x \rceil$ 表示不小于 $x$ 的最小整数
四舍五入：round(x) 表示最接近 $x$ 的整数

// C++ 中的取整函数
#include <cmath>
double x = 3.7;
floor(x);   // 3.0
ceil(x);    // 4.0
round(x);   // 4.0

1.3 模运算与同余

模运算： $\bmod m$ 表示 $a$ 除以 $m$ 的余数，满足 $\leq a \bmod m < m$
同余：如果 $\bmod m = b \bmod m$ ，则称 $a$ 与 $b$ 模 $m$ 同余，记作 $\pmod{m}$
模运算性质：
- $\bmod m = (a \bmod m + b \bmod m) \bmod m$
- $\bmod m = (a \bmod m - b \bmod m + m) \bmod m$
- $\bmod m = (a \bmod m × b \bmod m) \bmod m$

1.4 整数唯一分解定理

定理内容：任何大于 1 的整数都可以唯一地分解为质因数的幂的乘积形式：
$p_1^{a_1} × p_2^{a_2} × \cdots × p_k^{a_k}$
其中 $p1,p2,…,pkp_1, p_2, \ldots, p_k$ 是质数， $a1,a2,…,aka_1, a_2, \ldots, a_k$ 是正整数。

// 质因数分解
vector<pair<int, int>> primeFactorization(int n) {vector<pair<int, int>> factors;for (int i = 2; i * i <= n; i++) {if (n % i == 0) {int count = 0;while (n % i == 0) {count++;n /= i;}factors.push_back({i, count});}}if (n > 1) {factors.push_back({n, 1});}return factors;
}

1.5 最大公约数与最小公倍数

基本概念

最大公约数 (GCD)：两个或多个整数的最大公有因数
最小公倍数 (LCM)：两个或多个整数的最小公有倍数

计算方法

短除法

适用于较小数字，计算过程：
$\begin{array}{c|ccc} 2 & 6 & 15 & 20 \\ 3 & 3 & 15 & 10 \\ 5 & 1 & 5 & 10 \\ 2 & 1 & 1 & 2 \\ \end{array}$

最大公约数： $2$ （左侧能被所有数整除的数的乘积）
最小公倍数： $\times 3 \times 5 \times 2 \times 1 \times 1 \times 2 = 120$

1.6 辗转相除法（欧几里得算法）

适用于较大数字，递归公式：
$\gcd(a,b) = \begin{cases} a & \text{if } b = 0 \\ \gcd(b, a \bmod b) & \text{otherwise} \end{cases}$

示例：求 $gcd⁡(437,323)\gcd(437, 323)$
$\begin{align*} 437 \div 323 &= 1 \text{ 余 } 114 \\ 323 \div 114 &= 2 \text{ 余 } 95 \\ 114 \div 95 &= 1 \text{ 余 } 19 \\ 95 \div 19 &= 5 \text{ 余 } 0 \\ \end{align*}$
∴ $gcd⁡(437,323)=19\gcd(437, 323) = 19$

C++ 模板代码

// 递归实现
int gcd(int a, int b) {return b == 0 ? a : gcd(b, a % b);
}// 迭代实现
int gcd(int a, int b) {while (b != 0) {int temp = b;b = a % b;a = temp;}return a;
}// 最小公倍数
int lcm(int a, int b) {return a / gcd(a, b) * b;  // 先除后乘避免溢出
}

关系公式

对于两个数 $a$ 和 $b$ ：
$\text{lcm}(a,b) = \frac{|a \times b|}{\gcd(a,b)}$

1.7 质数筛法

埃拉托斯特尼筛法（埃氏筛）

原理：从2开始，将每个质数的倍数都标记为合数
时间复杂度： $\log \log n)$
空间复杂度： $O (n)$

// vis[i] 标记合数，p[i] 质数列表
void sieve(int n) {vis[0] = vis[1] = true;for (int i = 2; i * i <= n; i++)if (vis[i])for (int j = i * i; j <= n; j += i)vis[j] = true;for(int i=1;i<=n;i++)if(!vis[i])p[++tot] = i;
}

欧拉筛（线性筛）

原理：每个合数只被它的最小质因子筛掉一次
时间复杂度： $O (n)$
空间复杂度： $O (n)$

void eulerSieve(int n) {for (int i = 1; i <= n; i++) {if (!vis[i])p[++tot] = i;for (int j = 1; j <= tot && p[j] * i <= n; j++) {vis[p[j] * i] = true;if (i % p[j] == 0)break;}}
}

2.离散与组合数学

2.1 集合

集合：具有某种特定性质的事物的总体
子集：如果集合 A 的所有元素都属于集合 B，则称 A 是 B 的子集，记作 $A \subseteq B$
交集： $\{x \mid x ∈ A \text{ 且 } x ∈ B\}$
并集： $\{x \mid x ∈ A \text{ 或 } x ∈ B\}$
补集： $x∉A}\complement_UA = \{x \mid x ∈ U \text{ 且 } x ∉ A\}$

2.2 排列组合

基本原理

加法原理：完成工作有 $n$ 类方法，第 $i$ 类有 $a_i$ 种方式，总方法数：
$a_1 + a_2 + \cdots + a_n$
乘法原理：完成工作有 $n$ 个步骤，第 $i$ 步有 $a_i$ 种方式，总方法数：
$a_1 \times a_2 \times \cdots \times a_n$

排列 (Arrangement/Permutation)

从 $n$ 个不同元素中取 $m$ 个按顺序排列：
$A_n^m = n(n-1)(n-2)\cdots(n-m+1) = \frac{n!}{(n-m)!}$
全排列： $Ann=n!=1×2×3×⋯×nA_n^n = n! = 1 \times 2 \times 3 \times \cdots \times n$

2.3 组合 (Combination)

从 $n$ 个不同元素中取 $m$ 个不考虑顺序：
$C_n^m = \frac{A_n^m}{m!} = \frac{n!}{m!(n-m)!}$

组合恒等式

$C_n^m = C_n^{n-m}$

解题技巧

1. 先选后排

先将元素选出，再进行排列

2. 特殊优先

特殊元素或位置优先处理

3. 分排用直排

多排问题可视为单排处理

4. 分类法

直接计算符合条件的数目

5. 排除法（正难则反）

计算不符合条件的数目，再从总数中减去

6. 捆绑法

$m$ 个必须相邻的元素捆绑处理：
$A_{n-m+1}^{n-m+1} \times A_m^m$

7. 插空法

$m$ 个不能相邻的元素先排其他元素再插空：
$A_{n-m}^{n-m} \times A_{n-m+1}^m$

8. 隔板法

将 $n$ 个相同元素分成 $m$ 组，每组至少一个：
$S = C_{n-1}^{m-1}$

9. 定序问题

$n$ 个元素中有 $m$ 个必须按特定顺序排列：
$\frac{A_n^n}{A_m^m}$

2.4 杨辉三角（帕斯卡三角形）

杨辉三角是二项式系数在三角形中的一种几何排列，具有以下性质：

第 $n$ 行第 $k$ 个数等于 $C_{n-1}^{k-1}$
每个数等于它上方两数之和
第 $n$ 行的数字和为 $2^{n-1}$

行号: 二项式系数
1:     1
2:    1 1
3:   1 2 1
4:  1 3 3 1
5: 1 4 6 4 1

// 生成杨辉三角的前 n 行，使用二维数组存储
int generatePascalTriangle(int n) {for (int i = 0; i < n; i++) {triangle[i][0] = 1; // 每行第一个元素为1triangle[i][i] = 1; // 每行最后一个元素为1// 计算中间元素for (int j = 1; j < i; j++)triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j];}
}

3. 其他

3.1 进制转换

进制表示法

16进制：H (Hexadecimal)
10进制：D (Decimal)
8进制：O (Octonary)
2进制：B (Binary)

转换方法

$n$ 进制转十进制

公式：
$x_{(10)} = \sum_{i=0}^{k-1} a_i \times n^i$
其中 $a_i$ 是第 $i$ 位上的数字。

示例：

$10010110_{(2)} = 1×2^7 + 0×2^6 + 0×2^5 + 1×2^4 + 0×2^3 + 1×2^2 + 1×2^1 + 0×2^0 = 150_{(10)}$
$KaTeX parse error: Expected '}', got 'EOF' at end of input: …= 0.3125_{(10)}$

十进制转 $n$ 进制

整数部分：除 $n$ 取余，逆序排列
小数部分：乘 $n$ 取整，顺序排列

示例： $13_{(10)} = 1101_{(2)}$
$\begin{align*} 13 \div 2 &= 6 \text{ 余 } 1 \\ 6 \div 2 &= 3 \text{ 余 } 0 \\ 3 \div 2 &= 1 \text{ 余 } 1 \\ 1 \div 2 &= 0 \text{ 余 } 1 \\ \end{align*}$

C++ 模板代码

// n进制转十进制
int nToDecimal(string num, int base) {int result = 0;for (char c : num) {int digit = (c >= '0' && c <= '9') ? c - '0' : c - 'A' + 10;result = result * base + digit;}return result;
}// 十进制转n进制
string decimalToN(int num, int base) {if (num == 0) return "0";string result;while (num > 0) {int remainder = num % base;char digit = (remainder < 10) ? '0' + remainder : 'A' + remainder - 10;result = digit + result;num /= base;}return result;
}

$n$ 进制转 $m$ 进制

以十进制为中介：
$n\text{-进制} \rightarrow \text{十进制} \rightarrow m\text{-进制}$

3.2 ASCII 码

基本概念

ASCII（American Standard Code for Information Interchange）：美国信息交换标准代码
使用7位二进制数（共128个字符）表示所有英文字母、数字和常用符号
标准ASCII码范围：0～127（十六进制：00～7F）

ASCII 码表分类

范围（十进制）	类别	说明
0～31, 127	控制字符	通信专用字符，如换行(10)、回车(13)
32	空格字符	空格(32)
33～47, 58～64, 91～96, 123～126	特殊符号	标点符号和运算符
48～57	数字	0-9，按顺序排列
65～90	大写字母	A-Z，按字母表顺序
97～122	小写字母	a-z，按字母表顺序

重要ASCII码值

‘0’ = 48
‘A’ = 65
‘a’ = 97
空格 = 32
换行符 = 10
回车符 = 13

应用示例

// C++中字符与ASCII码的转换
char c = 'A';
int ascii = (int)c;      // 65
char fromAscii = (char)65; // 'A'// 大小写转换（利用ASCII码差值为32）
char lower = 'A' + 32;   // 'a'
char upper = 'a' - 32;   // 'A'

3.3 格雷码（Gray Code）

基本概念

格雷码：一种循环二进制编码，相邻两个编码只有一位不同
优点：减少数字变化时产生的错误，常用于模拟数字转换、旋转编码器等

生成规则

1位格雷码：0, 1
n位格雷码 = (n-1)位格雷码顺序排列 + (n-1)位格雷码逆序排列，并在前面分别加0和1

格雷码与二进制转换

二进制转格雷码

$G_i = \begin{cases} B_i & i = n-1 \\ B_i \oplus B_{i+1} & i < n-1 \end{cases}$

其中 $B_i$ 是二进制数的第i位， $G_i$ 是格雷码的第i位， $⊕\oplus$ 表示异或运算

格雷码转二进制

$B_i = \begin{cases} G_i & i = n-1 \\ G_i \oplus B_{i+1} & i < n-1 \end{cases}$

C++ 实现代码

// 二进制转格雷码
int binaryToGray(int num) {return num ^ (num >> 1);
}// 格雷码转二进制
int grayToBinary(int gray) {int binary = gray;while (gray >>= 1) {binary ^= gray;}return binary;
}// 生成n位格雷码序列
vector<int> generateGrayCode(int n) {vector<int> grayCodes;int size = 1 << n; // 2^nfor (int i = 0; i < size; i++) {grayCodes.push_back(i ^ (i >> 1));}return grayCodes;
}