2022年12月 C/C++（四级）真题解析#中国电子学会#全国青少年软件编程等级考试

第1题：开餐馆

北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。小明打算从中选择合适的位置开设一些餐馆。这 n 个地点排列在同一条直线上。我们用一个整数序列m1, m2, … mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。我们用pi 表示在mi 处开餐馆的利润。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。请你帮助小明选择一个总利润最大的方案。
时间限制：1000
内存限制：65536
输入
标准的输入包含若干组测试数据。输入第一行是整数T (1 <= T <= 1000) ，表明有T组测试数据。紧接着有T组连续的测试。每组测试数据有3行, 第1行:地点总数 n (n < 100), 距离限制 k (k > 0 && k < 1000). 第2行:n 个地点的位置m1 , m2, … mn ( 1000000 > mi > 0 且为整数,升序排列) 第3行:n 个地点的餐馆利润p1 , p2, … pn ( 1000 > pi > 0 且为整数)
输出
对于每组测试数据可能的最大利润
样例输入
2
3 11
1 2 15
10 2 30
3 16
1 2 15
10 2 30
样例输出
40
30

要解决开餐馆的问题，可以使用动态规划的方法。

以下是使用C语言实现的代码：

#include 
#include 

int max(int a, int b) {
    return (a > b) ? a : b;
}

int maxProfit(int m[], int p[], int n, int k) {
    int dp[100];
    dp[0] = p[0];

    for (int i = 1; i < n; i++) {
        dp[i] = p[i];
        for (int j = i - 1; j >= 0; j--) {
            if (m[i] - m[j] > k) {
                dp[i] = max(dp[i], dp[j] + p[i]);
            }
        }
    }

    int maxProfit = 0;
    for (int i = 0; i < n; i++) {
        maxProfit = max(maxProfit, dp[i]);
    }

    return maxProfit;
}

int main() {
    int T;
    scanf("%d", &T);

    while (T--) {
        int n, k;
        scanf("%d %d", &n, &k);

        int m[100];
        int p[100];

        for (int i = 0; i < n; i++) {
            scanf("%d", &m[i]);
        }

        for (int i = 0; i < n; i++) {
            scanf("%d", &p[i]);
        }

        int result = maxProfit(m, p, n, k);
        printf("%d\n", result);
    }

    return 0;
}

该代码使用一个一维数组dp来记录到达每个位置时的最大利润。

首先，将dp数组的初始值全部设为0。

然后，从第一个位置开始遍历到最后一个位置，对于每个位置i，将该位置的利润p[i]作为初始值。

接下来，从位置i-1开始往前遍历，对于每个位置j，判断如果从位置j到位置i的距离大于k，则可以考虑将餐馆放在位置j，并更新位置i的最大利润为dp[j] + p[i]。

最后，遍历整个位置数组，找到最大的利润值，并输出。

主函数根据输入的测试组数，循环读取每组测试数据，并调用maxProfit函数计算答案并输出。

第2题：糖果

由于在维护世界和平的事务中做出巨大贡献，Dzx被赠予糖果公司2010年5月23日当天无限量糖果免费优惠券。在这一天，Dzx可以从糖果公司的N件产品中任意选择若干件带回家享用。糖果公司的N件产品每件都包含数量不同的糖果。Dzx希望他选择的产品包含的糖果总数是K的整数倍，这样他才能平均地将糖果分给帮助他维护世界和平的伙伴们。当然，在满足这一条件的基础上，糖果总数越多越好。Dzx最多能带走多少糖果呢? 注意：Dzx只能将糖果公司的产品整件带走。
时间限制：7000
内存限制：65536
输入
第一行包含两个整数N(1<=N<=100)和K(1<=K<=100) 以下N行每行1个整数，表示糖果公司该件产品中包含的糖果数目，不超过1000000
输出
符合要求的最多能达到的糖果总数，如果不能达到K的倍数这一要求，输出0
样例输入
5 7
1
2
3
4
5
样例输出
14
提示
Dzx的选择是2+3+4+5=14，这样糖果总数是7的倍数，并且是总数最多的选择。

要解决糖果问题，可以使用动态规划的方法。

以下是使用C语言实现的代码：

#include 
#include 

int max(int a, int b) {
    return (a > b) ? a : b;
}

int maxCandies(int candies[], int n, int k) {
    bool dp[100001] = {false};
    dp[0] = true;

    int maxCandies = 0;
    for (int i = 0; i < n; i++) {
        for (int j = k - 1; j >= 0; j--) {
            if (dp[j]) {
                for (int x = 1; x <= candies[i]; x++) {
                    if (j + x * k > 100000) {
                        break;
                    }
                    dp[j + x * k] = true;
                    maxCandies = max(maxCandies, j + x * k);
                }
            }
        }
    }

    return maxCandies;
}

int main() {
    int N, K;
    scanf("%d %d", &N, &K);

    int candies[100];
    for (int i = 0; i < N; i++) {
        scanf("%d", &candies[i]);
    }

    int result = maxCandies(candies, N, K);
    printf("%d\n", result);

    return 0;
}

该代码使用一个布尔数组dp来记录是否能够组成糖果总数的倍数。

首先，将dp数组的初始值全部设为false，表示不能组成任何糖果总数的倍数。

然后，将0设为true，表示可以组成0的倍数。

接下来，从第一个糖果开始遍历到最后一个糖果，对于每个糖果candies[i]，从目标糖果总数k-1开始往前遍历，对于每个总数j，如果dp[j]为true表示可以组成总数j的倍数，那么可以考虑将糖果candies[i]的个数乘以倍数k加到总数j上，并更新dp[j + x * k]为true，表示可以组成总数j + x * k的倍数。

同时，记录最大的糖果总数maxCandies。

最后，返回最大的糖果总数maxCandies作为结果。

主函数读取输入的糖果数量和倍数，以及每个糖果的数量，然后调用maxCandies函数计算答案并输出。

第3题：鸡蛋的硬度

最近XX公司举办了一个奇怪的比赛：鸡蛋硬度之王争霸赛。参赛者是来自世 界各地的母鸡，比赛的内容是看谁下的蛋最硬，更奇怪的是XX公司并不使用什么精密仪器来测量蛋的硬度，他们采用了一种最老土的办法–从高度扔鸡蛋–来 测试鸡蛋的硬度，如果一次母鸡下的蛋从高楼的第a层摔下来没摔破，但是从a+1层摔下来时摔破了，那么就说这只母鸡的鸡蛋的硬度是a。你当然可以找出各种 理由说明这种方法不科学，比如同一只母鸡下的蛋硬度可能不一样等等，但是这不影响XX公司的争霸赛，因为他们只是为了吸引大家的眼球，一个个鸡蛋从100 层的高楼上掉下来的时候，这情景还是能吸引很多人驻足观看的，当然，XX公司也绝不会忘记在高楼上挂一条幅，写上“XX公司”的字样–这比赛不过是XX 公司的一个另类广告而已。
勤于思考的小A总是能从一件事情中发现一个数学问题，这件事也不例外。“假如有很多同样硬度的鸡蛋，那么我可以用二分的办法用最少的次数测出鸡蛋 的硬度”，小A对自己的这个结论感到很满意，不过很快麻烦来了，“但是，假如我的鸡蛋不够用呢，比如我只有1个鸡蛋，那么我就不得不从第1层楼开始一层一 层的扔，最坏情况下我要扔100次。如果有2个鸡蛋，那么就从2层楼开始的地方扔……等等，不对，好像应该从1/3的地方开始扔才对，嗯，好像也不一定 啊……3个鸡蛋怎么办，4个，5个，更多呢……”，和往常一样，小A又陷入了一个思维僵局，与其说他是勤于思考，不如说他是喜欢自找麻烦。
好吧，既然麻烦来了，就得有人去解决，小A的麻烦就靠你来解决了：)
时间限制：1000
内存限制：65536
输入
输入包括多组数据，每组数据一行，包含两个正整数n和m(1<=n<=100,1<=m<=10)，其中n表示楼的高度，m表示你现在拥有的鸡蛋个数，这些鸡蛋硬度相同(即它们从同样高的地方掉下来要么都摔碎要么都不碎)，并且小于等于n。你可以假定硬度为x的鸡蛋从高度小于等于x的地方摔无论如何都不会碎(没摔碎的鸡蛋可以继续使用)，而只要从比x高的地方扔必然会碎。 对每组输入数据，你可以假定鸡蛋的硬度在0至n之间，即在n+1层扔鸡蛋一定会碎。
输出
对于每一组输入，输出一个整数，表示使用最优策略在最坏情况下所需要的扔鸡蛋次数。

样例输入
100 1
100 2
样例输出
100
14
提示
最优策略指在最坏情况下所需要的扔鸡蛋次数最少的策略。 如果只有一个鸡蛋，你只能从第一层开始扔，在最坏的情况下，鸡蛋的硬度是100，所以需要扔100次。如果采用其他策略，你可能无法测出鸡蛋的硬度(比如你第一次在第二层的地方扔,结果碎了,这时你不能确定硬度是0还是1)，即在最坏情况下你需要扔无限次，所以第一组数据的答案是100。

这个问题可以使用动态规划来解决，其中状态转移方程是关键。

我们可以定义一个二维数组dp，其中dp[i][j]表示在有i层楼和j个鸡蛋的情况下，使用最优策略在最坏情况下所需要的最少扔鸡蛋次数。

根据题目的要求，对于每个楼层x，我们可以选择在第x层扔鸡蛋或者不扔鸡蛋。如果鸡蛋碎了，我们就需要在前x-1层楼使用j-1个鸡蛋继续进行测试；如果鸡蛋没碎，我们就需要在剩下的i-x层楼使用j个鸡蛋进行测试。因此，状态转移方程可以表示为：

dp[i][j] = min(1 + max(dp[x-1][j-1], dp[i-x][j])), 其中 1 <= x <= i

这个状态转移方程的意义是，对于每个楼层x，我们都尝试从第x层楼扔鸡蛋，并取最坏情况下的最少扔鸡蛋次数。然后在所有可能的x的情况下，选择最小值作为结果。

以下是使用C语言实现的代码：

#include 
#include 

int min(int a, int b) {
    return (a < b) ? a : b;
}

int max(int a, int b) {
    return (a > b) ? a : b;
}

int eggDrop(int n, int m) {
    int dp[101][11];

    for (int i = 0; i <= n; i++) {
        dp[i][0] = 0;  // 没有鸡蛋时，不需要扔
        dp[i][1] = i;  // 只有一个鸡蛋时，最坏情况下需要从第一层开始一层一层扔
    }

    for (int j = 1; j <= m; j++) {
        dp[0][j] = 0;  // 没有楼层时，不需要扔
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 2; j <= m; j++) {
            dp[i][j] = INT_MAX;
            for (int x = 1; x <= i; x++) {
                int res = 1 + max(dp[x-1][j-1], dp[i-x][j]);
                dp[i][j] = min(dp[i][j], res);
            }
        }
    }

    return dp[n][m];
}

int main() {
    int n, m;
    while (scanf("%d %d", &n, &m) != EOF) {
        int result = eggDrop(n, m);
        printf("%d\n", result);
    }

    return 0;
}

在主函数中，我们使用一个循环读取多组输入数据，并调用eggDrop函数计算答案并输出。

第4题：山区建小学

政府在某山区修建了一条道路，恰好穿越总共m个村庄的每个村庄一次，没有回路或交叉，任意两个村庄只能通过这条路来往。已知任意两个相邻的村庄之间的距离为di(为正整数)，其中，0 < i < m。为了提高山区的文化素质，政府又决定从m个村中选择n个村建小学(设 0 < n < = m < 500 )。请根据给定的m、n以及所有相邻村庄的距离，选择在哪些村庄建小学，才使得所有村到最近小学的距离总和最小，计算最小值。
时间限制：24000
内存限制：65536
输入
第1行为m和n，其间用空格间隔 第2行为(m-1) 个整数，依次表示从一端到另一端的相邻村庄的距离，整数之间以空格间隔。 例如 10 3 2 4 6 5 2 4 3 1 3 表示在10个村庄建3所学校。第1个村庄与第2个村庄距离为2，第2个村庄与第3个村庄距离为4，第3个村庄与第4个村庄距离为6，…，第9个村庄到第10个村庄的距离为3。
输出
各村庄到最近学校的距离之和的最小值。
样例输入
10 2
3 1 3 1 1 1 1 1 3
样例输出
18

这个问题可以使用动态规划来解决。我们可以定义一个二维数组dp，其中dp[i][j]表示在有i个村庄并选择了j个村庄建小学的情况下，各村庄到最近学校的距离之和的最小值。

根据题目的要求，对于每个村庄k，我们可以选择在第k个村庄建小学或者不建小学。如果选择在第k个村庄建小学，那么最近学校的位置就是第k个村庄；如果不建小学，那么最近学校的位置就是最近的已建小学。因此，状态转移方程可以表示为：

dp[i][j] = min(dp[k][j-1] + sum(d[k+1:i])), 其中 0 <= k < i

其中，sum(d[k+1:i])表示从第k+1个村庄到第i个村庄的距离之和。

以下是使用C语言实现的代码：

#include 
#include 

#define MAX_VILLAGE 500
#define INF 0x3f3f3f3f

int min(int a, int b) {
    return (a < b) ? a : b;
}

int sum(int arr[], int start, int end) {
    int result = 0;
    for (int i = start; i <= end; i++) {
        result += arr[i];
    }
    return result;
}

int calculateDistance(int m, int n, int distances[]) {
    int dp[MAX_VILLAGE + 1][MAX_VILLAGE + 1];
    int prefixSum[MAX_VILLAGE + 1];

    // 计算前缀和
    prefixSum[0] = 0;
    for (int i = 1; i <= m - 1; i++) {
        prefixSum[i] = prefixSum[i - 1] + distances[i - 1];
    }

    for (int i = 1; i <= m; i++) {
        dp[i][1] = sum(distances, 0, i - 1);  // 只建立一个小学，距离之和为前缀和
        for (int j = 2; j <= n; j++) {
            dp[i][j] = INF;
            for (int k = 0; k < i; k++) {
                dp[i][j] = min(dp[i][j], dp[k][j - 1] + sum(distances, k, i - 1));
            }
        }
    }

    return dp[m][n];
}

int main() {
    int m, n;
    scanf("%d %d", &m, &n);

    int distances[MAX_VILLAGE - 1];
    for (int i = 0; i < m - 1; i++) {
        scanf("%d", &distances[i]);
    }

    int result = calculateDistance(m, n, distances);
    printf("%d\n", result);

    return 0;
}

在主函数中，我们首先读取输入的m和n，然后读取相邻村庄的距离数组。接下来，我们调用calculateDistance函数计算最小的距离之和，并将结果输出。