选择题
T4. 现有一张分辨率为 2048 × 1024 2048 \times 10242048×1024 像素的 32 3232 位真彩色图像。请问要存储这张图像，需要多大的存储空间？（ ）

解析：2048 × 1024 × 32 ÷ 8 = 8 2048 \times 1024 \times 32 \div8=82048×1024×32÷8=8MB

T5. 冒泡排序算法的伪代码如下：

输入：数组 L，n ≥ 1。输出：按非递减顺序排序的 L。
算法 BubbleSort：
FLAG ← n // 标记被交换的最后元素位置
while FLAG > 1 do
k ← FLAG - 1
FLAG ← 1
for j = 1 to k do
if L(j) > L(j+1) then do
L(j) ↔ L(j+1)
FLAG ← j
1
2
3
4
5
6
7
8
9
10
对 n 个数用以上冒泡排序算法进行排序，最少需要比较多少次？（n - 1）

解析：当数组L中的元素按照非递减顺序排列时，比较次数最少。此时，内层for循环执行n-1次，FLAG值始终为1。

T6. 设 A 是 n 个实数的数组，考虑下面的递归算法：

XYZ(A[1..n])
1) if n=1 then return A[1]
2) else temp ← XYZ(A[1..n-1])
3) if temp < A[n]
4) then return temp
5) else return A[n]
1
2
3
4
5
6
请问算法 XYZ 的输出是什么？（ ）

解析：当数组的长度n为1时，返回A[1]。否则，递归求解XYZ(A[1..n-1])。核心逻辑在于如果求解得到的temp < A[n]，返回temp；否则返回A[n]。可以推断出是在打擂台求最小值。

T10. 五个小朋友并排站成一列，其中有两个小朋友是双胞胎，如果要求这两个双胞胎必须相邻，则有（ ）种不同排列方法？

解析：可以分两步解决：

双胞胎必须相邻，那么利用捆绑法，将双胞胎当作1个小朋友，那么4个小朋友的排列数为4 ! = 24 4!=244!=24
双胞胎的位置可以互换，因此对应2 22种排列
利用乘法原理，不同的排列方法有：48种。

T14. 10 个三好学生名额分配到 7 个班级，每个班级至少有一个名额，一共有（ ）种不同的分配方案。

解析：每个班级至少有一个名额，那么还剩下3个名额，可以进行如下分类：

分给3个班，每班一个，从7个班中选3个班的方案有：C 7 3 = 35 C_7^3=35C
7
3
​
=35
分给2个班，一个班2个、一个班1个，从7个班中选2个班的方案有：C 7 2 = 21 C_7^2=21C
7
2
​
=21；这两个班的名额交换过来又是一种方案，这样就有42种方案
分给1个班，从7个班中选1个班的方案有7种。
利用加法原理，一共有84种方案

T15. 有五副不同颜色的手套（共 10 只手套，每副手套左右手各 1 只），一次性从中取 6 只手套，请问恰好能配成两副手套的不同取法有（ ）种。

解析：从5副不同颜色的手套取 6 只手套，恰好能配成两副手套，可以分3步解决：

从5副手套中挑出两副手套，方案数有：C 5 2 = 10 C_5^2=10C
5
2
​
=10
从剩下的3副手套中挑出两副手套（剩下的两只手套不同，所以需要从2副手套中选出），方案数有：C 3 2 = 3 C_3^2=3C
3
2
​
=3
由于颜色不同，这两只手套一共有4 44种组合：左左、左右、右左、右右。
利用乘法原理，一共有120种方案。

阅读程序
T1. 字符编码

include [HTML_REMOVED]

include [HTML_REMOVED]

using namespace std;

char encoder[26] = {‘C’, ‘S’, ‘P’, 0};
char decoder[26];

string st;

int main() {
int k = 0;
for (int i = 0; i < 26; i)
if (encoder[i] != 0) k;
for (char x = ‘A’; x <= ‘Z’; x) {
bool flag = true;
for (int i = 0; i < 26; i)
if (encoder[i] == x) {
flag = false;
break;
}
if (flag) {
encoder[k] = x;
k;
}
}
for (int i = 0; i < 26; i)
decoder[encoder[i] - ‘A’] = i + ‘A’;
cin >> st;
for (int i = 0; i < st.length(); ++i)
st[i] = decoder[st[i] - ‘A’];
cout << st;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
解析：程序中将26个大写英文字母进行了编码。第一段for循环统计了encoder[]中字母的个数；第二段for循环将剩余字母依次放入enconder[]数组；第三段for循环将encoder[]中的每一个字母依次映射到A~Z，对应关系如下：

deconder[x] C S P A B D E F G H I J K L M N O Q R T U V W X Y Z
映射为 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
输入的字符串应当只由大写字母组成，否则在访问数组时可能越界。（正确 ）
解析：数组大小均为26，如果存在小写字母数组访问会越界。

若输入的字符串不是空串，则输入的字符串与输出的字符串一定不一样。（ 错误）
解析：从对应关系可以看出，S后面的字母映射之后没有变化，如果输入字符串有这些字母组成，则输入的字符串与输出的字符串是一样的。

将第 12 行的“i < 26”改为“i < 16”，程序运行结果不会改变。（正确 ）
解析：encoder[]初始化为3个字符，所以第一段for循环改为i < 16，对程序结果不会有任何影响。

将第 26 行的“i < 26”改为“i < 16”，程序运行结果不会改变。（ 错误）
解析：第 26 行的for循环作用是将大写英文字母映射到A~Z上。如果改为i < 16，那么后面部分的字母映射错误，在某些输入情况下（例如UVW），程序运行结果会发生改变。

若输出的字符串为“ABCABCABCA”，则下列说法正确的是（ ）
解析：若输出ABCABCABCA，根据映射的对应关系，则输入字符串为CSPCSPCSPC，因此输入的字符串中既有 S 又有 P。

若输出的字符串为“CSPCSPCSPCSP”，则下列说法正确的是（ ）
解析：若输出CSPCSPCSPCSP，根据映射的对应关系，则输入字符串为PRNPRNPRNPRN，输入的字符串中既有 P 又有 R。

T2. 进制转换

include [HTML_REMOVED]

using namespace std;

long long n, ans;
int k, len;
long long d[1000000];

int main() {
cin >> n >> k;
d[0] = 0;
len = 1;
ans = 0;
for (long long i = 0; i < n; i) {
d[0];
for (int j = 0; j + 1 < len; j) {
if (d[j] == k) {
d[j] = 0;
d[j + 1] += 1;
ans;
}
}
if (d[len - 1] == k) {
d[len - 1] = 0;
d[len] = 1;
len;
ans;
}
}
cout << ans << endl;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
假设输入的 n nn 是不超过 2 62 2^{62}2
62
的正整数，k kk 都是不超过 10000 1000010000 的正整数。

解析：题目中进行了n次循环，每次循环将d[0]增加1；然后检查第0位到第len-2是否为k，如果等于k则进行进位处理；最后判断最高位是否需要向前进位。
因此程序的作用是将n转换为k进制数，len记录转换后的位数，ans记录进位次数。

若 k=1，则输出 ans 时，len = n。（错误 ）
解析：k = 1时，无论n的值为多少，len的值只会在第一次循环最后的if中增加1次，而ans会增加n次，因此len = 2，ans = n。

若 k>1，则输出 ans 时，len 一定小于 n。（ 错误）
解析：举出一个反例即可，例如n = 1，k = 2时，将1转换为二进制的位数len = 1，此时len = n。

若 k>1，则输出 ans 时，k l e n k^{len}k
len
一定大于 n。（ 正确）
解析：除了k = 1的情况，任何数n转换为len位的k进制数后，k l e n > n k^{len} > nk
len

n，例如8的转换二进制为( 1000 ) 2 (1000)_2(1000)
2
​
，一共4位，而2 4 > 8 2^4>82
4
8。

若输入的 n 等于 1 0 15 10^{15}10
15
，输入的 k 为 1，则输出等于（ ）。
解析：k = 1时，无论n的值为多少，len的值只会在第一次循环最后的if中增加1次，而ans会增加n次，因此输出为1 0 5 10^510
5
。

若输入的 n 等于 205,891,132,094,649（即 3 30 3^{30}3
30
），输入的 k 为 3，则输出等于（3 30 − 1 2 \frac{3^{30}-1}{2}
2
3
30
−1
​
）。
解析：题目要计算的是将n转换为3进制的过程中，进位次数ans，其中n为3 30 3^{30}3
30
。由于数据规模较大，不妨先计算3 3 3^{3}3
3
，寻找规律。3 3 = ( 1000 ) 3 3^{3}=(1000)_33
3
=(1000)
3
​
，为求进位次数，可以将进位情况分为以下几类：

向最高位进位，有1种情况：( 222 ) 3 (222)_3(222)
3
​

向次高位进位，有3种情况：( 022 ) 3 (022)_3(022)
3
​
、( 122 ) 3 (122)_3(122)
3
​
、( 222 ) 3 (222)_3(222)
3
​

向第二位进位，有9种情况：( 002 ) 3 (002)_3(002)
3
​
、( 012 ) 3 (012)_3(012)
3
​
、( 022 ) 3 (022)_3(022)
3
​
、( 102 ) 3 (102)_3(102)
3
​
、( 112 ) 3 (112)_3(112)
3
​
、( 122 ) 3 (122)_3(122)
3
​
、( 202 ) 3 (202)_3(202)
3
​
、( 212 ) 3 (212)_3(212)
3
​
、( 222 ) 3 (222)_3(222)
3
​

因此，转换过程中总的进位次数a n s = 1 + 3 + 9 = 13 ans = 1 + 3 + 9 = 13ans=1+3+9=13。
进一步分析发现，对3 m 3^{m}3
m
的进位情况进行分类，每类的进位次数满足公比为3的等比数列，因此总的进位次数a n s = 3 0 + 3 1 + 3 2 + . . . + 3 m − 1 = 1 × 1 − 3 m 1 − 3 = 3 m − 1 2 ans = 3^0 + 3 ^1 + 3^2 + …+3^{m-1}=1\times \frac{1-3^m}{1-3}=\frac{3^m-1}{2}ans=3
0
+3
1
+3
2
+…+3
m−1
=1×
1−3
1−3
m

​
=
2
3
m
−1
​
。当m=30时，a n s = 3 30 − 1 2 ans = \frac{3^{30}-1}{2}ans=
2
3
30
−1
​
。
进步一推广，当输入n = k m n=k^mn=k
m
时，a n s = k m − 1 k − 1 ans = \frac{k^m-1}{k-1}ans=
k−1
k
m
−1
​

若输入的 n 等于 100,010,002,000,090，输入的 k 等于 10，则输出等于（11,112,222,444,453 ）。
解析：利用26题得到的结论，那么当k = 10 k=10k=10时：

累加到100 , 000 , 000 , 000 , 000 100,000,000,000,000100,000,000,000,000，需要进位11 , 111 , 111 , 111 , 111 11,111,111,111,11111,111,111,111,111次
累加到10 , 000 , 000 , 000 10,000,000,00010,000,000,000，需要进位1 , 111 , 111 , 111 , 111 1,111,111,111,1111,111,111,111,111次
累加到2 , 000 , 000 2,000,0002,000,000，需要进位2 × 111111 = 222 , 222 2 \times 111111=222,2222×111111=222,222次
累加到90 9090，需要进位9 × 1 = 9 9\times1=99×1=9次
总的进位次数a n s = 11 , 111 , 111 , 111 , 111 + 1 , 111 , 111 , 111 , 111 + 222 , 222 + 9 = 11 , 112 , 222 , 444 , 453 ans=11,111,111,111,111+1,111,111,111,111+222,222+9=11,112,222,444,453ans=11,111,111,111,111+1,111,111,111,111+222,222+9=11,112,222,444,453

T3. 深搜序列

include [HTML_REMOVED]

include [HTML_REMOVED]

using namespace std;

int n;
int d[50][2];
int ans;

void dfs(int n, int sum) {
if (n == 1) {
ans = max(sum, ans);
return;
}
for (int i = 1; i < n; i) {
int a = d[i - 1][0], b = d[i - 1][1];
int x = d[i][0], y = d[i][1];
d[i - 1][0] = a + x;
d[i - 1][1] = b + y;
for (int j = i; j < n - 1; j)
d[j][0] = d[j + 1][0], d[j][1] = d[j + 1][1];
int s = a + x + abs(b - y);
dfs(n - 1, sum + s);
for (int j = n - 1; j > i; –j)
d[j][0] = d[j - 1][0], d[j][1] = d[j - 1][1];
d[i - 1][0] = a, d[i - 1][1] = b;
d[i][0] = x, d[i][1] = y;
}
}

int main() {
cin >> n;
for (int i = 0; i < n; i)
cin >> d[i][0];
for (int i = 0; i < n; i)
cin >> d[i][1];
ans = 0;
dfs(n, 0);
cout << ans << endl;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
假设输入的 n 是不超过 50 的正整数，d[i][0]、d[i][1] 都是不超过 10000 的正整数。

解析：程序输入了两个长度为n的序列A和B，分别保存到d[i][0]和d[i][1]。dfs求解A序列相邻项的和与B序列相邻项差的绝对值，球它们之和的最大值。

若输入的 n 为 0，此程序可能会死循环或发生运行错误。（ 错误）
解析：当n为0时，dfs中for循环不会被执行，因此输出0，不会发生死循环。

若输入的 n 为 20，接下来的输入全为 0，则输出为 0。（正确 ）
解析：当两个序列同时为0，dfs中sum也始终为0，则输出为0。

输出的数一定不小于输入的 d[i][0] 和 d[i][1] 的任意一个。（ 错误）
解析：举出一个反例即可，例如n = 1时，ans = 0，小于d[1][0] 和 d[1][1] 。

若输入的 n 为 20，接下来输入的是 20 个 9 和 20 个 0，则输出为（ ）。
解析：若B序列为0，那么dfs就是对A序列进行迭代求和，将n取不同的值分析规律：

n 1 2 3 4 5 … 20
s 0 9+9=18 18+9=27 27+9=36 36+9=45 … 20×9=180
ans 0 0+18=18 18+27=45 45+36=81 81+45 =126 … 2×9+3×9+4×9+5×9+…+20×9
因此，a n s = ( 2 + 20 ) ∗ 19 2 × 9 = 1881 ans = \frac{(2 + 20)*19}{2}\times9=1881ans=
2
(2+20)∗19
​
×9=1881

若输入的 n 为 30，接下来的输入是 30 个 0 和 30 个 5，则输出为（ ）。
解析：若A序列为0，那么dfs就是对B序列相邻项差的绝对值迭代求和，将n取不同的值分析规律：

n 1 2 3 4 5 … 30
s 0 5-5=0 10-5=5 15-5=10 20-5=15 … 29×5-5=28×5=140
ans 0 0 0+5=5 5+10=15 15+15 =30 … 1×5+2×5+3×5+4×5+…+28×5
因此，a n s = ( 1 + 28 ) ∗ 28 2 × 5 = 2030 ans = \frac{(1 + 28)*28}{2}\times5=2030ans=
2
(1+28)∗28
​
×5=2030

若输入的 n 为 15，接下来输入是 15 到 1，以及 15 到 1，则输出为（ ）。
解析：将n取不同的值分析规律：

n 15 14 13 12 … 2
b[i][0] 15+14=29 15+14+13=42 15+14+13+12=54 15+14+13+12+11=65 … 15+14+13+12+11+2+1
s 15+14+15-14= 30 (15+14)+13+(15+14)-13=6 (15+14+13)+12+(15+14+13)-12=84 (15+14+13+12)+11+(15+14+13+12)-11=130 … (15+14+…+2)-1+(15+14+…+2)-1=238
ans 0+30=30 30+58=88 88+84=172 172+108=280 … 15×2+(15+14)×2+…+(15+14+…+2)×2
因此，a n s = 15 × 2 + ( 15 + 14 ) × 2 + . . . + ( 15 + 14 + . . . + 2 ) × 2 = ( 15 + 29 + 42 + 54 + 65 + 75 + 84 + 92 + 99 + 105 + 110 + 114 + 117 + 119 ) × 2 = 1120 × 2 = 2240 ans =15×2+(15+14)×2+…+(15+14+…+2)×2=(15+29+42+54+65+75+84+92+99+105+110+114+117+119)\times2=1120\times2=2240ans=15×2+(15+14)×2+…+(15+14+…+2)×2=(15+29+42+54+65+75+84+92+99+105+110+114+117+119)×2=1120×2=2240

完善程序
质因数分解
给出正整数 n nn，请输出将n nn 质因数分解的结果，结果从小到大输出。

例如：输入 n = 120 n=120n=120，程序应该输出 2 2 2 3 5，表示 120 = 2 × 2 × 2 × 3 × 5 120=2\times2\times2\times3\times5120=2×2×2×3×5。输入保证 2 ≤ n ≤ 1 0 9 2 \le n \le 10^92≤n≤10
9

。提示：先从小到大枚举变量 i ii，然后用 i ii 不停试除 n nn 来寻找所有的质因子。

试补全程序。

include [HTML_REMOVED]

using namespace std;

int n, i;

int main() {
scanf(“%d”, &n);
for (i = ①; ② <= n; i ++) {
③ {
printf(“%d “, i);
n = n / i;
}
}
if (④) {
printf(“%d “, ⑤);
}
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
解析：由于n nn中最多只包含一个大于n \sqrt{n}
n
​
的质因子。反证法，如果包含两个大于n \sqrt{n}
n
​
的质因子a aa和b bb，那么a × b > n a×b>na×b>n。因此，可以对大于n \sqrt{n}
n
​
的质因子单独处理，时间复杂度可以优化到O ( n ) O(\sqrt{n})O(
n
​
)。

空①，从最小的质数2开始枚举所有小于等于n \sqrt{n}
n
​
的数，答案为2。
空②，枚举所有小于等于n \sqrt{n}
n
​
的数，答案为i * i
空③，只要n能被i整除，就将i从n中除掉，答案为while(n % i == 0)
空④，如果n>1，说明n中包含一个大于等于n \sqrt{n}
n
​
的质因子，答案为n>1
空⑤，因为其它小于等于n \sqrt{n}
n
​
的质因子已经从n中除掉，所以答案为n。
最小区间覆盖
给出 n nn 个区间，第 i ii 个区间的左右端点是[ a i , b i ] [a_i,b_i][a
i
​
,b
i
​
]。现在要在这些区间中选出若干个，使得区间 [ 0 , m ] [0,m][0,m] 被所选区间的并覆盖（即每一个 0 ≤ i ≤ m 0 \le i \le m0≤i≤m 都在某个所选的区间中）。保证答案存在，求所选区间个数的最小值。

输入第一行包含两个整数 n nn 和 m mm（1 ≤ n ≤ 5000 1 \le n \le 50001≤n≤5000, 1 ≤ m ≤ 1 0 9 1 \le m \le 10^91≤m≤10
9
）。
接下来 $n $行，每行两个整数 a i a_ia
i
​
，b i b_ib
i
​
(0 ≤ a i 0 \le a_i0≤a
i
​
，b i ≤ m b_i \le mb
i
​
≤m）。
提示：使用贪心法解决这个问题。先用Θ ( n 2 ) \Theta(n^2)Θ(n
2
) 的时间复杂度排序，然后贪心选择这些区间。

试补全程序。

include [HTML_REMOVED]

using namespace std;

const int MAXN = 5000;
int n, m;
struct segment { int a, b; } A[MAXN];

void sort() // 排序
{
for (int i = 0; i < n; i)
for (int j = 1; j < n; j)
if (①)
{
segment t = A[j];
②
}
}

int main()
{
cin >> n >> m;
for (int i = 0; i < n; i)
cin >> A[i].a >> A[i].b;
sort();
int p = 1;
for (int i = 1; i < n; i)
if (③)
A[p] = A[i];
n = p;
int ans = 0, r = 0;
int q = 0;
while (r < m)
{
while (④)
q;
⑤;
ans++;
}
cout << ans << endl;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
算法思想如下：

首先使用了冒泡排序的思想，将所有区间按照左端点从小到大排序。
去除所有被包含的区间，例如[3,10]、[4,9]，后面的区间被前面的区间包含了，不需要进行判断。
为覆盖区间[0,m]，将r设为 0，在区间数组中找到离r最近的、并且左端点<=r的区间q，使用区间q的右端点更新r，重复这个过程直到r>=m。
空①，冒泡排序，将左端点值小的区间交到数组前面，答案为A[j].a[HTML_REMOVED]A[p-1].b
空④，找到r左边第一个区间q，答案为q + 1 < p && A[q + 1].a <= r
空⑤，用区间q的右端点更新r，答案为r = max(r, A[q