C/C++编程（1~8级）全部真题・点这里
第1题：完美立方
形如 a^3= b^3 + c^3 + d^3的等式被称为完美立方等式。例如 12^3= 6^3 + 8^3 + 10^3 。
编写一个程序，对任给的正整数 N (N≤100)，寻找所有的四元组 (a, b, c, d)，使得 a^3= b^3 + c^3 + d^3 ，其中 a,b,c,d均大于 11, 小于等于 N，且 b≤c≤d 。
时间限制：1000
内存限制：65536
输入
一个正整数 N(N≤100)。
输出
每行输出一个完美立方。输出格式为：
Cube = a, Triple = (b,c,d)
其中 a,b,c,d 所在位置分别用实际求出四元组值代入。
请按照 a 的值，从小到大依次输出。
当两个完美立方等式中 a 的值相同，则 b 值小的优先输出、仍相同则 c 值小的优先输出。
样例输入
24
样例输出
Cube = 6, Triple = (3,4,5)
Cube = 12, Triple = (6,8,10)
Cube = 18, Triple = (2,12,16)
Cube = 18, Triple = (9,12,15)
Cube = 19, Triple = (3,10,18)
Cube = 20, Triple = (7,14,17)
Cube = 24, Triple = (12,16,20)
下面是一个使用C语言实现的解决方案，可以找到满足完美立方等式的四元组 (a, b, c, d)：
#include <stdio.h>
void find_perfect_cubes(int N) {
for (int a = 2; a <= N; a++) {
for (int b = 2; b <= N; b++) {
for (int c = b; c <= N; c++) {
for (int d = c; d <= N; d++) {
if (a * a * a == b * b * b + c * c * c + d * d * d) {
printf("Cube = %d, Triple = (%d,%d,%d)\n", a, b, c, d);
}
}
}
}
}
}
int main() {
int N;
scanf("%d", &N);
find_perfect_cubes(N);
return 0;
}
这个实现中，我们使用四重循环来遍历所有可能的四元组 (a, b, c, d)。其中，a从2到N，b从2到N，c从b到N，d从c到N。对于每个四元组，判断是否满足完美立方等式 a^3 = b^3 + c^3 + d^3 ，如果满足，则输出该四元组。
在main函数中，我们读取输入的N，并调用find_perfect_cubes函数找到满足条件的四元组。然后，我们按照要求输出每个完美立方等式的结果。
注意：在实际编写和运行代码时，请确保输入数据的格式和范围符合题目要求，并进行必要的错误处理。
第2题：不定方程求解
给定正整数a，b，c。求不定方程 ax+by=c 关于未知数x和y的所有非负整数解组数。
时间限制：1000
内存限制：65536
输入
一行，包含三个正整数a，b，c，两个整数之间用单个空格隔开。每个数均不大于1000。
输出
一个整数，即不定方程的非负整数解组数。
样例输入
2 3 18
样例输出
4
下面是一个使用C语言实现的解决方案，可以求解不定方程 ax+by=c 的非负整数解组数：
#include <stdio.h>
int count_solutions(int a, int b, int c) {
int count = 0;
for (int x = 0; x <= c / a; x++) {
int remainder = c - a * x;
if (remainder % b == 0) {
count++;
}
}
return count;
}
int main() {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
int num_solutions = count_solutions(a, b, c);
printf("%d\n", num_solutions);
return 0;
}
这个实现中，我们定义了一个辅助函数count_solutions，用于计算不定方程的非负整数解组数。在函数中，我们使用一个循环来遍历所有可能的x值，其中x的范围是从0到c/a。对于每个x值，我们计算对应的余数remainder = c - a * x，并检查remainder是否能被b整除。如果能整除，则表示存在一个满足条件的非负整数解组，计数器count加1。
在main函数中，我们读取输入的a、b、c，并调用count_solutions函数计算解组数。然后，我们输出解组数。
注意：在实际编写和运行代码时，请确保输入数据的格式和范围符合题目要求，并进行必要的错误处理。
第3题：分解因数
给出一个正整数 a ，要求分解成若干个正整数的乘积，即 a = a1· a2 ·a3·…·an，并且 1<a1≤a2≤a3≤…≤ an，问这样的分解的种数有多少。
注意到 a = a 也是一种分解。
时间限制：1000
内存限制：65536
输入
第 1 行是测试数据的组数 n(1≤n≤1000) ，后面跟着 n 行输入。每组测试数据占 1 行，包括一个正整数 a (1<a<32768)
输出
n 行，每行输出对应一个输入。输出应是一个正整数，指明满足要求的分解的种数。
样例输入
2
2
20
样例输出
1
4
下面是一个使用C语言实现的解决方案，可以计算给定正整数a的分解因数的种数：
#include <stdio.h>
int count_factors(int n) {
int count = 0;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
count++;
}
}
return count;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
int num_factors = count_factors(a);
printf("%d\n", num_factors);
}
return 0;
}
这个实现中，我们定义了一个辅助函数count_factors，用于计算给定正整数n的因数个数。在函数中，我们使用一个循环来遍历从1到n的所有数，如果某个数能整除n，则计数器count加1。
在main函数中，我们首先读取输入的测试数据组数n。然后，使用一个循环来处理每组测试数据。对于每组数据，我们读取输入的正整数a，并调用count_factors函数计算分解因数的种数。最后，我们输出结果。
注意：在实际编写和运行代码时，请确保输入数据的格式和范围符合题目要求，并进行必要的错误处理。
第4题：上台阶
楼梯有 n(1≤n≤30) 阶台阶,上楼时可以一步上 1 阶,也可以一步上 2 阶,也可以一步上 3 阶，编程计算共有多少种不同的走法。
时间限制：1000
内存限制：65536
输入
输入的每一行包括一组测试数据，即为台阶数 n(1≤n≤30) 。最后一行为0，表示测试结束。
输出
每一行输出对应一行输入的结果，即为走法的数目。
样例输入
1
2
3
4
0
样例输出
1
2
4
7
下面是一个使用C语言实现的解决方案，可以计算给定台阶数n的不同走法数量：
#include <stdio.h>
int count_ways(int n) {
if (n <= 0) {
return 0;
} else if (n == 1) {
return 1;
} else if (n == 2) {
return 2;
} else if (n == 3) {
return 4;
} else {
int ways[n+1];
ways[1] = 1;
ways[2] = 2;
ways[3] = 4;
for (int i = 4; i <= n; i++) {
ways[i] = ways[i-1] + ways[i-2] + ways[i-3];
}
return ways[n];
}
}
int main() {
int n;
while (1) {
scanf("%d", &n);
if (n == 0) {
break;
}
int num_ways = count_ways(n);
printf("%d\n", num_ways);
}
return 0;
}
这个实现中，我们定义了一个辅助函数count_ways，用于计算给定台阶数n的不同走法数量。在函数中，我们使用动态规划的思想来计算走法数量。对于n大于3的情况，我们使用一个数组ways来保存每个台阶数对应的走法数量。初始情况下，我们已知1阶有1种走法，2阶有2种走法，3阶有4种走法。然后，我们从4阶开始迭代计算每个台阶数的走法数量，通过累加前面三个台阶数的走法数量得到当前台阶数的走法数量。最后，我们返回数组ways中n阶对应的走法数量。
在main函数中，我们使用一个循环来读取输入的台阶数n，并调用count_ways函数计算走法数量。当输入的台阶数为0时，表示测试结束，循环结束。
注意：在实际编写和运行代码时，请确保输入数据的格式和范围符合题目要求，并进行必要的错误处理。
第5题：田忌赛马
在田忌赛马的故事中，孙膑用自己的下等马对战对手的上等马，自己上等马对阵对手的中等马，自己的中等马对阵对手的下等马，从而赢得了胜利。现在即将进行的是N匹马的赛马比赛。双方队伍的马各分为N等。已知只有当我方马的等级比对方马等级高 X 等以上（包含 X ）时，我方才可以取得这场比赛的胜利。如果在N场比赛中我方的胜场数大于对方，则我方取得最终的胜利。现在已知对方这 N 场比赛的出战方案，请计算所有令我方最终获胜的出战方案。
时间限制：1000
内存限制：65536
输入
第一行两个整数， N 和 X 。0≤X<N≤9 。 第二行 N 个正整数，A1, A2,…, AN 。Ai表示第 i 场比赛对方马的等级，1≤i≤N。等级越高越强。
输出
按字典序输出所有我方最终获胜的方案，每个方案一行。每行是 N 个正整数，两两之间以一个空格分隔，第 i 个数表示我方第 i 场比赛马的等级。
样例输入
样例输入1
3 1
3 2 1
样例输入2
3 0
3 1 2
样例输出
样例输出1
1 3 2
样例输出2
1 2 3
1 3 2
2 1 3
3 1 2
3 2 1
下面是一个使用C语言实现的解决方案，可以计算所有使我方最终获胜的出战方案：
#include <stdio.h>
#include <stdlib.h>
int N, X;
int opponent[10];
int used[10];
int my_horses[10];
int compare(const void *a, const void *b) {
return *(int*)a - *(int*)b;
}
void dfs(int idx) {
if (idx == N) {
for (int i = 0; i < N; i++) {
printf("%d ", my_horses[i]);
}
printf("\n");
return;
}
for (int i = 0; i < N; i++) {
if (!used[i] && my_horses[idx - 1] - opponent[i] >= X) {
used[i] = 1;
my_horses[idx] = opponent[i];
dfs(idx + 1);
used[i] = 0;
}
}
}
int main() {
scanf("%d %d", &N, &X);
for (int i = 0; i < N; i++) {
scanf("%d", &opponent[i]);
}
qsort(opponent, N, sizeof(int), compare);
my_horses[0] = 10; // 设置一个较大的初始值
dfs(0);
return 0;
}
这个实现中，我们使用深度优先搜索（DFS）算法来生成所有可能的我方出战方案。我们使用一个全局数组opponent来存储对方马的等级，并根据题目要求进行排序。我们还使用一个全局数组used来标记对方马是否被使用过，以及一个全局数组my_horses来存储我方马的等级。
在dfs函数中，我们通过递归实现深度优先搜索。在每个递归层级中，我们检查所有未被使用的对方马，并且满足我方马的等级比对方马等级高X以上的条件。对于满足条件的对方马，我们将其标记为已使用，并将其添加到我方马的等级数组my_horses中。然后，我们继续递归调用dfs函数，进入下一个递归层级。当递归到最后一层时，即完成了一种出战方案的生成，我们将生成的出战方案输出。
在main函数中，我们首先读取输入的N和X，并读取对方马的等级，并对对方马的等级进行排序。然后，我们调用dfs函数开始进行深度优先搜索，生成所有可能的我方出战方案。
注意：在实际编写和运行代码时，请确保输入数据的格式和范围符合题目要求，并进行必要的错误处理。
