CSP-J 2021 入门级 第一轮（初赛） 阅读程序（3）

【题目】

CSP-J 2021 入门级 第一轮（初赛） 阅读程序（3）

01 #include<iostream>
02 using namespace std;03
03
04 const int n = 100000;
05 const int N = n + 1;
06
07 int m;
08 int a[N], b[N], c[N], d[N];
09 int f[N], g[N];
10
11 void init()
12 {
13     f[1]= g[1]= 1;
14     for(int i = 2; i <= n; i++){
15         if(!a[i]) { 
16             b[m++] = i;
17             c[i] = 1, f[i] = 2;
18             d[i] = 1, g[i] = i + 1;
19         }
20         for(int j = 0; j < m && b[j] * i <= n; j++) {
21             int k = b[j];
22             a[i * k] = 1;
23             if(i % k == 0) {
24                 c[i * k] = c[i]+ 1;
25                 f[i * k] = f[i] / c[i * k]*(c[i * k]+ 1);
26                 d[i * k] = d[i];
27                 g[i * k] = g[i] * k + d[i];
28                 break;
29             }
30             else {
31                 c[i * k] = 1;
32                 f[i * k] = 2 * f[i];
33                 d[i * k] = g[i];
34                 g[i * k]= g[i] * (k + 1);
35             }
36          }
37     }
38 }
39
40 int main()
41 {
42     init();
43     
44     int x;
45     cin >> x;
46     cout << f[x] << ' ' << g[x]<< endl;
47     return 0;
48 }

假设输入的x是不超过1000的自然数，完成下面的判断题和单选题：

• 判断题

1. 若输入不为1，把第13行删去不会影响输出的结果。（ ）
2. 第25行的 f[i] / c[i * k]可能存在无法整除而向下取整的情况。 （ ）
3. 在执行完 init() 后，f 数组不是单调递增的，但 g 数组是单调递增的。 （ ）

• 单选题

4. init 函数的时间复杂度为（ ）。
   A. $O(n)$
   B. $O(n\log n)$
   C. $O(n\sqrt{n})$
   D. $O(n^2)$
5. 在执行完 init() 后，f[1],f[2],f[3]，…，f[100] 中有（）个等于 2。
   A. 23
   B. 24
   C. 25
   D. 26
6. 当输入为 1000 时，输出为（）。
   A. 15 1340
   B. 15 2340
   C. 16 2340
   D. 16 1340

【题目考点】

1. 线性筛

2. 算术基本定理

算术基本定理，又称为正整数的唯一分解定理：
任何一个正整数都可以分解成一些质因数的乘积，并且在不计次序的情况下，这种分解方式是唯一的。
$N=p_1^{a_1}{p}_2^{a_2}...p_n^{a_n}$
其中$p_1<p_2<...<p_n$且都为质数。
$a_1,a_2,...,a_n$都是正整数。
正整数N的约数个数为：$(a_1+1)(a_2+1)...(a_n+1)={\prod }_{i=1}^n(a_i+1)$
正整数N的约数和为：$(1+p_1+p_1^2+...+p_1^{a_1})(1+p_2+...+p_2^{a_2})...(1+p_n+...+p_n^{a_n})={\prod }_{i=1}^n{\sum }_{j=0}^{a_i}{p}_i^j$

【解题思路】

要想理解本题，首先要会线性筛。（见信息学奥赛一本通 2040：【例5.7】筛选法找质数）
这是线性筛是模板代码：

bool isPrime[1005];//isPrime[i]：i是否是质数 
int prime[1005], pn;//prime[i]：第i个质数 
void initPrime(int n)
{memset(isPrime, 1, sizeof(isPrime));for(int i = 2; i <= n; ++i){if(isPrime[i])prime[++pn] = i;for(int j = 1; j <= pn && i*prime[j] <= n; ++j){isPrime[i*prime[j]] = false;if(i%prime[j] == 0)break;}}
}

对比可知a[i]表示i是否是合数。如果a[i]为0，那么i是质数，如果a[i]为1，那么i是合数。
b数组保存所有筛出的质数，m是b数组中元素的个数，只要i的质数，就将i填充到数组b中。b数组下标从0到m-1保存填充进来的m个质数。
线性筛过程中，每个数都是通过其最小质因数被筛掉。k是b[j]，即第j个质数。确定i*k是合数时，k是i*k的最小质因数。
接下来就有些难懂了。
观察可知，f数组与c数组有关，d数组与g数组有关。
我们首先关注f与c数组，将代码中其它数组相关的内容都去掉：

11 void init()
12 {
13     f[1]= 1;
14     for(int i = 2; i <= n; i++){
15         if(!a[i]) { 
16             b[m++] = i;
16             c[i] = 1, f[i] = 2;
19         }
20         for(int j = 0; j < m && b[j] * i <= n; j++) {
21             int k = b[j];
22             a[i * k] = 1;
23             if(i % k == 0) {
24                 c[i * k] = c[i]+ 1;
25                 f[i * k] = f[i] / c[i * k]*(c[i * k]+ 1);
28                 break;
29             }
30             else {
31                 c[i * k] = 1;
32                 f[i * k] = 2 * f[i];
】35             }
36          }
37     }
38 }

• 当$i$为质数时，$c_i=1$，$f_i=2$；
• 如果$i$不是$k$的倍数，那么$c_{i\cdot k}=1$，$f_{i\cdot k}=2f_i$。
• 如果$i$是$k$的倍数，那么$c_{i\cdot k}=c_i+1$，$f_{i\cdot k}=\frac{f_i(c_{i\cdot k}+1)}{c_{i\cdot k}}$。
  由于$f_{i\cdot k}$的表达式中的$c_{i\cdot k}$的值就是刚刚赋值的$c_i+1$，因此：
  $f_{i\cdot k}=f_i\frac{c_{i\cdot k}+1}{c_i+1}$

到这里，如果想看出$c$数组与f数组的意义，必须对算术基本定理十分熟悉。（见上面【题目考点】）。

$f_{i\cdot k}$每次乘以$c_{i\cdot k}+1$，和求一个正数的约数个数过程中，每次乘以质因数的指数加1，即$(a_n+1)$，很相似。进而想到$c$应该表示的是质因数的指数。
当$i$是$k$的倍数时，$k$是$i\cdot k$的最小质因数，$k$也是$i$的最小质因数。
那么$i\cdot k$分解质因数后$k$的指数比$i$分解质因数后$k$的指数大1。
因此可以联想到：$c_i$表示$i$分解质因数后，$i$的最小质因数的指数。

$c_i$表示$i$分解质因数后，$i$的最小质因数的指数。

• 当$i$为质数时，$i$的最小质因数是自己，指数为1，因此$c_i=1$
• 当$i$不是$k$的倍数时，$k$是$i\cdot k$的最小质因数，$k$的指数为1，因此$c_{i\cdot k}=1$
• 当$i$是$k$的倍数时，$k$是$i\cdot k$与$i$的最小质因数，$i\cdot k$分解质因数后$k$的指数比$i$分解质因数后$k$的指数大1，因此有$c_{i\cdot k}=c_i+1$

设$i=k^{c_i}{p}_1^{a_1}...p_n^{a_n}$，
那么$i\cdot k=k^{c_{i\cdot k}}{p}_1^{a_1}...p_n^{a_n}$
$i$的约数个数为$(c_i+1)(a_1+1)...(a_n+1)$
$i\cdot k$的约数个数为$(c_{i\cdot k}+1)(a_1+1)...(a_n+1)$
$i$的约数个数除以$(c_i+1)$再乘以$(c_{i\cdot k}+1)$，就能得到$i\cdot k$的约数个数。
据此可知，$f_i$表示$i$的约数个数

$f_i$表示$i$的约数个数

• 当$i$是质数时，$i$的约数有2个，因此$f_i=2$。
• 当$i$不是$k$的倍数时，$k$是$i\cdot k$的最小质因数
  设$i=p_1^{a_1}...p_n^{a_n}$，约数个数为：$f_i=(a_1+1)...(a_n+1)$
  那么$i\cdot k=k{p}_1^{a_1}...p_n^{a_n}$，约数个数为：$f_{i\cdot k}=(1+1)(a_1+1)...(a_n+1)$
  因此$f_{i\cdot k}=2f_i$。
• 当$i$是$k$的倍数时，$k$是$i\cdot k$的最小质因数
  设$i=k^{c_i}{p}_1^{a_1}...p_n^{a_n}$，
  那么$i\cdot k=k^{c_{i\cdot k}}{p}_1^{a_1}...p_n^{a_n}$
  $i$的约数个数为$f_i=(c_i+1)(a_1+1)...(a_n+1)$
  $i\cdot k$的约数个数为$f_{i\cdot k}=(c_{i\cdot k}+1)(a_1+1)...(a_n+1)$
  因此$f_{i\cdot k}=f_i\frac{c_{i\cdot k}+1}{c_i+1}$

接下来考虑$d$与$g$数组

11 void init()
12 {
13     f[1]= g[1]= 1;
14     for(int i = 2; i <= n; i++){
15         if(!a[i]) { 
16             b[m++] = i;
18             d[i] = 1, g[i] = i + 1;
19         }
20         for(int j = 0; j < m && b[j] * i <= n; j++) {
21             int k = b[j];
22             a[i * k] = 1;
23             if(i % k == 0) {
26                 d[i * k] = d[i];
27                 g[i * k] = g[i] * k + d[i];
28                 break;
29             }
30             else {
33                 d[i * k] = g[i];
34                 g[i * k]= g[i] * (k + 1);
35             }
36          }
37     }
38 }

• 当$i$为质数时，$d_i=1$，$g_i=i+1$；
• 如果$i$不是$k$的倍数，那么$d_{i\cdot k}=g_i$，$g_{i\cdot k}=(k+1)g_i$。
• 如果$i$是$k$的倍数，那么$d_{i\cdot k}=d_i$，$g_{i\cdot k}=k\cdot g_i+d_i$。

上面都已经确定$f_i$是根据分解质因数后的式子求约数个数，接下来大概率就要求约数和了（因为算术基本定理的知识点讲的就是这两点）
当$i$为质数时，i的约数和是$i+1$
当$i$不是$k$的倍数时，$i\cdot k$分解质因数后比$i$多了一项$k$，在求约数和时，会多乘一项$1+k$。
因此可以猜测$g_i$表示i的约数和。

$g_i$表示$i$的约数和

• 当$i$为质数时，$i$的约数和为$i+1$，有$g_i=i+1$；
• 当$i$不是$k$的倍数时，$k$是$i\cdot k$的最小质因数
  设$i=p_1^{a_1}...p_n^{a_n}$，约数和为：$g_i=(1+p_1+...+p_1^{a_1})...(1+p_n+...+p_n^{a_n})$
  $i\cdot k=k{p}_1^{a_1}...p_n^{a_n}$，约数和为：$g_{i\cdot k}=(1+k)(1+p_1+...+p_1^{a_1})...(1+p_n+...+p_n^{a_n})$
  所以$g_{i,k}=(1+k)g_i$
• 当$i$是$k$的倍数时，$k$是$i\cdot k$的最小质因数
  设$i=k^{c_i}{p}_1^{a_1}...p_n^{a_n}$，约数和$g_i=(1+k+...+k^{c_i})...(1+p_n+...+p_n^{a_n})$
  那么$i\cdot k=k^{c_{i\cdot k}}{p}_1^{a_1}...p_n^{a_n}$，约数和$g_{i\cdot k}=(1+k+...+k^{c_{i,k}})...(1+p_n+...+p_n^{a_n})$
  由于此时$c_{i,k}=c_i+1$所以
  $g_{i\cdot k}=(1+k+...+k^{c_i+1})...(1+p_n+...+p_n^{a_n})$
  $k\cdot g_i=(k+k^2+...+k^{c_i+1})...(1+p_n+...+p_n^{a_n})$
  $g_{i\cdot k}=k\cdot g_i+(1+p_1+...+p_1^{a_1})...(1+p_n+...+p_n^{a_n})$
  已知：$g_{i\cdot k}=k\cdot g_i+d_i$。
  因此可以认为$d_i=(1+p_1+...+p_1^{a_1})...(1+p_n+...+p_n^{a_n})$，也就是$i$除以自己最小质因数的幂$k^{c_i}$后剩下的数$p_1^{a_1}...p_n^{a_n}$的约数和。

$d_i$表示$i$分解质因数后，$i$除以最小质因数的幂剩下的数的约数和
即如果$i=p_1^{a_1}{p}_2^{a_2}...p_n^{a_n}$，那么$d_i$为$p_2^{a_2}...p_n^{a_n}$的约数和。
$d_i=(1+p_2+...+p_2^{a_2})...(1+p_n+...+p_n^{a_n})$

• 当$i$为质数时，$i$的最小质因数为$i$，除以$i$后剩下的数为1，约数和为1，因此$d_i=1$；
• 当$i$不是$k$的倍数时，$k$是$i\cdot k$的最小质因数
  $i\cdot k=k{p}_1^{a_1}...p_n^{a_n}$，除以最小质因数的幂后，剩下的数为：$p_1^{a_1}...p_n^{a_n}=i$，该数的约数和为$g_i$，因此$d_{i\cdot k}=g_i$
• 当$i$是$k$的倍数时，$k$是$i\cdot k$的最小质因数
  设$i=k^{c_i}{p}_1^{a_1}...p_n^{a_n}$，除以最小质因数的幂$k^{c_i}$后，剩下的数为：$p_1^{a_1}...p_n^{a_n}$，其约数和为$d_i$
  设$i\cdot k=k^{c_{i\cdot k}}{p}_1^{a_1}...p_n^{a_n}$，除以最小质因数的幂$k^{c_{i\cdot k}}$后，剩下的数为：$p_1^{a_1}...p_n^{a_n}$，其约数和为$d_{i\cdot k}$，也为$d_i$
  因此$d_{i\cdot k}=d_i$

判断题

1. 若输入不为1，把第13行删去不会影响输出的结果。（ ）
答：T
第13行语句为f[1]= g[1]= 1;
如果输入为1，输出$f_1$，$g_1$，如果不进行初始化，$f_1，g_1$的值为0，与其意义不相符。
如果输入不为1，即i不为1时，输出$f_i、g_i$的值。
当$i$为质数时，$f_i=2$，$g_i=i+1$，与$f_1$与$g_1$无关。
当$i$为合数时，$f_i$，$g_i$的求解过程依赖$c_i$与$d_i$，而$c_i$与$d_i$的值也和$f_1$与$g_1$无关。
因此输入不为1时，$f_1,g_1$的值对$f_i,g_i$的值没有影响。本题叙述正确。

2. 第25行的 f[i] / c[i * k]可能存在无法整除而向下取整的情况。 （ ）
答：F
根据上述分析，此时$c_{i\cdot k}=c_i+1$，
$c_i$是$i$的最小质因数是指数，设$i=k^{c_i}{p}_1^{a_1}...p_n^{a_n}$，那么$i$的约数个数$f_i=(c_i+1)(a_1+1)...(a_n+1)$，$f_i/(c_i+1)$是一定可以整除的，该叙述错误。

3. 在执行完 init() 后，f 数组不是单调递增的，但 g 数组是单调递增的。 （ ）
答：F
$f_i$是$i$的约数个数，不是单调递增的，比如$f_4=3$，$f_5=2$
$g_i$是$i$的约数和，也不是单调递增的，比如$g_4=1+2+4=7$，$g_5=1+5=6$
因此叙述错误。

单选题

4. init 函数的时间复杂度为（ ）。
A. $O(n)$
B. $O(n\log n)$
C. $O(n\sqrt{n})$
D. $O(n^2)$
答：A
代码整体是线性筛算法，线性筛的时间复杂度为$O(n)$

5. 在执行完 init() 后，f[1],f[2],f[3]，…，f[100] 中有（）个等于 2。
A. 23
B. 24
C. 25
D. 26
答：C
$f_i=2$表示$i$只有2个约数。每个数都有约数：1与自己。只有两个约数的数为质数。那么本题问的是$1\sim 100$中有多少个质数。
可以从小到大枚举质数，每行写10个：

2	3	5	7	11	13	17	19	23	29
31	37	41	43	47	53	59	61	67	71
73	79	83	89	97

或者在纸上用埃筛的方法。
100以内的数，偶数一定不是质数。写出剩下的奇数。

2 3 5 7 
11 13 15 17 19
21 23 25 27 29 
31 33 35 37 39
41 43 45 47 49
51 53 55 57 59
61 63 65 67 69
71 73 75 77 79
81 83 85 87 89
91 93 95 97 99 

去掉大于3的3的倍数，各位相加后是3的倍数的数是3的倍数。
去掉大于5的5的倍数，个位是5的都是5的倍数。
去掉7的倍数，有$7\ast 7=49$，$7\ast 11=77$，$7\ast 13=91$。
而后就可以结束了，因为如果n是合数，n一定存在因数小于等于$\sqrt{n}$，现在小于等于$\sqrt{100}=10$的质因数都看过了，那么剩下的数一定都是质数。

2 3 5 7 
11 13 17 19
23  29 
31 37
41 43 47
53  59
61 67
71 73 79
83 89
97 

$1\sim 100$一共有25个质数。

6. 当输入为 1000 时，输出为（）。
A. 15 1340
B. 15 2340
C. 16 2340
D. 16 1340
答：C
对1000进行分解质因数$1000=2^3\ast 5^3$
1000的约数个数$f_{1000}=(1+3)(1+3)=16$
1000的约数和为$$\begin{gathered} g_{1000}=(1+2+2^2+2^3)(1+5+5^2+5^3) \\ =(3+4+8)(6+25+125) \\ =15\ast 156=2340 \end{gathered}$$
因此会输出$16$与$2340$，选C。

【答案】

1. T
2. F
3. F
4. A
5. C
6. C