第二十四届全国青少年信息学奥林匹克联赛初赛 普及组 C++语言试题
作者：野牛程序员：2023-04-04 15:09:21题目阅读 2651
第二十四届全国青少年信息学奥林匹克联赛初赛 普及组 C++语言试题
竞赛时间：2018 年 10 月 13 日 14:30~16:30
选手注意：
试题纸共有 7 页，答题纸共有 2 页，满分 100 分。请在答题纸上作答，写在 试题纸上的一律无效。
不得使用任何电子设备（如计算器、手机、电子词典等）或查阅任何书籍资料。
一、单项选择题（共 15 题，每题 2 分，共计 30 分；每题有且仅有一个正确选项）
以下哪一种设备属于输出设备：（ ）
A. 扫描仪 B. 键盘 C. 鼠标 D. 打印机
2. 下列四个不同进制的数中，与其它三项数值上不相等的是（ ）。
A. (269)16
B. (617)10
C. (1151)8
D. (1001101011)2
这道题目是一道进制转换的综合应用题。我们先来简单解释一下题目中出现的四种进制： (269)16：这是十六进制，也就是我们平时说的“16进制”，其中包括0-9和A-F共16个数字，其实际数值为2×16^2+6×16^1+9×16^0=617。 (617)10：这是十进制，也就是我们平时说的“10进制”，其中包括0-9共10个数字，数值就是它本身。 (1151)8：这是八进制，也就是我们平时说的“8进制”，其中包括0-7共8个数字，其实际数值为1×8^3+1×8^2+5×8^1+1×8^0=617。 (1001101011)2：这是二进制，也就是我们平时说的“2进制”，其中只包括0和1两个数字，其实际数值为1×2^9+0×2^8+0×2^7+1×2^6+1×2^5+0×2^4+1×2^3+0×2^2+1×2^1+1×2^0=619。 那么根据题目要求，我们需要找出其中与其他三项数值上不相等的数。这需要我们进行一些简单的比较和计算。 首先，我们可以发现选项 B 是十进制，而其他三个选项都不是，所以选项 B 可以被排除。 接下来，我们将选项 A、C、D 转化成同一进制（十进制）进行比较： (269)16 = 617 (1151)8 = 617 (1001101011)2 = 619 我们可以看到，选项 A 和选项 C 的十进制值都是 617 和 617，而选项 D 的十进制值是 619，与其他两项不同。因此，答案是选项 D。 总结一下技巧： 掌握不同进制的数值表示方法。 熟练掌握进制之间的转换方法。 进行比较时，将所有数值转换为同一进制进行比较。
3. 1MB 等于（ ）。
A. 1000 字节
B. 1024 字节
C. 1000 X 1000 字节
D. 1024 X 1024 字节
什么是MB。MB是计算机中存储容量的单位，它表示的是一段数据所占用的空间大小。 那么，1MB到底等于多少呢？ 什么是MB。MB是计算机中存储容量的单位，它表示的是一段数据所占用的空间大小。那么，1MB到底等于多少呢？ 选项A、C都是以1000为基数进行计算，但在计算机中，存储容量的计算是以2的次方为基数的。因此，选项B、D是正确答案。1MB等于1024字节或1024乘1024字节，这取决于你是在处理文件还是在处理存储器容量。 那么，如何记忆这个技巧呢？我们可以使用一个简单的助记法：1024是2的10次方，而计算机中的存储容量是以2为基数进行计算的。因此，我们可以将1024视为计算机存储容量中的“特殊数字”，并记住1MB等于1024字节或1024乘1024字节。 当我们在处理计算机中的存储器容量时，通常使用的是二进制单位，如字节（Byte）、千字节（Kilobyte，简称KB）、兆字节（Megabyte，简称MB）、吉字节（Gigabyte，简称GB）、太字节（Terabyte，简称TB）等。而这些二进制单位都是以2的幂为基数的，如1KB等于2的10次方字节（即1024字节），1MB等于2的20次方字节（即1024乘1024字节），以此类推。 当我们在处理文件时，通常使用的是十进制单位，如千字节（KB）、兆字节（MB）、吉字节（GB）、太字节（TB）等。这些十进制单位是以1000为基数的，如1KB等于1000字节，1MB等于1000乘1000字节，以此类推。 需要注意的是，不同的应用程序可能会使用不同的单位来表示存储容量，因此在实际应用中，我们需要根据具体的情况来选择使用哪种单位。同时，我们还需要了解计算机中的存储容量是以二进制为基数进行计算的这一基本知识，以便更好地理解和处理存储容量的相关问题。
4. 广域网的英文缩写是（ ）。
A. LAN
B. WAN
C. MAN
D. LNA
广域网的英文缩写是 WAN，WAN 表示 Wide Area Network。一个计算机网络通常由许多计算机连接在一起，这些计算机可以是在同一个房间，也可以是在不同的城市或国家。当它们连接在一起并共享信息时，我们称之为计算机网络。LAN 表示 Local Area Network，表示连接在同一地区的计算机网络。MAN 表示 Metropolitan Area Network，表示连接在同一城市的计算机网络。LNA 不是计算机网络的缩写。 因此，正确答案是 B. WAN。记住，当你需要连接不同城市或国家的计算机时，你需要使用 WAN。希望这个解释对你有帮助！
5. 中国计算机学会于（ ）年创办全国青少年计算机程序设计竞赛。
A. 1983
B. 1984
C. 1985
D. 1986
这道题目问的是中国计算机学会什么时候创办了全国青少年计算机程序设计竞赛。 正确答案是 B. 1984年。 这个题目主要考察了解历史的能力。下面是解题技巧： 首先，我们要知道什么是中国计算机学会。中国计算机学会是中国最大的计算机学术团体，成立于1978年。它的宗旨是推动中国计算机事业的发展，促进计算机学术交流和国际合作。 其次，我们需要知道什么是全国青少年计算机程序设计竞赛。这是一项由中国计算机学会主办的竞赛，旨在促进青少年对计算机科学的兴趣和学习，同时发掘和培养优秀的计算机人才。 最后，我们需要知道这个竞赛是在哪一年创办的。根据题目，中国计算机学会创办全国青少年计算机程序设计竞赛的时间是在1984年。因此，答案是B选项，1984年。
6. 如果开始时计算机处于小写输入状态，现在有一只小老鼠反复按照CapsLock、 字母键 A、字母键 S、字母键 D、字母键 F 的顺序循环按键，即 CapsLock、A、S、D、F、CapsLock、A、S、D、F、……，屏幕上输出的第 81 个字符是字母 （ ）。
A. A
B. S
C. D
D. a
数学里面的知识 ：分组，4个字母一组，81除以4=20余1，所以最后一个字母就是新的一组的开头第一个a ，组的字母大小写规律：大、小、大、小......,奇数为大写，偶数为小写，最后一组是奇数所以是大写字母。
7. 根节点深度为 0，一棵深度为 h 的满 k（k>1）叉树，即除最后一层无任何子 节点外，每一层上的所有结点都有 k 个子结点的树，共有（ ）个结点。
A. (k^h+1 - 1) / (k - 1)
B. k ^h-1
C. k^ h
D. (k ^h-1 ) / (k - 1)
根据题目，我们有一棵深度为h的满k叉树，每一层上的所有结点都有k个子结点，除最后一层无子节点外。我们需要计算该树的节点数。 对于满k叉树来说，它的每一层上的节点数都是k的幂次方。因此，我们可以计算每一层上的节点数，并将它们相加以得到总节点数。首先，根节点的深度为0，因此第0层节点数为1（即根节点）。第1层节点数为k^1，第2层节点数为k^2，以此类推，直到第h-1层节点数为k^(h-1)。最后一层没有子节点，因此它没有任何节点。 因此，满k叉树的节点数为： 1 + k^1 + k^2 + ... + k^(h-1) 我们可以使用等比数列的求和公式来计算这个总和。这个公式是： a(1 - r^n) / (1 - r) 其中，a是等比数列的首项，r是公比，n是项数。 在这种情况下，a=1，r=k，n=h，因为我们有h个项。因此，将这些值代入公式，我们得到： 1 + k^1 + k^2 + ... + k^(h-1) = (k^(h+1) - 1) / (k - 1) 首先，让我们定义一下什么是满k叉树。满k叉树是指每个节点都恰好有k个子节点的树。对于满k叉树，我们可以很容易地计算它的节点数。 对于深度为h的满k叉树，最后一层上的所有节点都是叶子节点。由于这是一棵满k叉树，因此最后一层上有k^h个叶子节点。因为这是最后一层，所以深度为h-1的层上的所有节点都是这些叶子节点的父节点。这个层上的节点数为k^(h-1)。因为这是深度为h-1的层，所以深度为h-2的层上的所有节点都是这些父节点的父节点，该层上的节点数为k^(h-2)。我们可以一直重复这个过程，直到深度为0，即根节点。 因此，根据上述推理，我们可以得出每个深度上的节点数，并将它们相加以得到总节点数。使用等比数列求和公式，我们可以将它们合并为一个简单的公式。公式如下： 1 + k^1 + k^2 + ... + k^(h-1) = (k^(h+1) - 1) / (k - 1) 这个公式给出了深度为h的满k叉树的总节点数，其中k是每个节点的子节点数，h是树的深度。 让我通过一个示意图来演示一下深度为3，子节点数为3的满叉树。 O <-- 第0层，深度为0，只有根节点 / | \\ O O O <-- 第1层，深度为1，有3个子节点 /|\\ | /|\\ O O O O O O <-- 第2层，深度为2，有9个子节点 /|\\|\\/|\\|\\/|\\ O O O O O O O O <-- 第3层，深度为3，有27个子节点，所有节点都是叶子节点 在上面的示意图中，我们可以看到深度为3，子节点数为3的满叉树。根据上述推理，我们可以计算出每个深度上的节点数。对于这个树来说，每层的节点数分别为： 第0层：1个节点 第1层：3个节点 第2层：9个节点 第3层：27个节点 总节点数等于所有节点数的和，即： 1 + 3 + 9 + 27 = 40 使用等比数列求和公式，我们可以将这个总和计算为： (k^(h+1) - 1) / (k - 1) = (3^(3+1) - 1) / (3 - 1) = 80 / 2 = 40 因此，我们可以验证这个满叉树的总节点数为40个。
8. 以下排序算法中，不需要进行关键字比较操作的算法是（ ）。
A. 基数排序
B. 冒泡排序
C. 堆排序
D. 直接插入排序
排序算法是计算机程序中非常常见的一种算法，它可以将一组数据按照一定的顺序进行排列。在排序过程中，通常需要比较不同数据之间的大小关系，以便确定它们在最终排序结果中的位置。 然而，有些排序算法可以在不进行关键字比较的情况下完成排序。关键字是指用于排序的数据元素的某个属性，例如数字大小或字母序列。这些算法利用了数据元素之间的其他性质，而不是比较它们的关键字来进行排序。 现在，让我们回到题目，根据上述解释，我们需要在给定的四个排序算法中找到一个不需要进行关键字比较操作的算法。 冒泡排序：它比较相邻的两个元素，并根据它们的大小关系交换它们的位置，以便将较大的元素“浮”到数组的末尾。这个过程需要进行关键字比较。 直接插入排序：它将数组中的每个元素插入到已排序的子数组中，使得插入后的子数组仍然有序。这个过程需要进行关键字比较。 堆排序：它使用一种数据结构叫做堆来进行排序。堆是一个可以快速查找最大元素的数据结构。堆排序需要进行关键字比较。 基数排序：它将元素按照不同的位数进行排序，从最低位到最高位。在每个位数上，元素的相对顺序都是不变的，因此不需要进行关键字比较。 因此，答案是：A. 基数排序，不需要进行关键字比较操作。 总结技巧：当我们在寻找一个不需要进行关键字比较操作的排序算法时，可以寻找那些利用数据元素之间的其他性质进行排序的算法，例如基数排序。 基数排序是一种非比较性质的排序算法，它将待排序的元素分配到各个“桶”中，再按照每个桶中元素的顺序依次取出来，从而实现排序的过程。这个算法的核心思想是：先按照元素的个位数字进行排序，然后按照十位、百位、千位等高位数字进行排序，最终就能够得到一个有序的序列。 下面是基数排序的详细步骤： 找出待排序数组中最大的数字，并确定它的位数，即最高位数。 对每一位上的数字进行排序。从最低位开始，对于每一个位上的数字，将待排序数组中的元素分配到对应的桶中。例如，对于个位数字为1的元素，将其放入编号为1的桶中。然后，按照桶的顺序，将所有桶中的元素依次取出来，放回到待排序数组中。这样就完成了对个位数字的排序。 重复步骤2，对十位、百位、千位等高位数字进行排序。每一轮排序完成后，将所有元素放回到待排序数组中。 最终，待排序数组就变成了一个有序的序列。 下面是使用C++语言实现基数排序的示例代码：
#include <iostream>
#include <vector>
using namespace std;
// 获取一个数字的第pos位上的数字
int getDigit(int num, int pos) {
int div = 1;
for (int i = 0; i < pos - 1; i++) {
div *= 10;
}
return (num / div) % 10;
}
void radixSort(vector<int>& arr) {
// 获取待排序数组中的最大值
int maxVal = arr[0];
for (int i = 1; i < arr.size(); i++) {
if (arr[i] > maxVal) {
maxVal = arr[i];
}
}
// 计算最大值的位数
int maxDigits = 0;
while (maxVal != 0) {
maxVal /= 10;
maxDigits++;
}
// 对每一位进行排序
for (int pos = 1; pos <= maxDigits; pos++) {
// 初始化桶
vector<vector<int>> buckets(10);
// 将元素分配到桶中
for (int i = 0; i < arr.size(); i++) {
int digit = getDigit(arr[i], pos);
buckets[digit].push_back(arr[i]);
}
// 将桶中的元素放回到数组中
int idx = 0;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < buckets[i].size(); j++) {
arr[idx++] = buckets[i][j];
}
}
}
}
int main() {
vector<int> arr = {23, 67, 3,6, 34, 56, 89, 44, 12, 78};
cout << "排序前的数组：";
for (int i = 0; i < arr.size(); i++) {
cout << arr[i] << " ";
}
cout << endl;
radixSort(arr);
cout << "排序后的数组：";
for (int i = 0; i < arr.size(); i++) {
cout << arr[i] << " ";
}
cout << endl;
return 0;
}输出结果： 排序前的数组：23 67 3 6 34 56 89 44 12 78 排序后的数组：3 6 12 23 34 44 56 67 78 89 在这个示例代码中，我们首先实现了一个`getDigit`函数，用于获取一个数字的第pos位上的数字。然后，我们实现了`radixSort`函数，其中对每一位上的数字进行排序，并将排序后的元素放回到原数组中。最终，我们在`main`函数中调用`radixSort`函数，对一个包含10个元素的数组进行排序，并输出排序前后的结果。 需要注意的是，基数排序的时间复杂度为O(d*(n+k))，其中d是数字的最高位数，n是待排序数组的长度，k是桶的个数。虽然基数排序的时间复杂度较低，但是由于它需要使用较多的空间来存储桶，所以在实际应用中可能会存在一定的局限性。
9. 给定一个含 N 个不相同数字的数组，在最坏情况下，找出其中最大或最小的 数，至少需要 N - 1 次比较操作。则最坏情况下，在该数组中同时找最大与 最小的数至少需要（ ）次比较操作。（⌈ ⌉表示向上取整，⌊ ⌋表示向下取整）
A. ⌈3N / 2⌉ - 2
B. ⌊3N / 2⌋ - 2
C. 2N - 2
D. 2N - 4
10. 下面的故事与（ ）算法有着异曲同工之妙。 从前有座山，山里有座庙，庙里有个老和尚在给小和尚讲故事：“从前有座 山，山里有座庙，庙里有个老和尚在给小和尚讲故事：‘从前有座山，山里 有座庙，庙里有个老和尚给小和尚讲故事……’”
A. 枚举
B. 递归
C. 贪心
D. 分治
11. 由四个没有区别的点构成的简单无向连通图的个数是（ ）。
A. 6
B. 7
C. 8
D. 9
计算简单无向连通图的个数是一个比较复杂的组合问题，没有简单的公式可以直接求解，需要进行分类讨论。不过，对于节点数比较小的情况，可以手动列举所有可能的图形，然后计算其数量。 对于四个节点的情况，我们可以按照度数分类讨论。因为每个节点的度数都不超过 2，所以可能出现的度数组合只有以下三种： 2, 2, 2, 2：此时只有一种情况，即一个正方形。 1, 1, 2, 2：此时有两种情况，即一个 V 形或一个 L 形。 1, 2, 2, 2：此时有三种情况，即一个 Y 形或一个 T 形或一个十字形。 因此，总共有 1 + 2 + 3 = 6 种不同的简单无向连通图。 需要注意的是，对于节点数更多的情况，手动列举所有可能的图形会变得十分困难。此时可以使用计算机算法来求解。
12. 设含有 10 个元素的集合的全部子集数为 S，其中由 7 个元素组成的子集数为 T，则 T / S 的值为（ ）。 A. 5 / 32
B. 15 / 128
C. 1 / 8
D. 21 / 128
子集数量：对于一个含有 n 个元素的集合，它的子集数量是 2^n，其中包括空集和该集合本身。 子集的排列组合：对于一个含有 n 个元素的集合，其中选择 r 个元素组成的子集的数量为 C(n,r)，表示为 n choose r，可以用下面的公式计算：C(n,r) = n!/[(n-r)!r!]。其中，n! 表示 n 的阶乘，即 n × (n-1) × ... × 2 × 1。
13. 10000 以内，与 10000 互质的正整数有（ ）个。
A. 2000
B. 4000
C. 6000
D. 8000
14. 为了统计一个非负整数的二进制形式中 1 的个数，代码如下：
int CountBit(int x)
{
int ret = 0;
while (x)
{
ret++;
___________;
}
return ret;
}
则空格内要填入的语句是（ ）。
A. x >>= 1
B. x &= x - 1
C. x |= x >> 1
D. x <<= 1
当我们要统计一个非负整数的二进制形式中 1 的个数时，可以使用“位运算”的方法，这种方法的原理是通过一些特殊的位运算操作来快速计算一个数字的二进制形式中 1 的个数。
以下是一种比较常见的位运算方法：
定义一个变量 ret，初始值为 0，用于记录二进制形式中 1 的个数。
对于给定的数字 x，我们不断地把它的最低位上的数字与 1 进行比较，如果是 1，就把 ret 加一。
然后，将 x 右移一位，即将 x 的二进制表示形式向右移动一位，去掉最低位的数字。
重复步骤 2 和步骤 3，直到 x 变成 0 为止。
在第二步中，我们如何判断 x 的最低位上的数字是否为 1 呢？这里我们可以使用按位与运算（&），按位与运算的规则是：只有两个相应的二进制位都为 1 时，结果才为 1，否则为 0。因此，如果我们将 x 和 1 进行按位与运算，得到的结果就是 x 的最低位上的数字。例如，对于数字 5（二进制形式为 101），我们将它和 1 进行按位与运算，得到的结果为 1，说明它的最低位上的数字是 1。
但是，使用上述方法进行循环的次数等于数字二进制形式中 1 的个数，效率并不是很高。因此，我们可以采用另外一种更快的方法，即“Brian Kernighan 算法”，该算法的基本思路是利用按位与运算的性质，每次去掉 x 的二进制形式中最低位上的 1，直到 x 变成 0。
具体实现方法如下：
定义一个变量 ret，初始值为 0，用于记录二进制形式中 1 的个数。
对于给定的数字 x，不断执行以下操作，直到 x 变成 0 为止：
a. 将 x 与 x-1 进行按位与运算，并将结果赋值给 x。这个操作会将 x 的二进制形式中最低位上的 1 变成 0。
b. ret 加 1。
返回 ret，即为数字 x 的二进制形式中 1 的个数。
在这个过程中，每次执行操作 a，都会去掉 x 的二进制形式中最低位上的 1。
因此，对于任意一个非负整数 x，循环的次数等于它的二进制形式中 1 的个数，
而且由于每次操作都会去掉一个 1，因此时间复杂度为 O(k)，其中 k 是 x 的二进制形式中 1 的个数。
与普通的循环方法相比，Brian Kernighan 算法在计算二进制形式中 1 的个数时具有更高的效率。
这是因为在二进制表示中，每个数字都可以表示为若干个 2 的幂次之和，例如 9（二进制表示为 1001）
可以表示为 2³ + 2⁰，而 10（二进制表示为 1010）可以表示为 2³ + 2¹。在 Brian Kernighan 算法中，
每次操作都会去掉二进制形式中最低位上的 1，因此每个数字只会被处理一次，因此时间复杂度为 O(k)，
其中 k 是 x 的二进制形式中 1 的个数。
int CountBit(int x)
{
int ret = 0;
while (x)
{
x = x & (x - 1);
ret++;
}
return ret;
}
其中，x & (x - 1) 表示将 x 的二进制形式中最低位上的 1 变成 0，这个操作会去掉 x 的
二进制形式中最低位上的 1。
Brian Kernighan 算法是一种用于统计一个二进制数中 1 的个数的算法，它被命名为 Brian Kernighan，是因为这个算法是由
Brian Kernighan 在他的《C Programming Language》一书中首次介绍的。
该算法的思想是利用位运算，通过不断将数字中最低位的 1 变成 0 的方式来统计二进制数中 1 的个数。具体来说，算法的步骤如下：
定义一个计数器 ret，初始值为 0。
循环直到数字 x 变成 0：每次循环中，将 x 与 x - 1 做与运算，然后将结果赋值给 x。也就是说，x = x & (x - 1)。
在每次循环中，将计数器 ret 加 1。
循环结束后，返回计数器 ret 的值，即为二进制数中 1 的个数。
算法的正确性可以通过以下思路来解释：当一个二进制数减去 1 时，它的最低位的 1 变成了 0，而该位之后的所有 0 变成了 1。因此，如果我们将一个二进制数与它减去 1 的结果做与运算，那么该数最低位的 1 就会变成 0。因此，每次将 x 与 x - 1 做与运算，都会将 x 的二进制形式中最低位的 1 变成 0，这样就能够不断去掉 x 的二进制形式中的 1，并在每次操作中将计数器加 1，从而统计出二进制数中 1 的个数。
Brian Kernighan 算法的时间复杂度与二进制数中 1 的个数相关，具体来说，时间复杂度为 O(k)，其中 k 是二进制数中 1 的个数。这比暴力枚举二进制数中的每一位并统计 1 的个数更加高效。15. 下图中所使用的数据结构是（ ）。
二、问题求解（共 2 题，每题 5 分，共计 10 分）
甲乙丙丁四人在考虑周末要不要外出郊游。
已知①如果周末下雨，并且乙不去，则甲一定不去；②如果乙去，则丁一定 去；③如果丙去，则丁一定不去；④如果丁不去，而且甲不去，则丙一定不 去。如果周末丙去了，则甲________（去了/没去）(1 分)，乙________（去 了/没去）(1 分)，丁________（去了/没去）(1 分)，周末________（下雨/ 没下雨）(2 分)。
2. 从 1 到 2018 这 2018 个数中，共有__________个包含数字 8 的数。包含数字 8 的数是指有某一位是“8”的数， 例如“2018”与“188”。
三、阅读程序写结果（共 4 题，每题 8 分，共计 32 分）
1. #include<cstdio>
char st[100];
int main() {
scanf("%s", st);
for (int i = 0; st[i]; ++i) {
if ('A' <= st[i] && st[i] <= 'Z')
st[i] += 1;
}
printf("%s\\n", st);
return 0;
}
输入：QuanGuoLianSai
输出：_________
2. #include <cstdio>
int main() {
int x;
scanf("%d", &x);
int res = 0;
for (int i = 0; i < x; ++i) {
if (i * i % x == 1) {
++res;
}
}
printf("%d", res);
return 0;
}
输入：15
输出：_________
3.
#include <iostream>
using namespace std;
int n, m;
int findans(int n, int m) {
if (n == 0) return m;
if (m == 0) return n % 3;
return findans(n - 1, m) - findans(n, m - 1) + findans(n -1, m - 1);
}
int main(){
cin >> n >> m;
cout << findans(n, m) << endl;
return 0;
}
输入：5 6
输出：_________
4.
#include <cstdio>
int n, d[100];
bool v[100];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", d + i);
v[i] = false;
}
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (!v[i]) {
for (int j = i; !v[j]; j = d[j]) {
v[j] = true;
}
++cnt;
}
}
printf("%d\\n", cnt);
return 0;
}
输入：10 7 1 4 3 2 5 9 8 0 6
输出：_________四、完善程序（共 2 题，每题 14 分，共计 28 分）
![\"FE2JX)6U$2ME(AYPF6G]ITR.png\"/](\"/uploads/image/20230406/1680774373877476.png\" "\\"1680774373877476.png\\"")
#include<iostream>
using namespace std;
const int N = 110000, P = 10007;
int n;
int a[N], len;
int ans;
void getDivisor() {
len = 0;
for (int i = 1; (1) <= n; ++i)
if (n % i == 0) {
a[++len] = i;
if ( (2) != i) a[++len] = n / i;
}
}
int gcd(int a, int b) {
if (b == 0) {
(3) ;
}
return gcd(b, (4) );
}
int main() {
cin >> n;
getDivisor();
ans = 0;
for (int i = 1; i <= len; ++i) {
for (int j = i + 1; j <= len; ++j) {
ans = ( (5) ) % P;
}
}
cout << ans << endl;
return 0;
}![\"YSE~`W1TJU@(_L$`@7BSRXK.png\"/](\"/uploads/image/20230406/1680774480287026.png\" "\\"1680774480287026.png\\"")
#include<iostream>
using namespace std;
const int N = 100010;
int n;
int L[N], R[N], a[N];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
(1) ;
}
for (int i = 1; i <= n; ++i) {
R[i] = (2) ;
L[i] = i - 1;
}
for (int i = 1; i <= n; ++i) {
L[ (3) ] = L[a[i]];
R[L[a[i]]] = R[ (4) ];
}
for (int i = 1; i <= n; ++i) {
cout << (5) << " ";
}
cout << endl;
return 0;
}野牛程序员教少儿编程与信息学奥赛-微信|电话：15892516892
- 上一篇：如何让孩子自己爱上阅读？
- 下一篇：C++中的基数排序法