CCF GESP 2025年6月认证 C++ 5级
下面 C++ 代码是用欧几里得算法（辗转相除法）求两个正整数的最大公约数，$a$ 大于 $b$ 还是小于 $b$ 都适用。
int gcd(int a, int b) {
while (b) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}假设函数 gcd() 函数能正确求两个正整数的最大公约数，则下面的 lcm() 函数能求相应两数的最小公倍数。
int lcm(int a, int b) {
return a * b / gcd(a, b);
}下面的 C++ 代码用于输出每个数对应的质因数列表，输出形如：{5: [5], 6: [2, 3], 7: [7], 8: [2, 2, 2]}。
int main() {
int n, m;
cin >> n >> m;
if (n > m) swap(n, m);
map<int, vector<int>> prime_factor;
for (int i = n; i <= m; ++i) {
int j = 2, k = i;
while (k != 1) {
if (k % j == 0) {
prime_factor[i] = prime_factor[i] + j;
k /= j;
} else {
++j;
}
}
}
for (auto& p : prime_factor) {
cout << p.first << ": ";
for (int v : p.second)
cout << v << " ";
cout << endl;
}
return 0;
}下面的 C++ 代码实现归并排序。代码在执行时，将输出一次 HERE 字符串，因为 merge() 函数仅被调用一次。
void merge(std::vector<int>& arr, int left, int mid, int right) {
std::vector<int> temp(right - left + 1);
int i = left;
int j = mid + 1;
int k = 0;
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
while (i <= mid) {
temp[k++] = arr[i++];
}
while (j <= right) {
temp[k++] = arr[j++];
}
for (int p = 0; p < k; ++p) {
arr[left + p] = temp[p];
}
}
void mergeSort(std::vector<int> arr, int left, int right) {
if (left >= right) {
return;
}
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
std::cout << "HERE";
merge(arr, left, mid, right);
}归并排序的最好、最坏和平均时间复杂度均为 $O(n \log n)$。
查字典这个小学生必备技能，可以把字典视为一个已排序的数组。假设小杨要查找一个音首字母为 $g$ 的单词，他首先翻到字典约一半的页数，发现该页的首字母是 $m$，由于字母表中 $g$ 位于 $m$ 之前，所以排除字典后半部分，查找范围缩小到前半部分；不断重复上述步骤，直到找到首字母为 $g$ 的页码。这种查字典的一系列操作可看作二分查找。
求解下图中 A 点到 D 点最短路径，其中 A 到 B 之间的 12 可以理解为距离。求解这样的问题常用 Dijkstra 算法，其思路是通过逐步选择当前距离起点最近的节点来求解非负权重图（如距离不能为负值）单源最短路径的算法。从该算法的描述可以看出，Dijkstra 算法是贪心算法。
分治算法将原问题可以分解成规模更小的子问题，使得求解问题的难度降低。但由于分治算法需要将问题进行分解，并且需要将多个子问题的解合并为原问题的解，所以分治算法的效率通常比直接求解原问题的效率低。
函数 puzzle 定义如下，则调用 puzzle(7) 程序会无限递归。
int puzzle(int n) {
if (n == 1) return 1;
if (n % 2 == 0) return puzzle(n / 2);
return puzzle(3 * n + 1);
}如下为线性筛法，用于高效生成素数表，其核心思想是每个合数只被它的最小质因数筛掉一次，时间复杂度为 $O(n)$。
vector<int> linearSieve(int n) {
vector<bool> is_prime(n + 1, true);
vector<int> primes;
for (int i = 2; i <= n; ++i) {
if (is_prime[i]) {
primes.push_back(i);
}
for (int j = 0; j < primes.size() && i * primes[j] <= n; ++j) {
is_prime[i * primes[j]] = false;
if (i % primes[j] == 0) {
break;
}
}
}
return primes;
}