CCF-CSP历年真题答案1，2

本文代码主要来自up主圣斗士-DS-ALGO对历年真题的讲解，在此特别感谢。
侵权则删。

10.1_分蛋糕_2017_03

#include <iostream>
using namespace std;int main() {int a[1000], n, k; // 定义数组a用于存储蛋糕的重量，整数n表示蛋糕的数量，整数k为分配的阈值int count = 0; // 定义整数count用于计数能够完整分配的蛋糕数量int weight = 0; // 定义整数weight用于累加蛋糕的重量cin >> n >> k; // 从标准输入读取蛋糕的数量n和阈值k// 读取每个蛋糕的重量for (int i = 0; i < n; i++) {cin >> a[i];}// 遍历所有蛋糕，尝试按重量分配for (int i = 0; i < n; i++) {weight += a[i]; // 累加当前蛋糕的重量if (weight >= k) { // 当累计重量大于或等于阈值k时weight = 0; // 重置累计重量count++; // 增加完整分配的蛋糕计数}}// 检查最后一个蛋糕是否被分配if (weight > 0) count++; // 如果有剩余重量，说明最后一个蛋糕也被分配了cout << count; // 输出能够完整分配的蛋糕数量return 0; // 程序结束
}

11.2_公共钥匙盒_2017_09

#include <iostream>
#include <algorithm>//sort()函数头文件 
using namespace std;
#define N 1002
struct Key
{int name;//钥匙序号 int begin;//开始时间 int time;//持续时间 int flag = 0;//flag=1：此借出、归还操作已执行 
};
bool BeginCmp(Key first, Key second) 
{//按起始时间从小到大排序 return first.begin < second.begin;
}
bool EndCmp(Key first, Key second) {if (first.begin + first.time == second.begin + second.time) { return first.name < second.name; }//同一时间还，序号小的钥匙先还入else{return first.begin + first.time < second.begin + second.time;}
}void printAction(Key* key, int k)
{for (int i = 0; i < k; i++){cout << key[i].name << " **" << key[i].begin << "** " << key[i].time <<"   结束时间： "<< key[i].begin+key[i].time << endl;}
}int main() 
{int n, k;//n把钥匙，k位老师操作cin >> n >> k;int Box[N];for (int i = 0; i < n; i++) {//初始化钥匙存放序号Box()数组 Box[i] = i + 1;}Key key[N];for (int i = 0; i < k; i++) {//输入老师的操作信息 cin >> key[i].name >> key[i].begin >> key[i].time;}sort(key, key + k, BeginCmp);//按照开始时间排序cout << "\n按照开始时间排序：" << endl;printAction(key, k);int BeginTimeFlag = key[0].begin;//最早开始时间 sort(key, key + k, EndCmp);//按照结束时间排序cout << "\n按照结束时间排序：" << endl;printAction(key, k);cout << "``````````````````````````````````\n\n";int EndTimeFlag = key[k - 1].begin + key[k - 1].time;//最晚结束时间 cout<<"BeginTimeFlag: "<<BeginTimeFlag << "  EndTimeFlag: " << EndTimeFlag << endl;for (int i = BeginTimeFlag; i <= EndTimeFlag; i++) {//对时间遍历 for (int j = 0; j < k; j++) {//对操作遍历 if (key[j].flag == 0) {//key[j].flag==0,说明k[j]的借出、归还操作未全执行一次 if (key[j].begin + key[j].time == i) {	//到达钥匙j的归还还时间 for (int x = 0; x < n; x++) {//将钥匙j存入最小的空钥匙挂钩上 if (Box[x] == 0){Box[x] = key[j].name;//放入钥匙 key[j].flag = 1;//key[j]的借出、归还操作已执行完毕，key[j].flag赋值为1，后续不需执行break;}}}else if (key[j].begin == i) {//到达钥匙j的借出时间 for (int x = 0; x < n; x++) {if (Box[x] == key[j].name) {Box[x] = 0;//借出钥匙，钥匙盒中此位置为0 break;//后续循环内容不需执行 }}}}}}cout << "钥匙盒中钥匙序号：";for (int i = 0; i < n; i++) {cout << Box[i] << " ";}return 0;
}/*
测试用例：
5 7
1 1 14
3 3 12
1 15 12
2 7 20
3 18 12
4 21 19
5 30 9
*/

25.1 未初始化警告

#include <iostream>
#include <set>
using namespace std;int main()
{int n;int k;cin >> n >> k;int x;int y;set<int> s;int count = 0;for (int i = 0; i < k; ++i){cin >>x>> y;if (s.find(y) == s.end() && y!=0){++count;}s.insert(x);}cout << "count: "<<count << endl;return 0;
}

26.1_归一化处理

#include <stdio.h>
#include <iostream>
#include <math.h>
using namespace std;int main() {int n; // 定义一个整数变量n，用于存储数据的数量double a[1002]; // 定义一个大小为1002的数组，用于存储数据cin >> n; // 从标准输入读取数据的数量nfor (int i = 1; i <= n; i++) {cin >> a[i]; // 从标准输入读取每个数据}double sum = 0; // 定义一个双精度浮点数变量sum，用于累加数据for (int i = 1; i <= n; i++) {sum += a[i]; // 累加所有数据}double a_avg; // 定义一个双精度浮点数变量a_avg，用于存储平均值a_avg = sum / n; // 计算平均值// printf("%f\n", a_avg); // 输出平均值（注释掉的代码）double D = 0; // 定义一个双精度浮点数变量D，用于累加方差for (int i = 1; i <= n; i++) {D += (a[i] - a_avg) * (a[i] - a_avg); // 累加每个数据与平均值的差的平方}D = D / n; // 计算方差// printf("%f\n", D); // 输出方差（注释掉的代码）double d; // 定义一个双精度浮点数变量d，用于存储标准差d = sqrt(D); // 计算标准差// printf("%f\n", d); // 输出标准差（注释掉的代码）for (int i = 1; i <= n; i++) {printf("%f\n", (a[i] - a_avg) / d); // 输出每个数据与平均值的差除以标准差}return 0; // 程序结束
}

26.2_寻宝！大冒险！

#include <stdio.h>
#include <iostream>
using namespace std;struct tree {int x; // 定义结构体变量x，用于存储坐标xint y; // 定义结构体变量y，用于存储坐标y
};int main() {int n, L, S;cin >> n >> L >> S; // 从标准输入读取n, L和S的值tree a[1010]; // 定义一个结构体数组a，用于存储点的坐标// 读取每个点的坐标for (int i = 1; i <= n; i++) {cin >> a[i].x >> a[i].y;}int B[52][52]; // 定义一个二维数组B，用于存储某种状态// 初始化数组Bfor (int i = S; i >= 0; i--) {for (int j = 0; j <= S; j++) {cin >> B[i][j];}}int temp[52][52]; // 定义一个二维数组temp，用于存储临时状态int count = 0; // 定义一个整数变量count，用于计数// 初始化temp数组for (int i = 1; i <= n; i++){if ( (a[i].x > (L-S)) ||  (a[i].y > (L-S))){continue; // 如果点不在范围内，跳过当前循环}for (int x = 0; x <= S; x++) {for (int y = 0; y <= S; y++) {temp[x][y] = 0; // 初始化temp数组}}for (int k = 1; k <= n; k++) {int tempx = a[k].x - a[i].x;int tempy = a[k].y - a[i].y;if (tempx < 0 || tempx > S) continue; // 如果x差值不在范围内，跳过当前循环if (tempy < 0 || tempy > S) continue; // 如果x差值为0或等于S，跳过当前循环temp[tempx][tempy] = 1; // 标记temp数组}int flag = 0; // 初始化标志变量flagfor (int x = S; x >= 0; x--) {for (int y = 0; y <= S; y++) {if (temp[x][y] != B[x][y]) flag = 1; // 如果temp和B数组对应位置不同，设置flag为1}}if (flag == 0) count++; // 如果flag为0，表示所有对应位置相同，计数器加1}cout << count; // 输出计数器的值return 0;
}

27.1_如此编码

#include <stdio.h>
#include <iostream>
using namespace std;int main() {int n; // 定义一个整数变量n，用于存储输入的数值int m; // 定义一个整数变量m，用于存储输入的数值cin >> n >> m; // 从标准输入读取n和m的值int a[22]; // 定义一个大小为22的整数数组aint c[22]; // 定义一个大小为22的整数数组cc[0] = 1; // 初始化数组c的第一个元素为1// 读取数组a的元素，并计算数组c的累积乘积for (int i = 1; i <= n; i++) {cin >> a[i]; // 从标准输入读取数组a的元素c[i] = c[i - 1] * a[i]; // 计算累积乘积}int b[22]; // 定义一个大小为22的整数数组bb[0] = 0; // 初始化数组b的第一个元素为0int temp = 0; // 定义一个整数变量temp，用于存储临时值// 计算数组b的元素for (int i = 1; i <= n; i++) {b[i] = (m % c[i] - temp) / c[i - 1]; // 计算数组b的元素temp = temp + c[i - 1] * b[i]; // 更新临时值cout << b[i] << " "; // 输出数组b的最后一个元素}return 0; // 程序结束
}

27.2_何以包邮

#include <iostream>
#include <set>
using namespace std;int main() {int n; // 定义一个整数变量n，用于存储商品的数量int x; // 定义一个整数变量x，用于存储预算cin >> n >> x; // 从标准输入读取商品的数量n和预算xint a[32]; // 定义一个大小为32的整数数组a，用于存储每个商品的价格for (int i = 1; i <= n; i++) {cin >> a[i]; // 从标准输入读取每个商品的价格}set<int> PossibleCost[32]; // 定义一个大小为32的整数集合数组PossibleCost，用于存储可能的总成本PossibleCost[0].insert(0); // 初始化集合，插入0作为基础成本// 动态规划过程，计算所有可能的总成本for (int i = 1; i <= n; i++) {for (set<int>::iterator p = PossibleCost[i - 1].begin(); p != PossibleCost[i - 1].end(); ++p) {int Nobuy = *p; // 当前一个商品组合的成本int buy = *p + a[i]; // 当前一个商品组合加上当前商品的成本PossibleCost[i].insert(Nobuy); // 插入新的可能成本到集合中PossibleCost[i].insert(buy); // 插入新的可能成本到集合中}}// 找到不超过预算的最小可能成本for (set<int>::iterator q = PossibleCost[n].begin(); q != PossibleCost[n].end(); ++q) {if (*q >= x) { // 如果可能成本不超过预算cout << "minCost: " << *q; // 输出可能的最小成本return 0; // 结束程序}}return 0; // 如果没有找到不超过预算的可能成本，返回0
}

28.1_现值计算

#include <stdio.h>
#include <iostream>
using namespace std;int main() {int n; // 定义一个整数变量n，用于存储项数int x; // 定义一个整数变量x，用于存储初始值double i, r, sum; // 定义三个双精度浮点数变量i, r, sum，分别用于存储利率，利率和总和// 从标准输入读取项数n和初始值xscanf("%d %lf", &n, &i);scanf("%d", &x); // 从标准输入读取初始值xr = 1.0; // 初始化利率r为1.0（即100%）sum = x; // 初始化总和sum为初始值x// 循环计算总和for (int k = 1; k <= n; k++) {scanf("%d", &x); // 从标准输入读取每一项的值r = r * (1 + i); // 更新利率r为(1+i)^ksum = sum + x / r; // 将每一项的现值加到总和中}printf("%.3f", sum); // 输出计算得到的总和return 0;
}

28.2_训练计划

#include <iostream>
using namespace std;struct course {int p;    // 优先级int t;    // 持续时间int start; // 开始时间int end;  // 结束时间
};int main() {course a[10];int n, m; // 定义两个整数变量n和mcin >> n >> m; // 从标准输入读取n和m的值int flag = 1; // 初始化标志变量flag为1for (int i = 1; i <= m; i++) {cin >> a[i].p; // 从标准输入读取每个活动的优先级}for (int i = 1; i <= m; i++) {cin >> a[i].t; // 从标准输入读取每个活动的持续时间a[i].end = n + 1; // 初始化每个活动的结束时间为n+1}for (int i = 1; i <= m; i++) {for (int j = i; j <= m; j++) {if (a[i].p == 0) {a[i].start = 1; // 如果优先级为0，开始时间为1}else {a[i].start = a[a[i].p].start + a[a[i].p].t; // 否则，开始时间为前一个优先级活动的结束时间加上当前活动的持续时间}if ((a[i].start + a[i].t - 1) > n) flag = 0; // 如果活动的结束时间超过了n，将标志变量flag设置为0}}if (flag == 1) {for (int j = m; j >= 1; j--) {if (a[j].end == (n + 1)) a[j].end = n + 1 - a[j].t; // 如果活动的结束时间为n+1，更新为n+1-当前活动的持续时间if (a[j].p != 0) {if ((a[j].end - a[a[j].p].t) < a[a[j].p].end) // 如果活动的结束时间减去前一个优先级活动的结束时间小于当前活动的优先级a[a[j].p].end = a[j].end - a[a[j].p].t; // 更新前一个优先级活动的结束时间}}}cout << a[1].start; // 输出第一个活动的开始时间for (int i = 2; i <= m; i++) {cout << " " << a[i].start; // 输出其他活动的开始时间}cout << endl;if (flag == 1) { // 如果标志变量flag为1cout << a[1].end; // 输出第一个活动的结束时间for (int i = 2; i <= m; i++) {cout << " " << a[i].end; // 输出其他活动的结束时间}cout << endl;}return 0;
}

29.1_田地丈量_2023_03

#include <stdio.h>
#include <iostream>
using namespace std;int main() 
{int n, a, b; // 定义三个整数变量n, a, b，分别表示矩形的数量和矩形的长宽限制cin >> n >> a >> b; // 从标准输入读取n, a, b的值int area = 0; // 定义一个整数变量area，用于存储矩形的总面积int x1, y1, x2, y2; // 定义四个整数变量x1, y1, x2, y2，分别表示矩形的左上角和右下角坐标// 遍历每个矩形for (int i = 1; i <= n; i++) {cin >> x1 >> y1 >> x2 >> y2; // 从标准输入读取矩形的坐标int xk, yk, xt, yt; // 定义四个整数变量xk, yk, xt, yt，分别表示矩形在限制范围内的左上角和右下角坐标// 处理矩形的左上角坐标if ((0 <= x1) && (x1 <= a)) xk = x1; // 如果x1在范围内，xk = x1if (x1 < 0) xk = 0; // 如果x1小于0，xk = 2if (x1 > a) continue; // 如果x1大于a，跳过当前循环// 处理矩形的右上角坐标if ((0 <= y1) && (y1 <= b)) yk = y1; // 如果y1在范围内，yk = y1if (y1 < 0) yk = 0; // 如果y1小于0，yk = 0if (y1 > b) continue; // 如果y1大于b，跳过当前循环// 处理矩形的右下角坐标if ((0 <= x2) && (x2 <= a)) xt = x2; // 如果x2在范围内，xt = x2if (x2 < 0) continue; // 如果x2小于0，跳过当前循环if (x2 > a) xt = a; // 如果x2大于a，xt = a// 处理矩形的左下角坐标if ((0 <= y2) && (y2 <= b)) yt = y2; // 如果y2在范围内，yt = y2if (y2 < 0) continue; // 如果y2小于0，跳过当前循环if (y2 > b) yt = b; // 如果y2大于b，yt = b// 计算矩形的面积并累加到总面积if ((xt >= xk) && (yt >= yk)){area += (xt - xk) * (yt - yk);}}cout <<"\narea: " << area<<'\n'; // 输出矩形的总面积return 0; // 程序结束
}

29.2_垦田计划_2023_03

#include <stdio.h>
#include <iostream>
#include <algorithm>
using namespace std;struct area 
{int t; // 时间int c; // 成本
} a[100100];// 比较函数，用于排序
bool cmp(const area& a, const area& b) 
{return a.t > b.t;
}int main() 
{int n, m, k; // 定义三个整数变量n, m, kcin >> n >> m >> k; // 从标准输入读取n, m, k的值for (int i = 1; i <= n; i++) {cin >> a[i].t >> a[i].c; // 从标准输入读取每个任务的时间和成本}sort(a + 1, a + n + 1, cmp); // 对任务进行排序，按照时间从大到小int maxmin; // 定义一个整数变量maxmin，用于存储最大最小值int sumc = 0; // 定义一个整数变量sumc，用于存储总成本int range = 1; // 定义一个整数变量range，用于存储当前范围maxmin = a[1].t; // 初始化maxmin为第一个任务的时间while (range <= n) {if (maxmin == a[range].t) {sumc += a[range].c; // 累加当前任务的成本range++; // 移动到下一个任务}else {int temp; // 定义一个整数变量temp，用于存储临时值temp = (maxmin - a[range].t) * sumc; // 计算临时值if (m >= temp) {m = m - temp; // 更新剩余成本maxmin = a[range].t; // 更新maxmin}else {cout << maxmin - m / sumc; // 输出结果return 0; // 程序结束}}}int x; // 定义一个整数变量x，用于存储最终结果x = ((maxmin - m / sumc) > k) ? (maxmin - m / sumc) : k; // 计算最终结果cout << "result: "<<x; // 输出最终结果return 0; // 程序结束
}

30.1_重复局面_2023_05

#include <stdio.h>
#include <iostream>
#include <string>
using namespace std;int main() 
{int n; // 定义一个整数变量n，用于存储棋盘的行数cin >> n; // 从标准输入读取n的值string chess[110]; // 定义一个字符串数组chess，用于存储每行的棋盘状态// 读取棋盘的每一行for (int i = 1; i <= n; i++) {for (int j = 1; j <= 8; j++) {string temp; // 定义一个字符串变量temp，用于存储单个格子的棋盘状态cin >> temp; // 从标准输入读取单个格子的棋盘状态chess[i] = chess[i] + temp; // 将读取的格子状态追加到当前行的棋盘状态中}int count = 1; // 初始化计数器count为1，用于存储与第一行相同的棋盘行数// 遍历棋盘的每一行，与第一行进行比较std::cout << '\n';for (int k = 1; k < i; k++){if (chess[k] == chess[i]) // 如果当前行与第一行相同count++; // 计数器加1}cout << count << endl; // 输出与第一行相同的棋盘行数}return 0; // 程序结束
}

30.2_矩阵运算_2023_05

#include <stdio.h>
#include <iostream>
using namespace std;int Q[10010][22], KT[22][10010], V[10010][22]; // 定义三个二维数组
int W[10010]; // 定义一个一维数组
long long int temp[10010]; // 定义一个长整型数组int main() {int n, d; // 定义两个整数变量n和dcin >> n >> d; // 从标准输入读取n和d的值// 读取矩阵Q的值for (int i = 1; i <= n; i++) {for (int j = 1; j <= d; j++) {cin >> Q[i][j];}}// 读取矩阵KT的值for (int i = 1; i <= n; i++) {for (int j = 1; j <= d; j++) {cin >> KT[j][i];}}// 读取矩阵V的值for (int i = 1; i <= n; i++) {for (int j = 1; j <= d; j++) {cin >> V[i][j];}}// 读取数组W的值for (int i = 1; i <= n; i++) {cin >> W[i];}std::cout << "\nresult:\n";// 计算矩阵乘法Q * KTfor (int i = 1; i <= n; i++) {for (int j = 1; j <= n; j++) {temp[j] = 0; // 初始化temp数组for (int k = 1; k <= d; k++) {temp[j] += Q[i][k] * KT[k][j]; // 计算矩阵乘法}temp[j] = temp[j] * W[i]; // 乘以W数组}// 计算矩阵乘法(temp) * Vfor (int j = 1; j <= d; j++){long long int temp2 = 0; // 初始化temp2变量for (int k = 1; k <= n; k++){temp2 += temp[k] * V[k][j]; // 计算矩阵乘法}if (j == 1){cout << temp2; // 输出第一列的结果}else{cout << " " << temp2; // 输出后续列的结果}}cout << endl; // 输出换行符}return 0; // 程序结束
}

31.1_坐标变换（其一）__2023_09

#include <stdio.h>
#include <iostream>
using namespace std;int main() 
{int n, m; // 定义两个整数变量n和mcin >> n >> m; // 从标准输入读取n和m的值int x, y, dx = 0, dy = 0; // 定义四个整数变量x, y, dx, dy，其中dx和dy初始化为0// 读取n对坐标(x, y)，并计算它们的和for (int i = 1; i <= n; i++) {cin >> x >> y; // 从标准输入读取一对坐标(x, y)dx = dx + x; // 将x的值累加到dx中dy = dy + y; // 将y的值累加到dy中}// 读取m对坐标(x, y)，并输出它们的和加上之前计算的和for (int i = 1; i <= m; i++) {cin >> x >> y; // 从标准输入读取一对坐标(x, y)std::cout << "result:";cout << x + dx << " " << y + dy << endl; // 输出x + dx和y + dy的值}return 0; // 程序结束
}

31.2_坐标变换（其二）__2023_09

#include <stdio.h>
#include <iostream>
#include <math.h>
#include <vector>using namespace std;int main() {int n, m; // 定义两个整数变量n和m，分别表示操作的数量和坐标变换的数量cin >> n >> m;int op; // 定义一个整数变量op，用于存储操作类型double data; // 定义一个双精度浮点数变量data，用于存储操作数据//double kdata[100010], thetadata[100010]; // 定义两个双精度浮点数数组，用于存储缩放因子和旋转角度std::vector<double> kdata(100010);std::vector<double> thetadata(100010);int i, j; // 定义两个整数变量i和j，用于存储坐标变换的索引double x, y; // 定义两个双精度浮点数变量x和y，用于存储坐标值kdata[0] = 1; // 初始化缩放因子为1thetadata[0] = 0; // 初始化旋转角度为0// 读取操作类型和操作数据for (int k = 1; k <= n; k++) {cin >> op >> data;if (op == 1) { // 如果操作类型为1，表示缩放操作kdata[k] = kdata[k - 1] * data; // 更新缩放因子thetadata[k] = thetadata[k - 1]; // 旋转角度不变}else { // 如果操作类型为2，表示旋转操作kdata[k] = kdata[k - 1]; // 缩放因子不变thetadata[k] = thetadata[k - 1] + data; // 更新旋转角度}}std::cout << "-----------------------------------" << std::endl;// 读取坐标变换的索引和坐标值for (int k = 1; k <= m; k++) {cin >> i >> j >> x >> y;double ktemp, thetatemp; // 定义两个双精度浮点数变量，用于存储缩放因子和旋转角度ktemp = kdata[j] / kdata[i - 1]; // 计算缩放因子thetatemp = thetadata[j] - thetadata[i - 1]; // 计算旋转角度x = x * ktemp; // 应用缩放变换y = y * ktemp; // 应用缩放变换double dx = x, dy = y; // 保存原始坐标值x = dx * cos(thetatemp) - dy * sin(thetatemp); // 应用旋转变换y = dx * sin(thetatemp) + dy * cos(thetatemp); // 应用旋转变换printf("result: %f %f\n\n", x, y); // 输出最终的坐标值}return 0; // 程序结束
}

32.1_仓库规划_2023_12

#include <stdio.h>
#include <iostream>
using namespace std;int ck[1010][11]; // 定义一个二维数组ck，用于存储数据int main() 
{int n, m; // 定义两个整数变量n和mcin >> n >> m; // 从标准输入读取n和m的值// 读取n行m列的数据存入数组ck中for (int i = 1; i <= n; i++) {for (int j = 1; j <= m; j++) {cin >> ck[i][j];}}int count; // 定义一个整数变量count，用于计数// 遍历数组的每一行for (int i = 1; i <= n; i++) {int j; // 定义一个整数变量j// 从第i行之后的每一行进行比较for (j = 1; j <= n; j++) {count = 0; // 初始化计数器count为0// 比较第i行和第j行的每个元素for (int k = 1; k <= m; k++) {if (ck[j][k] > ck[i][k]){++count; // 如果第j行的元素大于第i行的元素，计数器加1}}if (count == m) { // 如果计数器等于m，说明第j行的所有元素都大于第i行的元素cout << j << endl; // 输出第j行的行号break; // 跳出内层循环}}if (j > n) cout << 0 << endl; // 如果没有找到满足条件的行，输出0}return 0; // 程序结束
}

32.2_因子化简_2023_12

#include <stdio.h>
#include <iostream>
#include <math.h>
#include <stack>
using namespace std;int main() {int q; // 读取测试用例的数量cin >> q;while (q--) {long long int n; // 定义一个长整型变量n，用于存储输入的数值int k; // 定义一个整数变量k，用于存储阈值cin >> n >> k;int p = 2; // 初始化质因数为2pair<long long int, int> f; // 定义一个pair类型的变量f，用于存储质因数和其指数stack<pair<long long int, int>> fact; // 定义一个栈，用于存储质因数分解的结果fact.push(make_pair(1, 1)); // 初始化栈，将(1, 1)压入栈中while (n != 1) { // 当n不等于1时，继续分解if (n % p == 0) { // 如果n能被p整除if (fact.top().first == p) { // 如果栈顶元素的质因数等于pfact.top().second++; // 增加栈顶元素的指数}else { // 如果栈顶元素的质因数不等于pfact.push(make_pair(p, 1)); // 将(p, 1)压入栈中}n = n / p; // 更新n的值为n除以p}else { // 如果n不能被p整除p++; // 增加质因数p的值}}long long result = 1; // 初始化结果为1while (!fact.empty()) { // 当栈不为空时，继续处理if (fact.top().second >= k) // 如果栈顶元素的指数大于等于k{result *= pow(fact.top().first, fact.top().second); // 将栈顶元素的质因数的相应次方累乘到结果中}fact.pop(); // 弹出栈顶元素}cout << "result:" << result << '\n'<<endl; // 输出结果}return 0; // 程序结束
}

33.1_词频统计_2024_03

#include <stdio.h>
#include <iostream>
using namespace std;int x[110]; // 存储每个元素在所有组中的出现次数
int flag[110]; // 标记某个元素在当前组中是否出现过
int y[110]; // 存储每个元素的累计出现次数int main() 
{int n, m; // n表示有多少组数据，m表示每组数据中有多少个元素cin >> n >> m; // 从标准输入读取n和m的值// 初始化x, flag, y数组的所有元素为0for (int i = 1; i <= m; i++) {x[i] = flag[i] = y[i] = 0;}// 遍历每一组数据for (int i = 1; i <= n; i++) {int number; // 存储当前组数据中元素的数量cin >> number; // 从标准输入读取当前组数据中元素的数量// 遍历当前组数据中的每个元素for (int j = 1; j <= number; j++) {int word; // 存储当前元素的值cin >> word; // 从标准输入读取当前元素的值flag[word]++; // 标记当前元素在当前组中出现过y[word]++; // 累计当前元素的出现次数}// 更新x数组，计算每个元素在所有组中的出现次数for (int k = 1; k <= m; k++) {if (flag[k] > 0) x[k]++; // 如果当前元素在当前组中出现过，则其在所有组中的出现次数加1flag[k] = 0; // 重置标记，为下一组数据做准备}}cout << '\n' << "Output:" << '\n';// 输出每个元素在所有组中的出现次数和累计出现次数for (int i = 1; i <= m; i++) {cout << x[i] << " " << y[i] << endl; // 输出格式为：每个元素在所有组中的出现次数 每个元素的累计出现次数}return 0; // 程序结束
}

33.2_相似度计算_2024_03

#include <iostream>
#include <string>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;int main() {set<string> A; // 定义一个字符串集合Aset<string> B; // 定义一个字符串集合Bstring temp; // 定义一个字符串变量tempint n, m; // 定义两个整数变量n和mcin >> n >> m; // 从标准输入读取n和m的值// 读取n个字符串存入集合Afor (int i = 1; i <= n; i++) {cin >> temp;for (int i = 0; i < temp.size(); i++) {if (temp[i] >= 'A' && temp[i] <= 'Z') {temp[i] += ('a' - 'A'); // 将大写字母转换为小写字母}}A.insert(temp); // 将转换后的字符串插入集合A}// 读取m个字符串存入集合Bfor (int i = 1; i <= m; i++) {cin >> temp;for (int i = 0; i < temp.size(); i++) {if (temp[i] >= 'A' && temp[i] <= 'Z') {temp[i] += ('a' - 'A'); // 将大写字母转换为小写字母}}B.insert(temp); // 将转换后的字符串插入集合B}vector<string> V; // 定义一个字符串向量Vset_intersection(A.begin(), A.end(), B.begin(), B.end(), inserter(V, V.begin())); // 计算集合A和B的交集，并存储在向量V中cout << V.size() << endl; // 输出集合A和B的交集的大小cout << A.size() + B.size() - V.size() << endl; // 输出集合A和B的并集的大小return 0;
}

34.1__矩阵重塑（其一）__2024_06

#include <stdio.h>
#include <iostream>
using namespace std;int A[10010]; // 定义一个整型数组A，大小为10010int main() 
{int n, m, p, q; // 定义四个整型变量n, m, p, qcin >> n >> m >> p >> q; // 从标准输入读取n, m, p, q的值// 读取二维数组的元素，假设n*m即为数组的总元素个数for (int i = 1; i <= n * m; i++) {cin >> A[i - 1];}// 输出数组元素，按p行q列的格式输出for (int i = 0; i < p; i++) {for (int j = 0; j < q; j++) {cout << A[i * q + j]; // 输出第i行第j列的元素if (j == (q - 1)) { // 如果是每行的最后一个元素cout << endl; // 输出换行符，开始新的一行}else {cout << " "; // 输出空格，分隔同一行的元素}}}return 0;
}

34.2__矩阵重塑（其二）__2024_06

#include <stdio.h>
#include <iostream>
using namespace std;int A[10010]; // 定义一个整型数组A，用于存储输入的矩阵元素
int temp[100010]; // 定义一个临时整型数组temp，用于存储矩阵元素int main() 
{int n, m, t; // 定义三个整型变量n, m, t，分别表示矩阵的行数、列数和操作数cin >> n >> m >> t; // 从标准输入读取n, m, t的值// 读取矩阵元素，存入数组A中for (int i = 1; i <= n * m; i++) {cin >> A[i - 1];}// 进行t次操作for (int k = 0; k < t; k++) {int op, a, b; // 定义三个整型变量op, a, b，分别表示操作类型和操作的参数cin >> op >> a >> b; // 从标准输入读取op, a, b的值if (op == 1) {n = a; // 如果操作类型为1，更新行数nm = b; // 更新列数m}if (op == 2) {// 如果操作类型为2，进行矩阵转置操作for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {temp[j * n + i] = A[i * m + j]; // 将矩阵元素存入临时数组temp中}}for (int i = 0; i < n * m; i++) {A[i] = temp[i]; // 将临时数组temp中的元素复制回数组A中}int tt; // 定义一个整型变量tt，用于交换行数和列数tt = n; // 更新行数n为原来的列数mn = m; // 更新列数m为原来的行数nm = tt; // 更新tt为原来的行数n}if (op == 3) {cout << "result: " << A[a * m + b] << endl; // 如果操作类型为3，输出矩阵中第a行第b列的元素}}return 0;
}

35.1_密码_2024_09

#include <stdio.h>
#include <iostream>
#include <string>// 定义一个结构体，用于存储字符及其出现次数
struct cnum
{char c; // 字符int num; // 字符出现次数
};cnum c[110]; // 创建一个数组，用于存储最多110个字符及其出现次数using namespace std;int main()
{int n; // 读取测试用例的数量cin >> n;while (n--) // 对每个测试用例进行处理{for (int i = 0; i < 110; i++) // 初始化数组{c[i].c = ' '; // 将字符初始化为空字符c[i].num = 0; // 将出现次数初始化为0}string code; // 用于存储输入的字符串cin >> code; // 读取输入的字符串int zimuflag = 0; // 标记是否有字母int shuziflag = 0; // 标记是否有数字int tesuflag = 0; // 标记是否有特殊字符int numflag = 0; // 标记是否有重复字符int level = 0; // 初始化密码等级for (int i = 0; i < code.size(); i++) // 遍历字符串中的每个字符{if (((code[i] >= 'A' && code[i] <= 'Z') || (code[i] >= 'a' && code[i] <= 'z'))) // 检查是否为字母{zimuflag = 1;}if ((code[i] >= '0' && code[i] <= '9')) // 检查是否为数字{shuziflag = 1;}if ((code[i] == '*') || (code[i] == '#')) // 检查是否为特殊字符（* 或 #）{tesuflag = 1;}for (int j = 0; j < 110; j++) // 遍历数组，查找字符是否已存在{if (c[j].c == ' ') // 找到空位置{c[j].c = code[i]; // 存储字符c[j].num = 1; // 初始化出现次数为1break;}if (c[j].c == code[i]) // 查找字符是否已存在{c[j].num++; // 增加出现次数if (c[j].num > 2) numflag = 1; // 如果出现次数超过2次，设置标记break;}}}if ((zimuflag == 1) && (shuziflag == 1) && (tesuflag == 1)) // 检查是否包含字母、数字和特殊字符{level = 2; // 设置密码等级为2if (numflag == 1) level = 1; // 如果有重复字符，设置密码等级为1}cout << level << endl; // 输出密码等级}return 0;
}

35.2_字符串变换_2024-09

#include <stdio.h>
#include <iostream>
#include <string>// 定义一个结构体，用于存储字符替换规则
struct fch
{char c1; // 替换前的字符char c2; // 替换后的字符int r;   // 替换规则的循环周期
};fch fs[110]; // 假设最多有110条替换规则using namespace std;int main()
{string s;  // 输入的原始字符串string ss; // 用于保存原始字符串的副本std::getline(cin, s); // 读取原始字符串ss = s;               // 保存原始字符串的副本int n; // 替换规则的数量cin >> n;std::cin.get(); // 清除输入缓冲区中的多余字符（换行符）// 读取替换规则for (int i = 0; i < n; ++i){string fc; // 临时字符串，用于读取一行替换规则std::getline(std::cin, fc);fs[i].c1 = fc[1]; // 替换前的字符（规则格式假设为 "X Y"）fs[i].c2 = fc[2]; // 替换后的字符fs[i].r = 1;      // 初始化循环周期为1}// 计算每个替换规则的循环周期for (int i = 0; i < n; i++){char temp;temp = fs[i].c2; // 从替换后的字符开始int count = 1;   // 初始化计数器while (temp != fs[i].c1) // 当未回到替换前的字符时{for (int j = 0; j < n; j++) // 查找下一个替换规则{if (fs[j].c1 == temp) // 如果找到匹配的替换规则{temp = fs[j].c2; // 更新当前字符为替换后的字符break;}}count++; // 增加计数器}fs[i].r = count; // 更新该替换规则的循环周期}// 读取需要进行的变换次数int m;cin >> m;while (m--) // 对每种变换次数进行处理{int k; // 当前的变换次数cin >> k;s = ss; // 恢复原始字符串// 对字符串中的每个字符进行变换for (int i = 1; i < (s.size() - 1); i++) // 跳过字符串的第一个和最后一个字符{char temp = s[i]; // 当前字符for (int j = 0; j < n; j++) // 查找匹配的替换规则{if (temp == fs[j].c1) // 如果找到匹配的替换规则{int tt = k % fs[j].r; // 计算实际需要进行的替换次数（利用循环周期优化）if (0 == tt) // 如果余数为0，表示不需要替换{break;}char tmp = fs[j].c2; // 初始化替换后的字符tt--; // 减少一次替换次数// 进行剩余的替换操作while (tt > 0){for (int p = 0; p < n; ++p) // 查找下一个替换规则{if (tmp == fs[p].c1) // 如果找到匹配的替换规则{tmp = fs[p].c2; // 更新当前字符为替换后的字符break;}}tt--; // 减少一次替换次数}s[i] = tmp; // 更新字符串中的字符break;}}}cout << s << endl; // 输出变换后的字符串}return 0;
}

36.1___移动__2024_12

#include <stdio.h>
#include <iostream>
#include <string>
using namespace std;int main()
{int n, k; // 定义两个整数变量n和kcin >> n >> k; // 从标准输入读取n和k的值while (k--) // 当k大于0时，执行循环体，每次循环后k减1{int x, y; // 定义两个整数变量x和ystring op; // 定义一个字符串变量op，用于存储操作指令cin >> x >> y >> op; // 从标准输入读取x，y和操作指令opfor (int i = 0; i < op.size(); i++) // 遍历操作指令op中的每个字符{if (op[i] == 'f') // 如果当前字符是'f'，表示向前移动y{if ((y + 1) <= n) y = y + 1; // 如果y+1不超过n，则y加1}if (op[i] == 'b') // 如果当前字符是'b'，表示向后移动y{if ((y - 1) >= 1) y = y - 1; // 如果y-1不小于1，则y减1}if (op[i] == 'l') // 如果当前字符是'l'，表示向左移动x{if ((x - 1) >= 1) x = x - 1; // 如果x-1不小于1，则x减1}if (op[i] == 'r') // 如果当前字符是'r'，表示向右移动x{if ((x + 1) <= n) x = x + 1; // 如果x+1不超过n，则x加1}}cout << x << ' ' << y << endl; // 输出当前的x和y坐标}return 0;
}

36.2__梦境巡查__2024_12

#include <stdio.h>
#include <iostream>
#include <string>
using namespace std;// 定义一个结构体，用于存储每个位置的权值、最大上界和最大下界
struct cnum
{int w;       // 当前位置的权值int upmax;   // 当前位置的最大上界int downmax; // 当前位置的最大下界
};cnum c[100010]; // 创建一个数组，用于存储最多100010个位置的cnum结构体int main()
{int n; // 定义一个整数变量n，表示位置的数量cin >> n; // 从标准输入读取n的值int a[100010], b[100010]; // 定义两个数组，用于存储每个位置的a和b值for (int i = 0; i <= n; i++) cin >> a[i]; // 从标准输入读取a数组的值for (int i = 1; i <= n; i++) cin >> b[i]; // 从标准输入读取b数组的值c[0].w = a[0]; // 初始化第一个位置的权值为a[0]// 计算每个位置的权值for (int i = 1; i <= n; i++){c[i].w = c[i - 1].w + a[i] - b[i];}c[1].upmax = c[0].w; // 初始化第二个位置的最大上界为第一个位置的权值// 计算每个位置的最大上界。计算经过区域的最大值。for (int i = 2; i <= n; i++){if (c[i - 1].w > c[i - 1].upmax)c[i].upmax = c[i - 1].w;elsec[i].upmax = c[i - 1].upmax;}c[n].downmax = c[n].w; // 初始化最后一个位置的最大下界为最后一个位置的权值// 计算每个位置的最大下界。计算“未”经过区域的最大值。for (int i = n - 1; i >= 1; i--){if (c[i].w > c[i + 1].downmax)c[i].downmax = c[i].w;elsec[i].downmax = c[i + 1].downmax;}// 输出每个位置的最大值for (int i = 1; i <= n; i++){if (c[i].upmax > (c[i].downmax + b[i]))cout << c[i].upmax << ' ';elsecout << c[i].downmax + b[i] << ' ';}return 0;
}