devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言算法赛——蓝桥杯（省赛试题）_蓝桥杯c语言题目省赛

作者：知新_RL | 2024-07-23 14:30:38

赞

踩

蓝桥杯c语言题目省赛

目录

一、十四届C/C++程序设计C组试题

二、十四届C/C++程序设计B组试题

三、十四届C/C++程序设计A组试题

四、十三届C/C++程序设计C组试题

五、十三届C/C++程序设计B组试题

六、十三届C/C++程序设计A组试题

七、十二届C/C++程序设计C组试题

八、十二届C/C++程序设计B组试题

九、十二届C/C++程序设计A组试题

十、十一届C/C++程序设计C组试题

一、十四届C/C++程序设计C组试题

  1.  
  2. 十四届程序C组试题A
  3.  
  4. #include <stdio.h>
  5. int main() 
  6. {
  7.     long long sum = 0;
  8.     int n = 20230408;
  9.     int i = 0;
  10.  
  11.     // 累加从1到n的所有整数
  12.     for (i = 1; i <= n; i++)
  13.     {
  14.         sum += i;
  15.     }
  16.  
  17.     // 输出结果
  18.     printf("%lld\n", sum);
  19.  
  20.     return 0;
  21. }

  1.  
  2. //十四届程序C组试题B
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include<time.h>
  7.  
  8. // 时间字符串解析为结构体 tm
  9. void parseTime(char* timeString, struct tm* timeStruct) {
  10.     sscanf(timeString, "%d-%d-%d %d:%d:%d",
  11.         &timeStruct->tm_year, &timeStruct->tm_mon, &timeStruct->tm_mday,
  12.         &timeStruct->tm_hour, &timeStruct->tm_min, &timeStruct->tm_sec);
  13.  
  14.     // tm_year表示的是自1900年以来的年数，需要减去1900
  15.     timeStruct->tm_year -= 1900;
  16.     // tm_mon表示的是0-11的月份，需要减去1
  17.     timeStruct->tm_mon -= 1;
  18. }
  19.  
  20. // 每一对相邻的上下班打卡之间的时间差
  21. int calculateTimeDifference(char* time1, char* time2) {
  22.     struct tm start, end;
  23.  
  24.     // 解析时间字符串为结构体 tm
  25.     parseTime(time1, &start);
  26.     parseTime(time2, &end);
  27.  
  28.     // 使用 mktime 将 tm 结构体转换为时间戳
  29.     time_t startTime = mktime(&start);
  30.     time_t endTime = mktime(&end);
  31.  
  32.     // 计算时间差
  33.     return difftime(endTime, startTime);
  34. }
  35.  
  36. int main() {
  37.     // 打卡记录数组
  38.     char* punchRecords[] = {
  39.         "2022-01-01 07:58:02",
  40.         "2022-01-01 12:00:05",
  41.         "2022-01-01 16:01:35",
  42.         "2022-01-02 00:20:05"
  43.     };
  44.  
  45.     int numRecords = sizeof(punchRecords) / sizeof(punchRecords[0]);
  46.  
  47.     // 按照时间顺序对打卡记录进行排序
  48.     for (int i = 0; i < numRecords - 1; i++) {
  49.         for (int j = 0; j < numRecords - i - 1; j++) {
  50.             if (strcmp(punchRecords[j], punchRecords[j + 1]) > 0) {
  51.                 // 交换记录
  52.                 char* temp = punchRecords[j];
  53.                 punchRecords[j] = punchRecords[j + 1];
  54.                 punchRecords[j + 1] = temp;
  55.             }
  56.         }
  57.     }
  58.  
  59.     // 计算总工作时长
  60.     int totalWorkDuration = 0;
  61.     for (int i = 0; i < numRecords - 1; i += 2) {
  62.         totalWorkDuration += calculateTimeDifference(punchRecords[i], punchRecords[i + 1]);
  63.     }
  64.  
  65.     // 输出总工作时长
  66.     printf("小蓝在2022年度的总工作时长是%d秒。\n", totalWorkDuration);
  67.  
  68.     return 0;
  69. }

  1.  
  2. 十四届程序C组试题C
  3.  
  4. #include <stdio.h>
  5. int main() {
  6.     int n; // 事件数量
  7.     scanf("%d", &n);
  8.  
  9.     int A[n], B[n], C[n]; // 存储每个事件中的A、B、C值
  10.     int maxEvents = -1; // 最多发生的事件数量
  11.     int X = 0, Y = 0, Z = 0; // 初始士兵数量
  12.  
  13.     for (int i = 0; i < n; ++i) {
  14.         scanf("%d %d %d", &A[i], &B[i], &C[i]);
  15.  
  16.         // 计算每个国家的士兵数量
  17.         X += A[i];
  18.         Y += B[i];
  19.         Z += C[i];
  20.  
  21.         // 判断是否有国家获胜
  22.         if ((X > Y + Z) || (Y > X + Z) || (Z > X + Y)) {
  23.             // 更新最多发生的事件数量
  24.             maxEvents = i + 1;
  25.         }
  26.     }
  27.  
  28.     printf("%d\n", maxEvents);
  29.  
  30.     return 0;
  31. }

  1. #include <stdio.h>
  2. int maximize_substrings(char* s)
  3. {
  4.     int count = 0;
  5.     int i, n;
  6.  
  7.     // 遍历字符串，从第二个字符开始
  8.     for (i = 1; s[i] != '\0'; ++i)
  9.     {
  10.         // 如果当前位置是'?'，则尽量使其与前一个字符不同
  11.         if (s[i] == '?') {
  12.             s[i] = (s[i - 1] == '1') ? '0' : '1';
  13.         }
  14.  
  15.         // 计算互不重叠的00和11子串的个数
  16.         if (s[i] == s[i - 1])
  17.         {
  18.             count += 1;
  19.         }
  20.     }
  21.  
  22.     return count;
  23. }
  24.  
  25. int main()
  26. {
  27.     char input_str[] = "1?0?1";
  28.     int result = maximize_substrings(input_str);
  29.  
  30.     printf("互不重叠的00和11子串个数：%d\n", result);
  31.  
  32.     return 0;
  33. }

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. // 函数：计算最小翻转次数
  5. int min_flips_to_match(char S[], char T[]) 
  6. {
  7.     int n = strlen(S);
  8.     int flips = 0;
  9.  
  10.     // 从第二个位置到倒数第二个位置进行遍历
  11.     for (int i = 1; i < n - 1; ++i) 
  12.     {
  13.         // 如果当前位置的字符与目标串不同
  14.         if (S[i] != T[i]) 
  15.         {
  16.             // 进行翻转操作
  17.             flips++;
  18.             S[i] = T[i];
  19.             S[i + 1] = (S[i + 1] == '0') ? '1' : '0';
  20.             S[i + 2] = (S[i + 2] == '0') ? '1' : '0';
  21.         }
  22.     }
  23.  
  24.     return flips;
  25. }
  26.  
  27. int main() 
  28. {
  29.     // 示例输入
  30.     char S[] = "01010";
  31.     char T[] = "00000";
  32.  
  33.     // 计算最小翻转次数
  34.     int result = min_flips_to_match(S, T);
  35.  
  36.     // 输出结果
  37.     printf("Minimum flips required: %d\n", result);
  38.  
  39.     return 0;
  40. }

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4.  
  5. #define MOD 998244353
  6.  
  7. // 函数：计算矩阵子矩阵价值的和
  8. int matrixSubmatrixSum(int n, int m, int matrix[n][m]) 
  9. {
  10.     // 预处理，计算每个位置的最大值和最小值
  11.     int maxVal[n][m];
  12.     int minVal[n][m];
  13.  
  14.     for (int i = 0; i < n; ++i) 
  15.     {
  16.         for (int j = 0; j < m; ++j) 
  17.         {
  18.             if (i > 0) 
  19.             {
  20.                 maxVal[i][j] = (maxVal[i][j] > maxVal[i - 1][j]) ? maxVal[i][j] : maxVal[i - 1][j];
  21.                 minVal[i][j] = (minVal[i][j] < minVal[i - 1][j]) ? minVal[i][j] : minVal[i - 1][j];
  22.             }
  23.             if (j > 0) 
  24.             {
  25.                 maxVal[i][j] = (maxVal[i][j] > maxVal[i][j - 1]) ? maxVal[i][j] : maxVal[i][j - 1];
  26.                 minVal[i][j] = (minVal[i][j] < minVal[i][j - 1]) ? minVal[i][j] : minVal[i][j - 1];
  27.             }
  28.             maxVal[i][j] = (maxVal[i][j] > matrix[i][j]) ? maxVal[i][j] : matrix[i][j];
  29.             minVal[i][j] = (minVal[i][j] < matrix[i][j]) ? minVal[i][j] : matrix[i][j];
  30.         }
  31.     }
  32.  
  33.     // 计算答案
  34.     int result = 0;
  35.  
  36.     for (int a = 1; a <= n; ++a) 
  37.     {
  38.         for (int b = 1; b <= m; ++b) 
  39.         {
  40.             for (int i = 0; i + a - 1 < n; ++i) 
  41.             {
  42.                 for (int j = 0; j + b - 1 < m; ++j)
  43.                 {
  44.                     int maxInSubmatrix = maxVal[i + a - 1][j + b - 1];
  45.                     int minInSubmatrix = minVal[i + a - 1][j + b - 1];
  46.                     result = (result + ((long long)maxInSubmatrix * minInSubmatrix) % MOD) % MOD;
  47.                 }
  48.             }
  49.         }
  50.     }
  51.  
  52.     return result;
  53. }
  54.  
  55. int main() 
  56. {
  57.     // 示例输入
  58.     int n = 3, m = 3;
  59.     int matrix[3][3] ={{1, 2, 3},{4, 5, 6},{7, 8, 9}};
  60.  
  61.     // 计算答案
  62.     int result = matrixSubmatrixSum(n, m, matrix);
  63.  
  64.     // 输出结果
  65.     printf("Sum of submatrix values: %d\n", result);
  66.  
  67.     return 0;
  68. }

 

  1. #include <stdio.h>
  2. #include <math.h>
  3.  
  4. #define MOD 998244353
  5.  
  6. // 计算欧拉函数
  7. long long phi(long long n) {
  8.     long long result = n;
  9.     for (long long p = 2; p * p <= n; ++p) {
  10.         if (n % p == 0) {
  11.             while (n % p == 0)
  12.                 n /= p;
  13.             result -= result / p;
  14.         }
  15.     }
  16.     if (n > 1)
  17.         result -= result / n;
  18.     return result % MOD;
  19. }
  20.  
  21. int main() {
  22.     long long a, b;
  23.     scanf("%lld %lld", &a, &b);
  24.  
  25.     // 计算欧拉函数
  26.     long long euler_a = phi(a);
  27.     long long euler_ab = phi((long long)pow(a, b));
  28.  
  29.     // 输出结果对MOD取模的值
  30.     printf("%lld\n", (euler_ab - euler_a + MOD) % MOD);
  31.  
  32.     return 0;
  33. }

  1.  
  2. #include <stdio.h>
  3.  
  4. #define max(a, b) ((a) > (b) ? (a) : (b))
  5.  
  6. int max_xor_difference(int arr[], int n) {
  7.     int prefix_xor_left[100000];
  8.     int prefix_xor_right[100000];
  9.  
  10.     // 计算从左往右的前缀异或和
  11.     prefix_xor_left[0] = arr[0];
  12.     for (int i = 1; i < n; ++i) {
  13.         prefix_xor_left[i] = prefix_xor_left[i - 1] ^ arr[i];
  14.     }
  15.  
  16.     // 计算从右往左的前缀异或和
  17.     prefix_xor_right[n - 1] = arr[n - 1];
  18.     for (int i = n - 2; i >= 0; --i) {
  19.         prefix_xor_right[i] = prefix_xor_right[i + 1] ^ arr[i];
  20.     }
  21.  
  22.     // 计算两个不相交子段内数的异或和的差值的最大值
  23.     int max_difference = 0;
  24.     for (int i = 0; i < n - 1; ++i) {
  25.         max_difference = max(max_difference, max(prefix_xor_left[i], prefix_xor_right[i + 1]));
  26.     }
  27.  
  28.     return max_difference;
  29. }
  30.  
  31. int main() {
  32.     int n;
  33.     printf("Enter the number of elements in the array: ");
  34.     scanf("%d", &n);
  35.  
  36.     int arr[100000];
  37.     printf("Enter the array elements: ");
  38.     for (int i = 0; i < n; ++i) {
  39.         scanf("%d", &arr[i]);
  40.     }
  41.  
  42.     int result = max_xor_difference(arr, n);
  43.  
  44.     printf("Maximum XOR difference of two non-overlapping subarrays: %d\n", result);
  45.  
  46.     return 0;
  47. }

  1. #include <stdio.h>
  2.  
  3. int gcd(int a, int b) {
  4.     while (b != 0) {
  5.         int temp = b;
  6.         b = a % b;
  7.         a = temp;
  8.     }
  9.     return a;
  10. }
  11.  
  12. void find_numbers(int arr[], int n) {
  13.     int i_min = -1, j_min = -1;
  14.  
  15.     for (int i = 0; i < n - 1; ++i) {
  16.         for (int j = i + 1; j < n; ++j) {
  17.             if (gcd(arr[i], arr[j]) > 1) {
  18.                 if (i_min == -1 || i < i_min || (i == i_min && j < j_min)) {
  19.                     i_min = i;
  20.                     j_min = j;
  21.                 }
  22.             }
  23.         }
  24.     }
  25.  
  26.     if (i_min == -1) {
  27.         printf("No such pair found.\n");
  28.     } else {
  29.         printf("Pair with minimum i and j: (%d, %d)\n", i_min + 1, j_min + 1);
  30.     }
  31. }
  32.  
  33. int main() {
  34.     int n;
  35.     printf("Enter the number of elements in the array: ");
  36.     scanf("%d", &n);
  37.  
  38.     int arr[1000];
  39.     printf("Enter the array elements: ");
  40.     for (int i = 0; i < n; ++i) {
  41.         scanf("%d", &arr[i]);
  42.     }
  43.  
  44.     find_numbers(arr, n);
  45.  
  46.     return 0;
  47. }

  1. #include <stdio.h>
  2.  
  3. long long calculate_subtree_size(int m, long long k) {
  4.     long long subtree_size = 1;
  5.  
  6.     // 计算当前结点的深度
  7.     long long depth = 0;
  8.     while (k > 0) {
  9.         k = (k - 1) / m;
  10.         depth++;
  11.     }
  12.  
  13.     // 计算子树的结点数量
  14.     for (long long i = depth - 1; i > 0; --i) {
  15.         subtree_size = subtree_size * m + i;
  16.     }
  17.  
  18.     return subtree_size;
  19. }
  20.  
  21. int main() {
  22.     int m;
  23.     printf("Enter the degree of the tree (m): ");
  24.     scanf("%d", &m);
  25.  
  26.     long long k;
  27.     printf("Enter the node number (k): ");
  28.     scanf("%lld", &k);
  29.  
  30.     long long result = calculate_subtree_size(m, k);
  31.  
  32.     printf("Number of nodes in the subtree corresponding to node %lld: %lld\n", k, result);
  33.  
  34.     return 0;
  35. }

二、十四届C/C++程序设计B组试题

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. int main() {
  5.     char array[] = "5686916124919823647759503875815861830379270588570991944686338516346707827689565614010094809128502533";
  6.     int arraySize = strlen(array);
  7.     char date[9];  // 存储提取的8位子序列
  8.     int uniqueDates = 0;  // 记录不同日期数量
  9.  
  10.     for (int i = 0; i <= arraySize - 8; ++i) {
  11.         // 提取8位子序列
  12.         strncpy(date, array + i, 8);
  13.         date[8] = '\0';  // 添加字符串结束符
  14.  
  15.         // 解析日期
  16.         int year, month, day;
  17.         sscanf(date, "%4d%2d%2d", &year, &month, &day);
  18.  
  19.         // 检查是否为2023年的合法日期
  20.         if (year == 2023 && month >= 1 && month <= 12 && day >= 1 && day <= 31) {
  21.             // 记录合法日期，并避免重复计数
  22.             uniqueDates++;
  23.             i += 7;  // 移动到下一个可能的子序列的起始位置
  24.         }
  25.     }
  26.  
  27.     // 输出结果
  28.     printf("满足条件的不同日期数量为：%d\n", uniqueDates);
  29.  
  30.     return 0;
  31. }

  1. #include <stdio.h>
  2. #include <math.h>
  3.  
  4. // 定义信息熵函数
  5. double entropy_equation(double x) {
  6.     double p0 = x / 23333333;
  7.     double p1 = (23333333 - x) / 23333333;
  8.     double entropy = -(p0 * log2(p0) + p1 * log2(p1));
  9.     return entropy - 11625907.5798;
  10. }
  11.  
  12. // 二分法求解方程
  13. double binary_search() {
  14.     double low = 0.0;
  15.     double high = 23333333;
  16.     double epsilon = 0.000001;  // 精度要求
  17.  
  18.     while (high - low > epsilon) {
  19.         double mid = (low + high) / 2.0;
  20.         double result = entropy_equation(mid);
  21.  
  22.         if (result > 0) {
  23.             high = mid;
  24.         } else {
  25.             low = mid;
  26.         }
  27.     }
  28.  
  29.     return low;
  30. }
  31.  
  32. int main() {
  33.     double zero_count = binary_search();
  34.     printf("0 出现的次数为: %lf\n", zero_count);
  35.  
  36.     return 0;
  37. }

  1.  
  2. #include <stdio.h>
  3.  
  4. // 计算最大公约数的欧几里得算法
  5. int gcd(int a, int b) {
  6.     if (b == 0) {
  7.         return a;
  8.     }
  9.     return gcd(b, a % b);
  10. }
  11.  
  12. // 计算数组中所有元素的最大公约数
  13. int findGCD(int arr[], int n) {
  14.     int result = arr[0];
  15.     for (int i = 1; i < n; i++) {
  16.         result = gcd(result, arr[i]);
  17.     }
  18.     return result;
  19. }
  20.  
  21. int main() {
  22.     int n;
  23.     printf("输入冶炼记录的数量 N: ");
  24.     scanf("%d", &n);
  25.  
  26.     int A[n], B[n];
  27.  
  28.     printf("输入每条记录中的 A 和 B：\n");
  29.     for (int i = 0; i < n; i++) {
  30.         scanf("%d %d", &A[i], &B[i]);
  31.     }
  32.  
  33.     // 计算最小值
  34.     int minV = findGCD(A, n);
  35.  
  36.     // 计算最大值
  37.     int maxV = findGCD(B, n);
  38.  
  39.     printf("转换率V的最小值：%d\n", minV);
  40.     printf("转换率V的最大值：%d\n", maxV);
  41.  
  42.     return 0;
  43. }

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4.  
  5. // 飞机结构体
  6. struct Aircraft 
  7. {
  8.     int arrivalTime;
  9.     int hoverTime;
  10.     int landingTime;
  11. };
  12.  
  13. // 比较函数，用于排序
  14. int compare(const void* a, const void* b) 
  15. {
  16.     return (((struct Aircraft*)a)->arrivalTime + ((struct Aircraft*)a)->hoverTime) -
  17.         (((struct Aircraft*)b)->arrivalTime + ((struct Aircraft*)b)->hoverTime);
  18. }
  19.  
  20. // 判断是否可以全部安全降落的函数
  21. int canLand(struct Aircraft aircraft[], int N) 
  22. {
  23.     qsort(aircraft, N, sizeof(struct Aircraft), compare);
  24.  
  25.     int currentTime = 0;
  26.  
  27.     for (int i = 0; i < N; i++) 
  28.     {
  29.         // 判断是否在时间窗口内降落
  30.         if (currentTime + aircraft[i].landingTime > aircraft[i].arrivalTime + aircraft[i].hoverTime) {
  31.             return 0; // 不能安全降落
  32.         }
  33.  
  34.         // 更新当前时间
  35.         currentTime = (currentTime + aircraft[i].landingTime > aircraft[i].arrivalTime)
  36.             ? currentTime + aircraft[i].landingTime
  37.             : aircraft[i].arrivalTime;
  38.     }
  39.  
  40.     return 1; // 可以安全降落
  41. }
  42.  
  43. int main() 
  44. {
  45.     int N;
  46.     printf("请输入飞机数量 N：");
  47.     scanf("%d", &N);
  48.  
  49.     struct Aircraft* aircraft = (struct Aircraft*)malloc(N * sizeof(struct Aircraft));
  50.  
  51.     // 输入飞机信息
  52.     for (int i = 0; i < N; i++) 
  53.     {
  54.         printf("请输入第 %d 架飞机的到达时刻、盘旋时间和降落时间：", i + 1);
  55.         scanf("%d %d %d", &aircraft[i].arrivalTime, &aircraft[i].hoverTime, &aircraft[i].landingTime);
  56.     }
  57.  
  58.     // 判断是否可以全部安全降落
  59.     if (canLand(aircraft, N)) 
  60.     {
  61.         printf("所有飞机可以全部安全降落。\n");
  62.     }
  63.     else 
  64.     {
  65.         printf("有飞机无法安全降落。\n");
  66.     }
  67.  
  68.     free(aircraft);
  69.     return 0;
  70. }

  1.  
  2. #include <stdio.h>
  3.  
  4. int max(int a, int b) {
  5.     return (a > b) ? a : b;
  6. }
  7.  
  8. int minDeletionsForChain(int arr[], int N) 
  9. {
  10.     int dp[N];
  11.     int result = 0;
  12.  
  13.     for (int i = 0; i < N; i++) {
  14.         dp[i] = 1;
  15.         for (int j = 0; j < i; j++) {
  16.             if (arr[j] % 10 == arr[i] / 10) {
  17.                 dp[i] = max(dp[i], dp[j] + 1);
  18.             }
  19.         }
  20.         result = max(result, dp[i]);
  21.     }
  22.  
  23.     return N - result;
  24. }
  25.  
  26. int main() {
  27.     int N;
  28.     printf("请输入数列的长度 N：");
  29.     scanf("%d", &N);
  30.  
  31.     int arr[N];
  32.     printf("请输入数列 A1, A2, ..., AN：");
  33.     for (int i = 0; i < N; i++) {
  34.         scanf("%d", &arr[i]);
  35.     }
  36.  
  37.     int deletions = minDeletionsForChain(arr, N);
  38.     printf("最少需要删除 %d 个数，使剩下的序列是接龙序列。\n", deletions);
  39.  
  40.     return 0;
  41. }

  1. #include <stdio.h>
  2.  
  3. #define ROW 4
  4. #define COL 5
  5.  
  6. void dfs(char grid[ROW][COL], int i, int j) {
  7.     if (i < 0 || i >= ROW || j < 0 || j >= COL || grid[i][j] == '0') {
  8.         return;
  9.     }
  10.  
  11.     grid[i][j] = '0';  // 标记当前格子为已访问
  12.  
  13.     // 上下左右四个方向进行深度优先搜索
  14.     dfs(grid, i - 1, j);
  15.     dfs(grid, i + 1, j);
  16.     dfs(grid, i, j - 1);
  17.     dfs(grid, i, j + 1);
  18. }
  19.  
  20. int numIslands(char grid[ROW][COL]) 
  21. {
  22.     int count = 0;
  23.  
  24.     for (int i = 0; i < ROW; ++i) {
  25.         for (int j = 0; j < COL; ++j) {
  26.             if (grid[i][j] == '1') {
  27.                 ++count;
  28.                 dfs(grid, i, j);  // 深度优先搜索标记当前岛屿
  29.             }
  30.         }
  31.     }
  32.  
  33.     return count;
  34. }
  35.  
  36. int main() 
  37. {
  38.     char grid[ROW][COL] = {
  39.         {'1', '1', '0', '0', '0'},
  40.         {'1', '1', '0', '0', '0'},
  41.         {'0', '0', '1', '0', '0'},
  42.         {'0', '0', '0', '1', '1'}
  43.     };
  44.  
  45.     int result = numIslands(grid);
  46.     printf("岛屿数量: %d\n", result);
  47.  
  48.     return 0;
  49. }

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. // 计算以c1开头、以c2结尾的子串个数
  5. int countShortenedSubstrings(char S[], char c1, char c2, int K) {
  6.     int n = strlen(S);
  7.     int count = 0;
  8.  
  9.     for (int i = 0; i < n; ++i) {
  10.         if (S[i] == c1) {
  11.             for (int j = i + 1; j < n; ++j) {
  12.                 if (S[j] == c2) {
  13.                     // 计算子串长度
  14.                     int length = j - i + 1;
  15.                     if (length >= K) {
  16.                         // 符合条件，计数器加一
  17.                         count++;
  18.                     }
  19.                 }
  20.             }
  21.         }
  22.     }
  23.  
  24.     return count;
  25. }
  26.  
  27. int main() {
  28.     char S[100];
  29.     char c1, c2;
  30.     int K;
  31.  
  32.     // 读取输入
  33.     printf("Enter the string S: ");
  34.     scanf("%s", S);
  35.     printf("Enter the characters c1 and c2: ");
  36.     scanf(" %c %c", &c1, &c2);
  37.     printf("Enter the value of K: ");
  38.     scanf("%d", &K);
  39.  
  40.     // 计算结果并输出
  41.     int result = countShortenedSubstrings(S, c1, c2, K);
  42.     printf("Number of shortened substrings: %d\n", result);
  43.  
  44.     return 0;
  45. }

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. // 计算以c1开头、以c2结尾的子串个数
  5. int countShortenedSubstrings(char S[], char c1, char c2, int K) {
  6.     int n = strlen(S);
  7.     int count = 0;
  8.  
  9.     for (int i = 0; i < n; ++i) {
  10.         if (S[i] == c1) {
  11.             for (int j = i + 1; j < n; ++j) {
  12.                 if (S[j] == c2) {
  13.                     // 计算子串长度
  14.                     int length = j - i + 1;
  15.                     if (length >= K) {
  16.                         // 符合条件，计数器加一
  17.                         count++;
  18.                     }
  19.                 }
  20.             }
  21.         }
  22.     }
  23.  
  24.     return count;
  25. }
  26.  
  27. int main() {
  28.     char S[100];
  29.     char c1, c2;
  30.     int K;
  31.  
  32.     // 读取输入
  33.     printf("Enter the string S: ");
  34.     scanf("%s", S);
  35.     printf("Enter the characters c1 and c2: ");
  36.     scanf(" %c %c", &c1, &c2);
  37.     printf("Enter the value of K: ");
  38.     scanf("%d", &K);
  39.  
  40.     // 计算结果并输出
  41.     int result = countShortenedSubstrings(S, c1, c2, K);
  42.     printf("Number of shortened substrings: %d\n", result);
  43.  
  44.     return 0;
  45. }

  1. #include <stdio.h>
  2.  
  3. #define MAX_NODES 100
  4.  
  5. int adjacency_list[MAX_NODES][MAX_NODES];
  6. int travel_times[MAX_NODES][MAX_NODES];
  7.  
  8. int dfs(int node, int parent, int skip_node, int n) {
  9.     int total_time = 0;
  10.  
  11.     for (int i = 0; i < n; ++i) {
  12.         if (i != parent && adjacency_list[node][i]) {
  13.             total_time += dfs(i, node, skip_node, n);
  14.         }
  15.     }
  16.  
  17.     // 如果当前节点不是要跳过的节点，累加其摆渡车时间
  18.     if (node != skip_node) {
  19.         total_time += travel_times[node][parent] + travel_times[parent][node];
  20.     }
  21.  
  22.     return total_time;
  23. }
  24.  
  25. int calculate_travel_time(int n, int k, int skip_node) {
  26.     int total_time = 0;
  27.  
  28.     for (int i = 1; i < k; ++i) {
  29.         total_time += dfs(i, -1, skip_node, n);
  30.     }
  31.  
  32.     return total_time;
  33. }
  34.  
  35. int main() {
  36.     int n = 6;
  37.     int k = 4;
  38.     int skip_node = 2;
  39.  
  40.     // 示例邻接列表和摆渡车时间
  41.     int adjacency_list[6][6] = {{0, 1, 1, 0, 0, 0},
  42.                                 {1, 0, 0, 1, 1, 0},
  43.                                 {1, 0, 0, 0, 0, 1},
  44.                                 {0, 1, 0, 0, 0, 0},
  45.                                 {0, 1, 0, 0, 0, 0},
  46.                                 {0, 0, 1, 0, 0, 0}};
  47.  
  48.     int travel_times[6][6] = {{0, 3, 2, 0, 0, 0},
  49.                               {3, 0, 0, 1, 4, 0},
  50.                               {2, 0, 0, 0, 0, 5},
  51.                               {0, 1, 0, 0, 0, 0},
  52.                               {0, 4, 0, 0, 0, 0},
  53.                               {0, 0, 5, 0, 0, 0}};
  54.  
  55.     int result = calculate_travel_time(n, k, skip_node);
  56.     printf("If skip node %d, total travel time: %d\n", skip_node, result);
  57.  
  58.     return 0;
  59. }

  1. #include <stdio.h>
  2. #include <stdbool.h>
  3.  
  4. #define MAX_NODES 1000
  5.  
  6. // 表示树的邻接列表
  7. int adjacency_list[MAX_NODES][MAX_NODES];
  8. // 标记边是否被访问过
  9. bool visited[MAX_NODES][MAX_NODES];
  10. // 结果数组，记录断开的边的编号
  11. int result[MAX_NODES];
  12. // 当前断开的边的编号
  13. int result_index;
  14.  
  15. // 深度优先搜索函数
  16. void dfs(int node, int parent, int a, int b, int n) {
  17.     for (int i = 0; i < n; ++i) {
  18.         if (adjacency_list[node][i] && !visited[node][i]) {
  19.             visited[node][i] = visited[i][node] = true;
  20.  
  21.             // 如果当前边的两个端点分别为a和b，说明这条边需要断开
  22.             if ((node == a && i == b) || (node == b && i == a)) {
  23.                 result[result_index++] = i + 1; // 存储边的编号（从1开始）
  24.             }
  25.  
  26.             dfs(i, node, a, b, n);
  27.         }
  28.     }
  29. }
  30.  
  31. int main() {
  32.     int n, m;
  33.     scanf("%d %d", &n, &m);
  34.  
  35.     // 初始化邻接列表和visited数组
  36.     for (int i = 0; i < n - 1; ++i) {
  37.         int u, v;
  38.         scanf("%d %d", &u, &v);
  39.         adjacency_list[u - 1][v - 1] = adjacency_list[v - 1][u - 1] = 1;
  40.         visited[u - 1][v - 1] = visited[v - 1][u - 1] = false;
  41.     }
  42.  
  43.     // 遍历每个数对，进行DFS判断是否可以断开
  44.     for (int i = 0; i < m; ++i) {
  45.         int a, b;
  46.         scanf("%d %d", &a, &b);
  47.  
  48.         // 重置结果数组和结果索引
  49.         result_index = 0;
  50.  
  51.         // 进行DFS遍历
  52.         dfs(0, -1, a - 1, b - 1, n);
  53.  
  54.         // 如果结果索引为0，说明没有找到需要断开的边
  55.         if (result_index == 0) {
  56.             printf("-1\n");
  57.         } else {
  58.             // 输出断开的边的编号
  59.             for (int j = 0; j < result_index; ++j) {
  60.                 printf("%d ", result[j]);
  61.             }
  62.             printf("\n");
  63.         }
  64.     }
  65.  
  66.     return 0;
  67. }

三、十四届C/C++程序设计A组试题

  1. #include <stdio.h>
  2.  
  3. // 检查一个数字是否是幸运数字的函数
  4. int is_lucky_number(int num) {
  5.     char num_str[20]; // 用于将数字转换为字符串以便处理
  6.     sprintf(num_str, "%d", num);
  7.     int length = strlen(num_str);
  8.  
  9.     // 如果数字的位数为奇数，则不是幸运数字
  10.     if (length % 2 != 0) {
  11.         return 0; // 返回假
  12.     }
  13.  
  14.     int half_length = length / 2;
  15.     int first_half_sum = 0, second_half_sum = 0;
  16.  
  17.     // 计算前半部分数字的和
  18.     for (int i = 0; i < half_length; i++) {
  19.         first_half_sum += num_str[i] - '0'; // 将字符转换为数字
  20.     }
  21.  
  22.     // 计算后半部分数字的和
  23.     for (int i = half_length; i < length; i++) {
  24.         second_half_sum += num_str[i] - '0';
  25.     }
  26.  
  27.     // 判断前半部分和后半部分是否相等
  28.     return first_half_sum == second_half_sum;
  29. }
  30.  
  31. // 计算在给定范围内的幸运数字的数量
  32. int count_lucky_numbers(int start, int end) {
  33.     int count = 0;
  34.  
  35.     // 遍历给定范围内的所有数字
  36.     for (int num = start; num <= end; num++) {
  37.         // 如果是幸运数字，增加计数
  38.         if (is_lucky_number(num)) {
  39.             count++;
  40.         }
  41.     }
  42.  
  43.     return count;
  44. }
  45.  
  46. int main() {
  47.     int start_range = 1;
  48.     int end_range = 100000000;
  49.  
  50.     // 调用函数计算幸运数字的数量
  51.     int result = count_lucky_numbers(start_range, end_range);
  52.  
  53.     // 打印结果
  54.     printf("There are %d lucky numbers between %d and %d.\n", result, start_range, end_range);
  55.  
  56.     return 0;
  57. }

  1. #include <stdio.h>
  2.  
  3. // 定义最大题目数和最大分数
  4. #define MAX_QUESTIONS 30
  5. #define MAX_SCORE 100
  6.  
  7. // 计算小蓝所有可能的答题情况数量的函数
  8. long long count_possible_ways() {
  9.     int target_score = 70;
  10.     int num_questions = 30;
  11.  
  12.     // 初始化动态规划数组
  13.     long long dp[MAX_QUESTIONS + 1][MAX_SCORE + 1] = { 0 };
  14.     dp[0][0] = 1;
  15.  
  16.     // 遍历每一道题目
  17.     for (int i = 1; i <= num_questions; i++) {
  18.         for (int j = 0; j <= target_score; j++) {
  19.             // 如果不答这道题
  20.             dp[i][j] += dp[i - 1][j];
  21.  
  22.             // 如果答对这道题，分数增加10
  23.             if (j >= 10) {
  24.                 dp[i][j] += dp[i - 1][j - 10];
  25.             }
  26.         }
  27.     }
  28.  
  29.     return dp[num_questions][target_score];
  30. }
  31.  
  32. int main() {
  33.     // 调用函数计算小蓝所有可能的答题情况数量
  34.     long long possible_ways = count_possible_ways();
  35.  
  36.     // 打印结果
  37.     printf("小蓝所有可能的答题情况有 %lld 种。\n", possible_ways);
  38.  
  39.     return 0;
  40. }

  1. #include <stdio.h>
  2. #include <math.h>
  3.  
  4. // 判断是否存在整数y和z，使得x = y^2 - z^2
  5. int has_yz(int x) {
  6.     int limit = (int)sqrt(x);
  7.     
  8.     // 遍历y的可能取值
  9.     for (int y = 1; y <= limit; y++) {
  10.         int z_square = y * y - x;
  11.  
  12.         // 如果z的平方为非负数且是完全平方数
  13.         if (z_square >= 0 && sqrt(z_square) == (int)sqrt(z_square)) {
  14.             return 1; // 存在满足条件的y和z
  15.         }
  16.     }
  17.  
  18.     return 0; // 不存在满足条件的y和z
  19. }
  20.  
  21. // 计算满足条件的x的数量
  22. int count_x(int L, int R) {
  23.     int count = 0;
  24.  
  25.     // 遍历给定范围内的所有x
  26.     for (int x = L; x <= R; x++) {
  27.         // 如果存在整数y和z，使得x = y^2 - z^2
  28.         if (has_yz(x)) {
  29.             count++;
  30.         }
  31.     }
  32.  
  33.     return count;
  34. }
  35.  
  36. int main() {
  37.     int L, R;
  38.  
  39.     // 输入L和R的值
  40.     printf("Enter the values of L and R: ");
  41.     scanf("%d %d", &L, &R);
  42.  
  43.     // 调用函数计算满足条件的x的数量
  44.     int result = count_x(L, R);
  45.  
  46.     // 输出结果
  47.     printf("There are %d numbers x in the range [%d, %d] satisfying the condition.\n", result, L, R);
  48.  
  49.     return 0;
  50. }

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. // 计算满足条件的不同子串选择方案的数量
  5. int count_substring_choices(char num_str[]) {
  6.     int n = strlen(num_str);
  7.     int num = atoi(num_str);
  8.     int choices = 0;  // 记录不同的选择方案数量
  9.     char substring[20];  // 假设数字最大长度为20
  10.  
  11.     // 从左往右遍历，找到第一个递减的位置
  12.     for (int i = 0; i < n - 1; i++) {
  13.         if (num_str[i] > num_str[i + 1]) {
  14.             // 在递减位置及其左侧选择子串
  15.             strncpy(substring, num_str, i + 1);
  16.             substring[i + 1] = '\0';  // 添加字符串结束符
  17.             printf("选择子串: %s\n", substring);
  18.             choices++;
  19.         }
  20.     }
  21.  
  22.     return choices;
  23. }
  24.  
  25. int main() {
  26.     char num_str[20];  // 假设数字最大长度为20
  27.  
  28.     // 输入数字字符串
  29.     printf("请输入数字字符串: ");
  30.     scanf("%s", num_str);
  31.  
  32.     // 调用函数计算满足条件的不同子串选择方案数量
  33.     int result = count_substring_choices(num_str);
  34.  
  35.     // 输出结果
  36.     printf("不同的子串选择方案数: %d\n", result);
  37.  
  38.     return 0;
  39. }

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. #define MAX_COLORS 1001
  5.  
  6. // 结点的定义
  7. struct TreeNode {
  8.     int color;
  9.     struct TreeNode* children[1001];
  10.     int num_children;
  11. };
  12.  
  13. // 创建一个新的结点
  14. struct TreeNode* createNode(int color) {
  15.     struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
  16.     node->color = color;
  17.     node->num_children = 0;
  18.     return node;
  19. }
  20.  
  21. // DFS遍历并统计子树颜色个数
  22. void dfs(struct TreeNode* root, int color_count[MAX_COLORS], int* balanced_trees) {
  23.     int i;
  24.     color_count[root->color]++;
  25.  
  26.     // 递归地处理子结点
  27.     for (i = 0; i < root->num_children; i++) {
  28.         dfs(root->children[i], color_count, balanced_trees);
  29.     }
  30.  
  31.     // 检查当前子树是否是颜色平衡树
  32.     int min_count = color_count[root->color];
  33.     int max_count = color_count[root->color];
  34.     for (i = 0; i < MAX_COLORS; i++) {
  35.         if (color_count[i] > 0) {
  36.             if (color_count[i] < min_count) min_count = color_count[i];
  37.             if (color_count[i] > max_count) max_count = color_count[i];
  38.         }
  39.     }
  40.  
  41.     if (max_count == min_count) (*balanced_trees)++;
  42.     color_count[root->color]--;
  43. }
  44.  
  45. int main() {
  46.     int n, i;
  47.     int color_count[MAX_COLORS] = {0}; // 记录每种颜色的个数
  48.     int balanced_trees = 0; // 颜色平衡子树的数量
  49.  
  50.     // 读取结点个数
  51.     scanf("%d", &n);
  52.  
  53.     struct TreeNode* nodes[n + 1]; // 结点数组
  54.     // 初始化结点数组
  55.     for (i = 1; i <= n; i++) {
  56.         int color;
  57.         scanf("%d", &color);
  58.         nodes[i] = createNode(color);
  59.     }
  60.  
  61.     // 构建树
  62.     for (i = 2; i <= n; i++) {
  63.         int parent;
  64.         scanf("%d", &parent);
  65.         nodes[parent]->children[nodes[parent]->num_children++] = nodes[i];
  66.     }
  67.  
  68.     // DFS遍历树并统计颜色平衡子树的数量
  69.     dfs(nodes[1], color_count, &balanced_trees);
  70.  
  71.     printf("%d\n", balanced_trees);
  72.  
  73.     return 0;
  74. }

  1. #include <stdio.h>
  2.  
  3. // 定义最大瓜的数量和最大重量
  4. #define MAX_N 100
  5. #define MAX_WEIGHT 1000
  6.  
  7. // 动态规划函数，返回最少需要劈的瓜的数量
  8. int minimumCutting(int weights[], int n, int targetWeight) {
  9.     // 定义动态规划数组
  10.     int dp[MAX_N + 1][MAX_WEIGHT + 1] = {0};
  11.  
  12.     // 初始化动态规划数组
  13.     dp[0][0] = 1;
  14.  
  15.     // 填充动态规划数组
  16.     for (int i = 1; i <= n; i++) {
  17.         for (int j = 0; j <= targetWeight; j++) {
  18.             dp[i][j] = dp[i - 1][j];
  19.             if (j >= weights[i - 1]) {
  20.                 dp[i][j] |= dp[i - 1][j - weights[i - 1]];
  21.             }
  22.         }
  23.     }
  24.  
  25.     // 如果无法得到总重为targetWeight的瓜，返回-1
  26.     if (dp[n][targetWeight] == 0) {
  27.         return -1;
  28.     }
  29.  
  30.     // 回溯找到最少需要劈的瓜的数量
  31.     int cuts = 0;
  32.     int currentWeight = targetWeight;
  33.     int currentMelon = n;
  34.  
  35.     while (currentWeight > 0 && currentMelon > 0) {
  36.         if (dp[currentMelon - 1][currentWeight]) {
  37.             currentMelon--;
  38.         } else {
  39.             currentWeight -= weights[currentMelon - 1];
  40.             cuts++;
  41.         }
  42.     }
  43.  
  44.     return cuts;
  45. }
  46.  
  47. int main() {
  48.     // 示例用法
  49.     int weights[] = {2, 3, 5, 7};
  50.     int n = sizeof(weights) / sizeof(weights[0]);
  51.     int target = 10;
  52.  
  53.     int result = minimumCutting(weights, n, target);
  54.     printf("%d\n", result);  // 输出 2
  55.  
  56.     return 0;
  57. }

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <limits.h>
  4.  
  5. // 定义无穷大值
  6. #define INF INT_MAX
  7.  
  8. // 定义设备和连接的结构体
  9. struct Edge {
  10.     int to;
  11.     int weight;
  12. };
  13.  
  14. // 定义图的结构体
  15. struct Graph {
  16.     int vertices;           // 设备的数量
  17.     struct Edge** adjMatrix; // 邻接矩阵表示的图
  18. };
  19.  
  20. // 初始化图
  21. struct Graph* initializeGraph(int vertices) {
  22.     struct Graph* graph = (struct Graph*)malloc(sizeof(struct Graph));
  23.     graph->vertices = vertices;
  24.  
  25.     // 为邻接矩阵分配内存
  26.     graph->adjMatrix = (struct Edge**)malloc(vertices * sizeof(struct Edge*));
  27.     for (int i = 0; i < vertices; ++i) {
  28.         graph->adjMatrix[i] = (struct Edge*)malloc(vertices * sizeof(struct Edge));
  29.     }
  30.  
  31.     // 初始化邻接矩阵
  32.     for (int i = 0; i < vertices; ++i) {
  33.         for (int j = 0; j < vertices; ++j) {
  34.             graph->adjMatrix[i][j].to = -1; // 表示没有连接
  35.             graph->adjMatrix[i][j].weight = INF; // 初始化为无穷大
  36.         }
  37.     }
  38.  
  39.     return graph;
  40. }
  41.  
  42. // 添加无向边到图
  43. void addEdge(struct Graph* graph, int from, int to, int weight) {
  44.     graph->adjMatrix[from][to].to = to;
  45.     graph->adjMatrix[from][to].weight = weight;
  46.  
  47.     // 由于是无向图，需要添加反向边
  48.     graph->adjMatrix[to][from].to = from;
  49.     graph->adjMatrix[to][from].weight = weight;
  50. }
  51.  
  52. // Dijkstra算法计算从源节点到所有其他节点的最短路径
  53. void dijkstra(const struct Graph* graph, int source, int* dist) {
  54.     int visited[graph->vertices];
  55.  
  56.     // 初始化距离数组和访问数组
  57.     for (int i = 0; i < graph->vertices; ++i) {
  58.         dist[i] = INF;
  59.         visited[i] = 0;
  60.     }
  61.  
  62.     dist[source] = 0; // 源节点到自身的距离为0
  63.  
  64.     for (int count = 0; count < graph->vertices - 1; ++count) {
  65.         int u = -1;
  66.  
  67.         // 选择未访问的节点中距离最小的节点
  68.         for (int i = 0; i < graph->vertices; ++i) {
  69.             if (!visited[i] && (u == -1 || dist[i] < dist[u]))
  70.                 u = i;
  71.         }
  72.  
  73.         visited[u] = 1; // 标记节点为已访问
  74.  
  75.         // 更新未访问节点的距离
  76.         for (int v = 0; v < graph->vertices; ++v) {
  77.             if (!visited[v] && graph->adjMatrix[u][v].to != -1 &&
  78.                 dist[u] + graph->adjMatrix[u][v].weight < dist[v]) {
  79.                 dist[v] = dist[u] + graph->adjMatrix[u][v].weight;
  80.             }
  81.         }
  82.     }
  83. }
  84.  
  85. // 计算两个设备之间的通信稳定性
  86. int calculateStability(const int* dist, int destination) {
  87.     if (dist[destination] == INF) {
  88.         return -1; // 如果没有路径，则返回-1
  89.     }
  90.  
  91.     return dist[destination];
  92. }
  93.  
  94. int main() {
  95.     int n, m;
  96.     scanf("%d %d", &n, &m); // 输入设备数量和连接数量
  97.  
  98.     struct Graph* graph = initializeGraph(n);
  99.  
  100.     // 输入物理连接的信息
  101.     for (int i = 0; i < m; ++i) {
  102.         int u, v, w;
  103.         scanf("%d %d %d", &u, &v, &w);
  104.         addEdge(graph, u - 1, v - 1, w); // 设备编号从1开始，转换为0开始的索引
  105.     }
  106.  
  107.     int q;
  108.     scanf("%d", &q); // 查询数量
  109.  
  110.     for (int i = 0; i < q; ++i) {
  111.         int x, y;
  112.         scanf("%d %d", &x, &y);
  113.  
  114.         int* distFromX = (int*)malloc(n * sizeof(int));
  115.         dijkstra(graph, x - 1, distFromX);
  116.         int stability = calculateStability(distFromX, y - 1);
  117.  
  118.         printf("%d\n", stability);
  119.  
  120.         free(distFromX);
  121.     }
  122.  
  123.     // 释放内存
  124.     for (int i = 0; i < n; ++i) {
  125.         free(graph->adjMatrix[i]);
  126.     }
  127.     free(graph->adjMatrix);
  128.     free(graph);
  129.  
  130.     return 0;
  131. }

  1. #include <stdio.h>
  2.  
  3. // 计算数组中每个子段的异或和并求和
  4. int main() {
  5.     int n;
  6.     scanf("%d", &n); // 输入数组长度
  7.  
  8.     int A[n];
  9.     for (int i = 0; i < n; ++i) {
  10.         scanf("%d", &A[i]); // 输入数组元素
  11.     }
  12.  
  13.     int result = 0;
  14.  
  15.     // 计算每个子段的异或和并求和
  16.     for (int i = 0; i < n; ++i) {
  17.         int XOR_sum = 0;
  18.         for (int j = i; j < n; ++j) {
  19.             XOR_sum ^= A[j]; // 计算子段的异或和
  20.             result += XOR_sum; // 将每个子段的异或和累加到结果中
  21.         }
  22.     }
  23.  
  24.     printf("%d\n", result);
  25.  
  26.     return 0;
  27. }

  1. #include <stdio.h>
  2.  
  3. #define N 4
  4. #define M 4
  5.  
  6. // 检查当前位置是否合法
  7. int is_valid(int board[N][M], int i, int j, int target_color) {
  8.     // 检查是否越界
  9.     if (i < 0 || i >= N || j < 0 || j >= M) {
  10.         return 0;
  11.     }
  12.  
  13.     // 检查当前位置是否已填充
  14.     if (board[i][j] != -1) {
  15.         return 0;
  16.     }
  17.  
  18.     // 统计周围黑色方格的数量
  19.     int count_black = 0;
  20.     for (int x = i - 1; x <= i + 1; x++) {
  21.         for (int y = j - 1; y <= j + 1; y++) {
  22.             if (x >= 0 && x < N && y >= 0 && y < M && board[x][y] == 1) {
  23.                 count_black++;
  24.             }
  25.         }
  26.     }
  27.  
  28.     // 检查是否符合数字约束
  29.     return count_black == target_color;
  30. }
  31.  
  32. // 填充周围的方格
  33. void fill_pixels(int board[N][M], int i, int j, int color) {
  34.     if (i < 0 || i >= N || j < 0 || j >= M || board[i][j] != -1) {
  35.         return;
  36.     }
  37.  
  38.     board[i][j] = color;
  39.  
  40.     // 递归填充周围的方格
  41.     fill_pixels(board, i - 1, j, color);
  42.     fill_pixels(board, i + 1, j, color);
  43.     fill_pixels(board, i, j - 1, color);
  44.     fill_pixels(board, i, j + 1, color);
  45. }
  46.  
  47. // 解决像素放置问题
  48. void solve_puzzle(int board[N][M]) {
  49.     for (int i = 0; i < N; i++) {
  50.         for (int j = 0; j < M; j++) {
  51.             if (board[i][j] != -1) {
  52.                 // 如果当前方格有数字约束，则进行DFS填充
  53.                 if (is_valid(board, i, j, board[i][j])) {
  54.                     fill_pixels(board, i, j, 1);
  55.                 } else {
  56.                     fill_pixels(board, i, j, 0);
  57.                 }
  58.             }
  59.         }
  60.     }
  61. }
  62.  
  63. int main() {
  64.     int initial_board[N][M] = {
  65.         {-1,  2, -1, -1},
  66.         {-1, -1,  3, -1},
  67.         { 4, -1,  0, -1},
  68.         {-1, -1, -1, -1}
  69.     };
  70.  
  71.     // 解决问题
  72.     solve_puzzle(initial_board);
  73.  
  74.     // 打印填充后的棋盘
  75.     for (int i = 0; i < N; i++) {
  76.         for (int j = 0; j < M; j++) {
  77.             printf("%d ", initial_board[i][j]);
  78.         }
  79.         printf("\n");
  80.     }
  81.  
  82.     return 0;
  83. }

  1. #include <stdio.h>
  2.  
  3. // 函数声明
  4. int min_operations(int n);
  5.  
  6. int main() {
  7.     // 例如，假设有10个硬币
  8.     int n = 10;
  9.  
  10.     // 调用函数计算最少需要多少次操作
  11.     int result = min_operations(n);
  12.  
  13.     // 打印结果
  14.     printf("最少需要 %d 次操作\n", result);
  15.  
  16.     return 0;
  17. }
  18.  
  19. // 求最少需要多少次操作使所有硬币朝上
  20. int min_operations(int n) {
  21.     int count = 0;  // 记录操作次数
  22.  
  23.     // 从第2个硬币开始，依次判断每个位置的硬币朝上还是朝下
  24.     for (int i = 2; i <= n; i++) {
  25.         // 如果当前位置的硬币朝下，则需要翻转
  26.         if (n % i == 0) {
  27.             count++;  // 记录操作次数增加
  28.         }
  29.     }
  30.  
  31.     return count;
  32. }

四、十三届C/C++程序设计C组试题

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. // 比较函数用于qsort
  6. int compareChars(const void *a, const void *b) {
  7.     return (*(char *)a - *(char *)b);
  8. }
  9.  
  10. int main() {
  11.     // 原始字符串
  12.     char originalString[] = "WHERETHEREISAWILLTHEREISAWAY";
  13.  
  14.     // 获取字符串长度
  15.     int length = strlen(originalString);
  16.  
  17.     // 使用qsort按字母表顺序排序字符串
  18.     qsort(originalString, length, sizeof(char), compareChars);
  19.  
  20.     // 输出排序后的字符串
  21.     printf("排列之后的字符串：%s\n", originalString);
  22.  
  23.     return 0;
  24. }

  1. #include <stdio.h>
  2.  
  3. int isInterestingTime(int year, int month, int day, int hour, int minute) {
  4.     // 将年份、月日、时分拼接成一个数字
  5.     int combinedNumber = year * 1000000 + month * 10000 + day * 100 + hour * 1 + minute * 0.01;
  6.  
  7.     // 统计数字2和数字0的个数
  8.     int count2 = 0, count0 = 0;
  9.     while (combinedNumber > 0) {
  10.         int digit = combinedNumber % 10;
  11.         if (digit == 2) {
  12.             count2++;
  13.         } else if (digit == 0) {
  14.             count0++;
  15.         }
  16.         combinedNumber /= 10;
  17.     }
  18.  
  19.     // 检查是否符合条件
  20.     return count2 == 3 && count0 == 1;
  21. }
  22.  
  23. int main() {
  24.     int count = 0;
  25.  
  26.     // 遍历年份
  27.     for (int year = 1000; year <= 9999; year++) {
  28.         // 遍历月份
  29.         for (int month = 1; month <= 12; month++) {
  30.             // 遍历日期
  31.             for (int day = 1; day <= 31; day++) {
  32.                 // 遍历小时
  33.                 for (int hour = 0; hour <= 23; hour++) {
  34.                     // 遍历分钟
  35.                     for (int minute = 0; minute <= 59; minute++) {
  36.                         // 检查是否符合条件
  37.                         if (isInterestingTime(year, month, day, hour, minute)) {
  38.                             count++;
  39.                         }
  40.                     }
  41.                 }
  42.             }
  43.         }
  44.     }
  45.  
  46.     printf("符合条件的时间总数：%d\n", count);
  47.  
  48.     return 0;
  49. }

  1. #include <stdio.h>
  2.  
  3. void getPaperSize(const char *paperName, int *width, int *height) {
  4.     // 解析纸张名称
  5.     char sizeChar;
  6.     int foldCount;
  7.     sscanf(paperName, "A%c%d", &sizeChar, &foldCount);
  8.  
  9.     // 根据A纸张的尺寸计算大小
  10.     *width = 1189;
  11.     *height = 841;
  12.     for (int i = 0; i < foldCount; i++) {
  13.         if (*width > *height) {
  14.             *width /= 2;
  15.         } else {
  16.             *height /= 2;
  17.         }
  18.     }
  19. }
  20.  
  21. int main() {
  22.     char paperName[10];
  23.     printf("输入纸张名称（例如：A0, A1, A2）: ");
  24.     scanf("%s", paperName);
  25.  
  26.     int width, height;
  27.     getPaperSize(paperName, &width, &height);
  28.  
  29.     printf("%s纸张的大小为：%dmm x %dmm\n", paperName, width, height);
  30.  
  31.     return 0;
  32. }

  1. #include <stdio.h>
  2.  
  3. long long calculate_sum(int arr[], int n) {
  4.     long long S = 0;
  5.  
  6.     for (int i = 0; i < n; i++) {
  7.         for (int j = i + 1; j < n; j++) {
  8.             S += (long long)arr[i] * arr[j];
  9.         }
  10.     }
  11.  
  12.     return S;
  13. }
  14.  
  15. int main() {
  16.     // 替换这里的实际整数值和数组大小
  17.     int numbers[] = {a1, a2, /*...*/, an};
  18.     int size = sizeof(numbers) / sizeof(numbers[0]);
  19.  
  20.     long long result = calculate_sum(numbers, size);
  21.  
  22.     printf("The sum is: %lld\n", result);
  23.  
  24.     return 0;
  25. }

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. // 计算数字的数位之和
  5. int digitSum(int num) {
  6.     int sum = 0;
  7.     while (num > 0) {
  8.         sum += num % 10;
  9.         num /= 10;
  10.     }
  11.     return sum;
  12. }
  13.  
  14. // 比较两个数字，按照问题描述中的规则进行比较
  15. int compare(const void *a, const void *b) {
  16.     int digitSumA = digitSum(*(int *)a);
  17.     int digitSumB = digitSum(*(int *)b);
  18.  
  19.     if (digitSumA != digitSumB) {
  20.         return digitSumA - digitSumB;
  21.     } else {
  22.         return *(int *)a - *(int *)b;
  23.     }
  24. }
  25.  
  26. // 找到排序后的第m个元素
  27. int findMthElement(int n, int m) {
  28.     int *numbers = (int *)malloc(n * sizeof(int));
  29.  
  30.     // 初始化数组
  31.     for (int i = 0; i < n; i++) {
  32.         numbers[i] = i + 1;
  33.     }
  34.  
  35.     // 使用qsort进行排序，使用自定义的比较函数
  36.     qsort(numbers, n, sizeof(int), compare);
  37.  
  38.     // 排序后的第m个元素
  39.     int result = numbers[m - 1];
  40.  
  41.     free(numbers);  // 释放动态分配的内存
  42.  
  43.     return result;
  44. }
  45.  
  46. int main() {
  47.     // 替换这里的实际整数值
  48.     int n = 100; // 假设排序范围是1到100
  49.     int m = 10;  // 找排序后的第10个元素
  50.  
  51.     int result = findMthElement(n, m);
  52.  
  53.     printf("The %dth element after sorting is: %d\n", m, result);
  54.  
  55.     return 0;
  56. }

  1. #include <stdio.h>
  2. #include <stdbool.h>
  3.  
  4. #define MAX_N 100000
  5.  
  6. int prefixXor[MAX_N + 1];
  7.  
  8. // 计算前缀异或数组
  9. void computePrefixXor(int arr[], int n) {
  10.     prefixXor[0] = 0;
  11.     for (int i = 1; i <= n; i++) {
  12.         prefixXor[i] = prefixXor[i - 1] ^ arr[i - 1];
  13.     }
  14. }
  15.  
  16. // 判断是否存在异或等于 x 的两个数
  17. bool hasXorPair(int l, int r, int x) {
  18.     return (prefixXor[r] ^ prefixXor[l - 1]) == x;
  19. }
  20.  
  21. // 查询阶段
  22. bool query(int arr[], int n, int l, int x) {
  23.     for (int r = 1; r <= n; r++) {
  24.         if (hasXorPair(l, r, x)) {
  25.             return true;
  26.         }
  27.     }
  28.     return false;
  29. }
  30.  
  31. int main() {
  32.     int n, m;
  33.     scanf("%d %d", &n, &m);
  34.  
  35.     int arr[MAX_N];
  36.     for (int i = 0; i < n; i++) {
  37.         scanf("%d", &arr[i]);
  38.     }
  39.  
  40.     // 预处理阶段
  41.     computePrefixXor(arr, n);
  42.  
  43.     // 查询阶段
  44.     for (int i = 0; i < m; i++) {
  45.         int l, x;
  46.         scanf("%d %d", &l, &x);
  47.  
  48.         if (query(arr, n, l, x)) {
  49.             printf("YES\n");
  50.         } else {
  51.             printf("NO\n");
  52.         }
  53.     }
  54.  
  55.     return 0;
  56. }

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. #define MAX_LEN 100
  5.  
  6. // 删除边缘字符的函数
  7. void removeEdgeChars(char s[]) {
  8.     int len = strlen(s);
  9.     int i, j;
  10.  
  11.     for (i = 0; i < len; i++) {
  12.         // 检查当前字符是否为边缘字符
  13.         if (i - 1 >= 0 && i + 1 < len && s[i] != s[i - 1] && s[i] != s[i + 1]) {
  14.             // 删除当前边缘字符
  15.             for (j = i; j < len - 1; j++) {
  16.                 s[j] = s[j + 1];
  17.             }
  18.             s[len - 1] = '\0';
  19.             len--;
  20.             i--; // 回退一步，重新检查当前位置
  21.         }
  22.     }
  23. }
  24.  
  25. int main() {
  26.     char s[MAX_LEN];
  27.     scanf("%s", s);
  28.  
  29.     // 进行24次操作
  30.     for (int i = 0; i < 24; i++) {
  31.         removeEdgeChars(s);
  32.     }
  33.  
  34.     if (strlen(s) == 0) {
  35.         printf("EMPTY\n");
  36.     } else {
  37.         printf("%s\n", s);
  38.     }
  39.  
  40.     return 0;
  41. }

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. // 比较函数用于排序
  5. int compare(const void *a, const void *b) {
  6.     return (*(int *)b - *(int *)a);
  7. }
  8.  
  9. // 计算查询结果的总和
  10. long long calculateSum(int arr[], int n, int queries[][2], int numQueries) {
  11.     long long sum = 0;
  12.  
  13.     // 计算原始数组的和
  14.     for (int i = 0; i < n; i++) {
  15.         sum += arr[i];
  16.     }
  17.  
  18.     // 遍历每个查询范围
  19.     for (int i = 0; i < numQueries; i++) {
  20.         int L = queries[i][0];
  21.         int R = queries[i][1];
  22.         
  23.         // 将查询范围内的元素设置为当前数组中的最大值
  24.         for (int j = L - 1; j < R; j++) {
  25.             sum += (arr[j] - arr[0]);  // 增加差值
  26.         }
  27.     }
  28.  
  29.     return sum;
  30. }
  31.  
  32. int main() {
  33.     int n, numQueries;
  34.     scanf("%d %d", &n, &numQueries);
  35.  
  36.     int arr[n];
  37.     for (int i = 0; i < n; i++) {
  38.         scanf("%d", &arr[i]);
  39.     }
  40.  
  41.     // 对数组进行排序
  42.     qsort(arr, n, sizeof(int), compare);
  43.  
  44.     int queries[numQueries][2];
  45.     for (int i = 0; i < numQueries; i++) {
  46.         scanf("%d %d", &queries[i][0], &queries[i][1]);
  47.     }
  48.  
  49.     // 计算查询结果的总和
  50.     long long result = calculateSum(arr, n, queries, numQueries);
  51.  
  52.     printf("%lld\n", result);
  53.  
  54.     return 0;
  55. }

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <math.h>
  4.  
  5. // 技能结构体
  6. typedef struct {
  7.     int A;
  8.     int B;
  9. } Skill;
  10.  
  11. // 比较函数用于排序技能
  12. int compare_skills(const void *a, const void *b) {
  13.     return ((Skill*)b)->A - ((Skill*)a)->A;
  14. }
  15.  
  16. // 计算最大攻击力提升
  17. int max_attack_increase(int N, int M, Skill skills[]) {
  18.     // 按攻击力提升排序
  19.     qsort(skills, N, sizeof(Skill), compare_skills);
  20.  
  21.     int total_attack_increase = 0;
  22.     for (int i = 0; i < N; ++i) {
  23.         int max_upgrades = ceil((double)skills[i].A / skills[i].B);
  24.         int upgrades = fmin(max_upgrades, M);
  25.         total_attack_increase += upgrades * skills[i].A;
  26.         M -= upgrades;
  27.     }
  28.  
  29.     return total_attack_increase;
  30. }
  31.  
  32. int main() {
  33.     // 示例输入
  34.     int N = 3;
  35.     int M = 5;
  36.     Skill skills[] = {{10, 2}, {7, 1}, {5, 1}};
  37.  
  38.     // 计算最大攻击力提升
  39.     int result = max_attack_increase(N, M, skills);
  40.  
  41.     // 输出结果
  42.     printf("最多可以提高的攻击力: %d\n", result);
  43.  
  44.     return 0;
  45. }

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. // 哈希表节点
  5. typedef struct Node {
  6.     int value;
  7.     int count;
  8.     struct Node* next;
  9. } Node;
  10.  
  11. // 哈希表
  12. typedef struct {
  13.     Node** table;
  14.     int size;
  15. } HashMap;
  16.  
  17. // 初始化哈希表
  18. HashMap* createHashMap(int size) {
  19.     HashMap* map = (HashMap*)malloc(sizeof(HashMap));
  20.     map->size = size;
  21.     map->table = (Node**)malloc(sizeof(Node*) * size);
  22.  
  23.     for (int i = 0; i < size; ++i) {
  24.         map->table[i] = NULL;
  25.     }
  26.  
  27.     return map;
  28. }
  29.  
  30. // 插入哈希表节点
  31. void insertHashMap(HashMap* map, int value) {
  32.     int index = abs(value) % map->size;
  33.  
  34.     Node* newNode = (Node*)malloc(sizeof(Node));
  35.     newNode->value = value;
  36.     newNode->count = 1;
  37.     newNode->next = map->table[index];
  38.     map->table[index] = newNode;
  39. }
  40.  
  41. // 查询哈希表节点
  42. int queryHashMap(HashMap* map, int value) {
  43.     int index = abs(value) % map->size;
  44.     Node* current = map->table[index];
  45.  
  46.     while (current != NULL) {
  47.         if (current->value == value) {
  48.             return current->count;
  49.         }
  50.         current = current->next;
  51.     }
  52.  
  53.     return 0;
  54. }
  55.  
  56. // 计算区间内出现ki次的数的数量
  57. int countOccurrences(int* prefixSum, int left, int right, HashMap* map, int k) {
  58.     if (left > right) {
  59.         return 0;
  60.     }
  61.  
  62.     int count = 0;
  63.     if (left == 0) {
  64.         count = queryHashMap(map, prefixSum[right]);
  65.     } else {
  66.         count = queryHashMap(map, prefixSum[right] - prefixSum[left - 1]);
  67.     }
  68.  
  69.     return count == k ? 1 : 0;
  70. }
  71.  
  72. int main() {
  73.     int n = 6;
  74.     int A[] = {1, 2, 1, 2, 3, 1};
  75.  
  76.     // 计算前缀和
  77.     int* prefixSum = (int*)malloc(sizeof(int) * n);
  78.     prefixSum[0] = A[0];
  79.     for (int i = 1; i < n; ++i) {
  80.         prefixSum[i] = prefixSum[i - 1] + A[i];
  81.     }
  82.  
  83.     // 构建哈希表
  84.     HashMap* map = createHashMap(n);
  85.  
  86.     // 插入前缀和到哈希表
  87.     for (int i = 0; i < n; ++i) {
  88.         insertHashMap(map, prefixSum[i]);
  89.     }
  90.  
  91.     // 示例查询
  92.     int queries[][3] = {{0, 2, 2}, {1, 4, 1}, {2, 5, 1}};
  93.  
  94.     // 处理查询
  95.     for (int i = 0; i < 3; ++i) {
  96.         int left = queries[i][0];
  97.         int right = queries[i][1];
  98.         int k = queries[i][2];
  99.  
  100.         int result = countOccurrences(prefixSum, left, right, map, k);
  101.         printf("在区间[%d, %d]内出现%d次的数有%d个\n", left, right, k, result);
  102.     }
  103.  
  104.     // 释放内存
  105.     free(prefixSum);
  106.     free(map->table);
  107.     free(map);
  108.  
  109.     return 0;
  110. }

五、十三届C/C++程序设计B组试题

六、十三届C/C++程序设计A组试题

七、十二届C/C++程序设计C组试题

八、十二届C/C++程序设计B组试题

九、十二届C/C++程序设计A组试题

十、十一届C/C++程序设计C组试题

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/870299
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号