ccf-csp 2018春季真题题解

跳一跳
问题描述
　　近来，跳一跳这款小游戏风靡全国，受到不少玩家的喜爱。
　　简化后的跳一跳规则如下：玩家每次从当前方块跳到下一个方块，如果没有跳到下一个方块上则游戏结束。
　　如果跳到了方块上，但没有跳到方块的中心则获得1分；跳到方块中心时，若上一次的得分为1分或这是本局游戏的第一次跳跃则此次得分为2分，否则此次得分比上一次得分多两分（即连续跳到方块中心时，总得分将+2，+4，+6，+8…）。
　　现在给出一个人跳一跳的全过程，请你求出他本局游戏的得分（按照题目描述的规则）。
输入格式
　　输入包含多个数字，用空格分隔，每个数字都是1，2，0之一，1表示此次跳跃跳到了方块上但是没有跳到中心，2表示此次跳跃跳到了方块上并且跳到了方块中心，0表示此次跳跃没有跳到方块上（此时游戏结束）。
输出格式
　　输出一个整数，为本局游戏的得分（在本题的规则下）。
样例输入
1 1 2 2 2 1 1 2 2 0
样例输出
22
数据规模和约定
　　对于所有评测用例，输入的数字不超过30个，保证0正好出现一次且为最后一个数字。

代码：

#include <iostream>using namespace std;const int MAXN = 40;
int arr[40];int main(){int a, pre = 0, ans = 0;while(cin >> a && a){if(a == 1)ans += 1, pre = 1;else{if(pre == 1 || pre == 0)pre = 2;elsepre += 2;ans += pre;}}cout << ans << endl;return 0;
}

碰撞的小球
问题描述
　　数轴上有一条长度为L（L为偶数)的线段，左端点在原点，右端点在坐标L处。有n个不计体积的小球在线段上，开始时所有的小球都处在偶数坐标上，速度方向向右，速度大小为1单位长度每秒。
　　当小球到达线段的端点（左端点或右端点）的时候，会立即向相反的方向移动，速度大小仍然为原来大小。
　　当两个小球撞到一起的时候，两个小球会分别向与自己原来移动的方向相反的方向，以原来的速度大小继续移动。
　　现在，告诉你线段的长度L，小球数量n，以及n个小球的初始位置，请你计算t秒之后，各个小球的位置。
提示
　　因为所有小球的初始位置都为偶数，而且线段的长度为偶数，可以证明，不会有三个小球同时相撞，小球到达线段端点以及小球之间的碰撞时刻均为整数。
　　同时也可以证明两个小球发生碰撞的位置一定是整数（但不一定是偶数）。
输入格式
　　输入的第一行包含三个整数n, L, t，用空格分隔，分别表示小球的个数、线段长度和你需要计算t秒之后小球的位置。
　　第二行包含n个整数a1, a2, …, an，用空格分隔，表示初始时刻n个小球的位置。
输出格式
　　输出一行包含n个整数，用空格分隔，第i个整数代表初始时刻位于ai的小球，在t秒之后的位置。
样例输入
3 10 5
4 6 8
样例输出
7 9 9
样例说明
　　初始时，三个小球的位置分别为4, 6, 8。

　　一秒后，三个小球的位置分别为5, 7, 9。

　　两秒后，第三个小球碰到墙壁，速度反向，三个小球位置分别为6, 8, 10。

　　三秒后，第二个小球与第三个小球在位置9发生碰撞，速度反向（注意碰撞位置不一定为偶数），三个小球位置分别为7, 9, 9。

　　四秒后，第一个小球与第二个小球在位置8发生碰撞，速度反向，第三个小球碰到墙壁，速度反向，三个小球位置分别为8, 8, 10。

　　五秒后，三个小球的位置分别为7, 9, 9。

样例输入
10 22 30
14 12 16 6 10 2 8 20 18 4
样例输出
6 6 8 2 4 0 4 12 10 2
数据规模和约定
　　对于所有评测用例，1 ≤ n ≤ 100，1 ≤ t ≤ 100，2 ≤ L ≤ 1000，0 < ai < L。L为偶数。
　　保证所有小球的初始位置互不相同且均为偶数。

代码：

#include <iostream>using namespace std;const int N = 110, M = 1010;struct node{int x, fx;node():x{-1}, fx{1} {};
};
node arr[N];
int seats[M];
int n, L, t;int main(){cin >> n >> L >> t;for(int i = 1; i <= n; i ++){cin >> arr[i].x;seats[arr[i].x] = i;}while(t --){for(int i = 1; i <= n; i ++){int &x = arr[i].x;seats[x] = 0;x += arr[i].fx;if(x == L || x == 0)arr[i].fx = -arr[i].fx;if(seats[x])arr[i].fx = -arr[i].fx, arr[seats[x]].fx = -arr[seats[x]].fx;seats[x] = i;}}for(int i = 1; i <= n; i ++)cout << arr[i].x << " ";return 0;
}

URL映射
问题描述
　　URL 映射是诸如 Django、Ruby on Rails 等网页框架 (web frameworks) 的一个重要组件。对于从浏览器发来的 HTTP 请求，URL 映射模块会解析请求中的 URL 地址，并将其分派给相应的处理代码。现在，请你来实现一个简单的 URL 映射功能。
　　本题中 URL 映射功能的配置由若干条 URL 映射规则组成。当一个请求到达时，URL 映射功能会将请求中的 URL 地址按照配置的先后顺序逐一与这些规则进行匹配。当遇到第一条完全匹配的规则时，匹配成功，得到匹配的规则以及匹配的参数。若不能匹配任何一条规则，则匹配失败。
　　本题输入的 URL 地址是以斜杠 / 作为分隔符的路径，保证以斜杠开头。其他合法字符还包括大小写英文字母、阿拉伯数字、减号 -、下划线 _ 和小数点 .。例如，/person/123/ 是一个合法的 URL 地址，而 /person/123? 则不合法（存在不合法的字符问号 ?）。另外，英文字母区分大小写，因此 /case/ 和 /CAse/ 是不同的 URL 地址。
　　对于 URL 映射规则，同样是以斜杠开始。除了可以是正常的 URL 地址外，还可以包含参数，有以下 3 种：
　　字符串：用于匹配一段字符串，注意字符串里不能包含斜杠。例如，abcde0123。
　　整数：用于匹配一个不带符号的整数，全部由阿拉伯数字组成。例如，01234。
　　路径：用于匹配一段字符串，字符串可以包含斜杠。例如，abcd/0123/。
　　以上 3 种参数都必须匹配非空的字符串。简便起见，题目规定规则中和前面一定是斜杠，后面要么是斜杠，要么是规则的结束（也就是该参数是规则的最后一部分）。而的前面一定是斜杠，后面一定是规则的结束。无论是 URL 地址还是规则，都不会出现连续的斜杠。
输入格式
　　输入第一行是两个正整数 n 和 m，分别表示 URL 映射的规则条数和待处理的 URL 地址个数，中间用一个空格字符分隔。
　　第 2 行至第 n+1 行按匹配的先后顺序描述 URL 映射规则的配置信息。第 i+1 行包含两个字符串 pi 和 ri，其中 pi 表示 URL 匹配的规则，ri 表示这条 URL 匹配的名字。两个字符串都非空，且不包含空格字符，两者中间用一个空格字符分隔。
　　第 n+2 行至第 n+m+1 行描述待处理的 URL 地址。第 n+1+i 行包含一个字符串 qi，表示待处理的 URL 地址，字符串中不包含空格字符。
输出格式
　　输入共 m 行，第 i 行表示 qi 的匹配结果。如果匹配成功，设匹配了规则 pj ，则输出对应的 rj。同时，如果规则中有参数，则在同一行内依次输出匹配后的参数。注意整数参数输出时要把前导零去掉。相邻两项之间用一个空格字符分隔。如果匹配失败，则输出 404。
样例输入
5 4
/articles/2003/ special_case_2003
/articles// year_archive
/articles/// month_archive
/articles article_detail
/static/ static_serve
/articles/2004/
/articles/1985/09/aloha/
/articles/hello/
/static/js/jquery.js
样例输出
year_archive 2004
article_detail 1985 9 aloha
404
static_serve js/jquery.js
样例说明
　　对于第 1 个地址 /articles/2004/，无法匹配第 1 条规则，可以匹配第 2 条规则，参数为 2004。
　　对于第 2 个地址 /articles/1985/09/aloha/，只能匹配第 4 条规则，参数依次为 1985、9（已经去掉前导零）和 aloha。
　　对于第 3 个地址 /articles/hello/，无法匹配任何一条规则。
　　对于第 4 个地址 /static/js/jquery.js，可以匹配最后一条规则，参数为 js/jquery.js。
数据规模和约定
　　1 ≤ n ≤ 100，1 ≤ m ≤ 100。
　　所有输入行的长度不超过 100 个字符（不包含换行符）。
　　保证输入的规则都是合法的。
　　
代码：

#include <iostream>
#include <string>
#include <vector>using namespace std;const int N = 110;struct node {string name;vector<string> v;bool op{};    //末尾是否有 /node() {op = false;}
};node arr[N];
int n, m;void deal(node &a, const string &s) {int pos = 1;    //跳过第一个 /int len;a.op = s.back() == '/';while (pos < s.length()) {len = 0;while (pos + len < s.length() && s[pos + len] != '/')++len;a.v.push_back(s.substr(pos, len));pos += len + 1;}
}bool check(node &tmp, node &a, vector<string> &ans) {//合法性检查if (a.v.size() && a.v.back() != "<path>" && a.op != tmp.op)return false;int pos = 0, i = 0;for (; i < tmp.v.size() && pos < a.v.size(); i++, pos++) {string &s = tmp.v[i];if (a.v[pos] == s) {continue;} else {if (a.v[pos] == "<int>") {for (char c : s)if (!isdigit(c))return false;//去除前导 0int k = 0;//保留一位 考虑全部都是0的情况while (k + 1 < s.length() && s[k] == '0')++k;ans.push_back(s.substr(k));} else if (a.v[pos] == "<str>") {ans.push_back(s);} else if (a.v[pos] == "<path>") {string t;for (; i < tmp.v.size(); i++)t += tmp.v[i] + '/';if (!tmp.op)t.pop_back();ans.push_back(t);return true;} else {return false;}}}return i == tmp.v.size() && pos == a.v.size();
}int main() {cin >> n >> m;for (int i = 0; i < n; i++) {string a, b;cin >> a >> b;arr[i].name = b;deal(arr[i], a);}while (m--) {node tmp;string s;bool op = false;cin >> s;deal(tmp, s);for (int i = 0; i < n && !op; i++) {node &a = arr[i];vector<string> ans;if (check(tmp, a, ans)) {cout << a.name << " ";for (const string &ss : ans)cout << ss << " ";cout << endl;op = true;}}if (!op)cout << "404" << endl;}return 0;
}

棋局评估
问题描述
　　Alice和Bob正在玩井字棋游戏。
　　井字棋游戏的规则很简单：两人轮流往3*3的棋盘中放棋子，Alice放的是“X”，Bob放的是“O”，Alice执先。当同一种棋子占据一行、一列或一条对角线的三个格子时，游戏结束，该种棋子的持有者获胜。当棋盘被填满的时候，游戏结束，双方平手。
　　Alice设计了一种对棋局评分的方法：
　　- 对于Alice已经获胜的局面，评估得分为(棋盘上的空格子数+1)；
　　- 对于Bob已经获胜的局面，评估得分为 -(棋盘上的空格子数+1)；
　　- 对于平局的局面，评估得分为0；

　　例如上图中的局面，Alice已经获胜，同时棋盘上有2个空格，所以局面得分为2+1=3。
　　由于Alice并不喜欢计算，所以他请教擅长编程的你，如果两人都以最优策略行棋，那么当前局面的最终得分会是多少？
输入格式
　　输入的第一行包含一个正整数T，表示数据的组数。
　　每组数据输入有3行，每行有3个整数，用空格分隔，分别表示棋盘每个格子的状态。0表示格子为空，1表示格子中为“X”，2表示格子中为“O”。保证不会出现其他状态。
　　保证输入的局面合法。(即保证输入的局面可以通过行棋到达，且保证没有双方同时获胜的情况)
　　保证输入的局面轮到Alice行棋。
输出格式
　　对于每组数据，输出一行一个整数，表示当前局面的得分。
样例输入
3
1 2 1
2 1 2
0 0 0
2 1 1
0 2 1
0 0 2
0 0 0
0 0 0
0 0 0
样例输出
3
-4
0
样例说明
　　第一组数据：
　　Alice将棋子放在左下角(或右下角)后，可以到达问题描述中的局面，得分为3。
　　3为Alice行棋后能到达的局面中得分的最大值。
　　第二组数据：

　　Bob已经获胜(如图)，此局面得分为-(3+1)=-4。
　　第三组数据：
　　井字棋中若双方都采用最优策略，游戏平局，最终得分为0。
数据规模和约定
　　对于所有评测用例，1 ≤ T ≤ 5。

代码：

#include <iostream>using namespace std;
int arr[3][3];inline int cal() {int cnt = 0;for (int i = 0; i < 3; i++)for (int j = 0; j < 3; j++)if (arr[i][j] == 0)++cnt;return cnt;
}//op为1代表先手
int dfs(int p) {//判断是否获胜int q = 3 - p;bool op = false;for (int i = 0; i < 3; i++) {bool t = true;for (int j = 0; j < 3; j++)if (arr[i][j] != q)t = false;if (t)op = true;}for (int i = 0; i < 3; i++) {bool t = true;for (int j = 0; j < 3; j++)if (arr[j][i] != q)t = false;if (t)op = true;}op |= (arr[0][0] == q && arr[1][1] == q && arr[2][2] == q) || (arr[2][0] == q && arr[1][1] == q && arr[0][2] == q);if (op) {int t = cal() + 1;//考虑到上一个对手return q == 1 ? t : -t;}//填满了if (cal() == 0)return 0;int a = -10, b = 10;//回溯dfsfor (int i = 0; i < 3; i++) {for (int j = 0; j < 3; j++) {if (arr[i][j])continue;arr[i][j] = p;int t = dfs(3 - p);a = max(a, t);b = min(b, t);arr[i][j] = 0;}}if (p == 1)return a;elsereturn b;
}int main() {int T;cin >> T;while (T--) {for (int i = 0; i < 3; i++)for (int j = 0; j < 3; j++)cin >> arr[i][j];cout << dfs(1) << endl;}return 0;
}

二次求和
问题描述
　　给一棵 n 个节点的树，用 1 到 n 的整数表示。每个节点上有一个整数权值 ai。再给出两个整数 L,R。现在有 m 个操作，每个操作这样描述：
　　给定树上两个节点 u,v 和一个整数 d，表示将树上 u 到 v 唯一的简单路径上每个点的权值 ai 都加上 d。之后求树上所有节点个数大于等于 L 小于等于 R 的简单路径的节点权值和之和。注意这里有两次求和：对于一条节点个数大于等于 L 小于等于 R 的简单路径，求出它所有节点的权值之和；然后对所有这样的路径，对它们的权值和再进行求和。因为答案很大，只用输出对Q=1,000,000,007 取余的结果即可。
输入格式
　　从标准输入读入数据。
　　包含多组数据。数据的第一行包含一个正整数 T，表示数据组数。保证 T=10。
　　每组数据的第一行包含 4 个非负整数 n,m,L,R，分别表示节点个数、操作个数和询问相关的两个参数。保证 1≤L≤R≤n。
　　第二行包含 n 个整数，表示 ai。保证 0≤ai<Q。
　　第三行包含 n-1 个整数，描述树的形态，其中第 i 个数 fi 表示节点 i+1 与节点 fi 之间有一条边，保证 1≤fi≤i<n。能够证明，这样能够保证给出的是一棵树。
　　接下来 m 行，每行包含三个整数 u,v,d，描述一个操作即将树上 u 到 v 唯一的简单路径上每个点的权值 ai 都加上 d，之后询问满足条件的两次求和的结果。保证 1≤u,v≤n，0≤d<Q。
　　保证上述同一行所有的数之间，均用一个空格隔开。
输出格式
　　输出到标准输出。
　　输出 m 行每行一个整数，表示两次求和的结果对 Q=1000000007 求余的结果。
　　子任务
　　共有 10 个测试点，各测试点特点如下：
　　测试点1：n=10，m=10。
　　测试点2：n=50，m=50。
　　测试点3：n=300，m=300。
　　测试点4：n=2000，m=2000。
　　测试点5：n=2000，m=100000。
　　测试点6：n=100000，m=100000。保证 fi=i。
　　测试点7：n=100000，m=100000。保证 fi=⌊(i+1)/2⌋，其中 ⌊⋅⌋ 表示向下取整，即给定的树是完全二叉树。
　　测试点8：n=100000，m=100000。保证对于同一组数据，相同的 fi 至多出现 2 次，即给定的树是二叉树。
　　测试点9：n=100000，m=100000。
　　测试点10：n=100000，m=100000。
　　上述约束对同一测试点中的每组数据都有效。

代码：

#include <iostream>
#include <cstring>
#include <algorithm>using namespace std;typedef long long LL;
const int N = 100010, M = N * 2, MOD = 1e9 + 7;int n, m, L, R;
int w[N];
int h[N], father[N], e[M], ne[M], idx;
int depth[N], fa[N][17];
int path[N], d[N], que[N];
int pos[N], root[N];
bool st[N];
int tr[N];
struct Node
{int d, w, id;bool operator< (const Node& t) const{return d < t.d;}
}q[N], p[N];inline void add(int a, int b)
{e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}inline int lowbit(int x)
{return x & -x;
}inline void update(int x, int v, int k)
{for (int i = x; i <= k; i += lowbit(i)) tr[i] = (tr[i] + v) % MOD;
}inline int query(int x, int k)
{x = min(x, k);int res = 0;for (int i = x; i > 0; i -= lowbit(i)) res = (res + tr[i]) % MOD;return res;
}void bfs()
{memset(depth, 0x3f, sizeof depth);depth[0] = 0, depth[1] = 1;int hh = 0, tt = 0;que[0] = 1;while (hh <= tt){int t = que[hh ++ ];for (int i = h[t]; ~i; i = ne[i]){int j = e[i];if (depth[j] > depth[t] + 1){depth[j] = depth[t] + 1;que[ ++ tt] = j;fa[j][0] = t;for (int k = 1; k <= 16; k ++ )fa[j][k] = fa[fa[j][k - 1]][k - 1];}}}
}inline int lca(int a, int b)
{if (depth[a] < depth[b]) swap(a, b);for (int k = 16; k >= 0; k -- )if (depth[fa[a][k]] >= depth[b])a = fa[a][k];if (a == b) return a;for (int k = 16; k >= 0; k -- )if (fa[a][k] != fa[b][k]){a = fa[a][k];b = fa[b][k];}return fa[a][0];
}void dfs(int u, int fa)
{d[u] = (d[fa] + path[u]) % MOD;for (int i = h[u]; ~i; i = ne[i]){int j = e[i];if (j == fa) continue;dfs(j, u);}
}int get_size(int u, int fa)
{if (st[u]) return 0;int res = 1;for (int i = h[u]; ~i; i = ne[i])if (e[i] != fa)res += get_size(e[i], u);return res;
}int get_wc(int u, int fa, int tot, int& wc)
{if (st[u]) return 0;int sum = 1, ms = 0;for (int i = h[u]; ~i; i = ne[i]){int j = e[i];if (j == fa) continue;int t = get_wc(j, u, tot, wc);ms = max(ms, t);sum += t;}ms = max(ms, tot - sum);if (ms <= tot / 2) wc = u;return sum;
}void get_dist(int u, int fa, int dist, int sum, int& qt)
{if (st[u]) return;q[ ++ qt] = {dist, sum, u};for (int i = h[u]; ~i; i = ne[i]){int j = e[i];if (j != fa)get_dist(j, u, dist + 1, (sum + w[j]) % MOD, qt);}
}inline int get(Node a[], int k, int limit, int wu, int& pu)
{sort(a + 1, a + k + 1);static int sum[N];int res = 0;for (int i = 1; i <= k; i ++ ) sum[i] = (sum[i - 1] + a[i].w) % MOD;for (int i = 1, j = k; i < j; i ++ ){while (j > i && a[j].d + a[i].d - 1 > limit) j -- ;if (j > i && a[j].d + a[i].d - 1 <= limit){res = (res + (LL)sum[j] - sum[i] + (LL)(j - i) * a[i].w - (LL)wu * (j - i)) % MOD;pu = (pu + j - i) % MOD;}}return res;
}int dfs_path(int u, int fa, int dist, int maxd)
{if (st[u]) return 0;int res = (query(R + 1 - dist, maxd) - query(L - dist, maxd)) % MOD;if (dist >= L && dist <= R) res = (res + 1) % MOD;for (int i = h[u]; ~i; i = ne[i]){int j = e[i];if (j != fa)res = (res + dfs_path(j, u, dist + 1, maxd)) % MOD;}path[u] = (path[u] + res) % MOD;return res;
}int calc(int u)
{if (st[u]) return 0;get_wc(u, -1, get_size(u, -1), u);st[u] = true;int res = 0, pt = 0;if (L <= 1 && R >= 1) res = w[u], path[u] = (path[u] + 1) % MOD;int cnt = 0, maxd = 0;for (int i = h[u]; ~i; i = ne[i]){int j = e[i], qt = 0;if (st[j]) continue;get_dist(j, -1, 2, (w[u] + w[j]) % MOD, qt);int pR = 0, pL = 0;res = (res - (LL)(get(q, qt, R, w[u], pR) - get(q, qt, L - 1, w[u], pL))) % MOD;path[u] = (path[u] - (LL)(pR - pL)) % MOD;pos[ ++ cnt] = pt + 1;  // 每一段开头root[cnt] = j;  // 每一段的根节点for (int k = 1; k <= qt; k ++ ){if (q[k].d >= L && q[k].d <= R){res = (res + q[k].w) % MOD;path[u] = (path[u] + 1) % MOD;  // 只计算从u到当前点的}p[ ++ pt] = q[k];maxd = max(maxd, q[k].d);}}pos[cnt + 1] = pt + 1;  // 哨兵for (int i = 1; i <= maxd; i ++ ) tr[i] = 0;for (int i = 1; i <= pt; i ++ ) update(p[i].d, 1, maxd);  // 插入树状数组中for (int i = 1; i <= cnt; i ++ ){int l = pos[i], r = pos[i + 1] - 1;for (int j = l; j <= r; j ++ ) update(p[j].d, -1, maxd);  // 将当前子树中的节点删掉dfs_path(root[i], u, 2, maxd);for (int j = l; j <= r; j ++ ) update(p[j].d, 1, maxd);  // 将当前子树中的节点添加回来}int pR = 0, pL = 0;res = (res + (LL)get(p, pt, R, w[u], pR) - get(p, pt, L - 1, w[u], pL)) % MOD;path[u] = (path[u] + (LL)pR - pL) % MOD;for (int i = h[u]; ~i; i = ne[i]) res = (res + calc(e[i])) % MOD;return res;
}int main()
{int T;scanf("%d", &T);while (T -- ){scanf("%d%d%d%d", &n, &m, &L, &R);memset(h, -1, sizeof h), idx = 0;memset(path, 0, sizeof path);for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);for (int i = 2; i <= n; i ++ ){int p;scanf("%d", &p);add(i, p), add(p, i);father[i] = p;}memset(st, 0, sizeof st);int res = calc(1);dfs(1, 0);bfs();while (m -- ){int a, b, c;scanf("%d%d%d", &a, &b, &c);int p = lca(a, b);int sum = (d[a] + (LL)d[b] - d[p] * 2 + path[p]) * c % MOD;res = ((res + sum) % MOD + MOD) % MOD;printf("%d\n", res);}}return 0;
}作者：yxc
链接：https://www.acwing.com/activity/content/code/content/957323/

更多历年题解戳这里：ccf-csp 历年真题题解

ccf-csp 2018春季真题题解相关推荐

python认证考试_Python入门习题（39）——CCF CSP认证考试真题：公共钥匙盒
CCF CSP认证考试真题:共钥匙盒问题描述试题编号:201709-2 试题名称:公共钥匙盒时间限制:1.0s 内存限制:256.0MB 问题描述有一个学校的老师共用N个教室,按照规定,所有的 ...
CCF CSP认证历年真题满分代码（持续更新中）
目标在接下来的半年到一年时间内,补全CCF认证历年真题(A-D)的满分代码(E题随缘). 考虑到CCF认证这个东西是可以混分的,我计划对D.E题额外增加部分分代码,或许有助于不同层次的选手备赛. 除 ...
python认证考试有哪些_Python入门习题（19）——CCF CSP认证考试真题：中间数
问题描述试题编号:201703-1 试题名称:分蛋糕时间限制:1.0s 内存限制:256.0MB 问题描述小明今天生日,他有n块蛋糕要分给朋友们吃,这n块蛋糕(编号为1到n)的重量分别为a1, ...
ccf-csp 2015春季真题题解
图像旋转问题描述旋转是图像处理的基本操作,在这个问题中,你需要将一个图像逆时针旋转90度. 计算机中的图像表示可以用一个矩阵来表示,为了旋转一个图像,只需要将对应的矩阵旋转即可. 输入格式输入的 ...
CSP认证历年真题题解 (Python)
文章目录此篇文章是小菜本菜使用Python做CCF-CSP的一些记录,希望能够以此帮助到正在为题目苦苦思考,但还没有找到解决思路的朋友们.诚然,这里的代码还有很多值得改进之处,希望各位码友不吝赐教. ...
Python入门习题（19）——CCF CSP认证考试真题：分蛋糕
问题描述试题编号: 201703-1 试题名称: 分蛋糕时间限制: 1.0s 内存限制: 256.0MB 问题描述小明今天生日,他有n块蛋糕要分给朋友们吃,这n块蛋糕(编号为1到n)的重量分别为 ...
历届CSP真题题解-CSP刷真题之路
历届CSP真题题解-CSP刷真题之路(持续更新中...) 2020-12 2020-09 2020-06 2019-12 2020-12 题目编号题解链接 CSP202012-1 期末预测之安全指数 ...
2019第十届蓝桥杯大赛软件类省赛C++ C组真题题解
============================== 2019-2021蓝桥杯C++ C组真题题解: 2019第十届蓝桥杯大赛软件类省赛C++ C组真题题解 2020第十一届蓝桥杯大赛软件类省 ...
2019第十届蓝桥杯大赛软件类省赛C++ B组真题题解
========================================== 2019-2021蓝桥杯C++ B组真题题解: 2019第十届蓝桥杯大赛软件类省赛C++ B组真题题解 2020第 ...

ccf-csp 2018春季真题题解

ccf-csp 2018春季真题题解相关推荐

最新文章

热门文章