编程题得分：100 总分：100
7-1 懂的都懂 (20分)
众所周知，在互联网上有很多话是不好直接说出来的，不过一些模糊的图片仍然能让网友看懂你在说什么。然而对这种言论依然一定要出重拳，所以请你实现一个简单的匹配算法。
现在我们采集了原图的一些特征数据，由 N 个小于 255 的非负整数组成，假设对于给定的若干张由 Mi 个同样小于 255 的非负整数组成的新图的特征数据，每个数据都可以由原图中任意四个不同数据的平均值计算而来，则称新图为原图的相似图片。对于给出的数据，请你判断是不是相似图片。
注意，不同数据指的并非是数据的值不同，而是不能取同一个数据多次。对于两个相同值的数据，如果给出两次，则可以取两次。
输入格式:
输入第一行是两个整数 N,K (1 ≤ N ≤ 50, 1 ≤ K ≤ 200)，表示采集的原图的特征数据个数和新图的张数。
接下来一行为 N 个小于 255 的非负整数，表示原图的特征数据。
最后的 K 行，每行第一个数是 Mi (1 ≤ Mi ≤ 200)，表示新图的特征数据个数。然后是 Mi 个小于 255 的非负整数，表示新图的特征数据。
输出格式:
对于每一张新图，如果为相似图片，则在一行中输出 Yes，否则输出 No。
输入样例:
5 3
4 8 12 20 40
3 11 16 19
3 12 16 19
10 11 11 11 11 11 11 11 11 11 11
输出样例:
Yes
No
Yes
编译器
NO_COMPILER
代码
#include<bits/stdc++.h>
using namespace std;
int n, k, a[55], t;
int b;
bool tong[1500];
int main(){
cin>>n>>k;
for(int i = 1; i<=n; ++i){
scanf("%d", &a[i]);
}
for(int i = 1; i<=n; ++i)
for(int j = i+1; j<=n; ++j)
for(int k = j+1; k<=n; ++k)
for(int p = k+1; p<=n; ++p){
tong[a[i]+a[j]+a[k]+a[p]] = 1;
}
while(k--){
cin>>t;
bool flag = 1;
for(int i = 1; i<=t; ++i){
scanf("%d", &b);
if(tong[b*4] == 0) flag = 0;
}
if(flag) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
return 0;
}编译器输出
a.cpp: In function ‘int main()’:
a.cpp:12:8: warning: ignoring return value of ‘int scanf(const char*, ...)’, declared with attribute warn_unused_result [-Wunused-result]
scanf("%d", &a[i]);
~~~~~^~~~~~~~~~~~~
a.cpp:26:9: warning: ignoring return value of ‘int scanf(const char*, ...)’, declared with attribute warn_unused_result [-Wunused-result]
scanf("%d", &b);
~~~~~^~~~~~~~~~
| 测试点 | 结果 | 测试点得分 | 耗时 | 内存 |
|---|---|---|---|---|
| 0 | 答案正确 | 10 | 4.00 ms | 572 KB |
| 1 | 答案正确 | 2 | 4.00 ms | 728 KB |
| 2 | 答案正确 | 1 | 4.00 ms | 604 KB |
| 3 | 答案正确 | 3 | 4.00 ms | 568 KB |
| 4 | 答案正确 | 4 | 8.00 ms | 580 KB |
评测结果 答案正确 (20 分)
7-2 芬兰木棋 (25分)
芬兰木棋（Mölkky，又称芬兰木柱）是源自芬兰的一项运动。哲哲将这个运动改造成了赛博朋克单人版，现在场上一开始有 N 根立起的小木棋（上面分别标有一个非负整数），哲哲投掷一根大木棋去击倒这些小木棋以获得分数。分数规则如下：
- 如果仅击倒 1 根木棋，则得木棋上的分数。
- 如果击倒 2 根或以上的木棋，则只得击倒根数的分数。（例如击倒 5 根，则得 5 分。）
哲哲固定站在 (0,0) 点上，四周放着若干个小木棋 (Xi,Yi)，坐标均为整数。每次哲哲可以朝一个方向扔出大木棋，大木棋会打倒这个方向上离哲哲最近的 k 个小木棋。哲哲游戏水平很高超，所以这个 k 可以自由控制。
请问哲哲最多能拿多少分，在获得最多分数的情况下最少需要扔出多少次大木棋？
规则与真实规则有较大出入，真实游玩时请以国际莫尔基组织的规则为准
输入格式:
输入第一行是一个正整数 N (1 ≤ N ≤ 105)，表示场上一开始有 N 个木棋。
接下来 N 行，每行 3 个整数 Xi,Yi,Pi，分别表示木棋放置在 (Xi,Yi)，木棋上的分数是 Pi。坐标在 32 位整数范围内，分数为小于等于 1000 的正整数。
保证 (0,0) 点没有木棋，也没有木棋重叠放置。
输出格式:
输出一行两个数，表示最多分数以及获得最多分数最少需要投掷大木棋多少次。
输入样例:
11
1 2 2
2 4 3
3 6 4
-1 2 2
-2 4 3
-3 6 4
-1 -2 1
-2 -4 1
-3 -6 1
-4 -8 2
2 -1 999
输出样例:
1022 9
编译器
NO_COMPILER
代码
#include<bits/stdc++.h>
#define int long long
using namespace std;
int n, c;
int ans, cnt;
double a, b;
int gcdd(int a, int b){
if(b==0) return a;
else return gcd(b, a%b);
}
struct node{
int x;
int y;
double dist;
int p;
}g[100005];
bool cmp(node x, node y){
if(x.x != y.x) return x.x < y.x;
else{
if(x.y != y.y) return x.y < y.y;
else if(x.dist != y.dist) return x.dist < y.dist;
}
}
signed main(){
cin>>n;
for(int i = 1; i<=n; ++i){
scanf("%lf %lf %lld", &a, &b, &c); //lf?f?
g[i].dist = a*a + b*b;
if(a && b){
int chu = gcdd(abs(a),abs(b));
g[i].x = a/chu;
g[i].y = b/chu;
}
if(a==0){
g[i].x = 0;
if(b>0) g[i].y = 1;
else g[i].y = -1;
}
if(b==0){
if(a>0) g[i].x = 1;
else g[i].x = -1;
g[i].y = 0;
}
g[i].p = c;
ans += c;
}
sort(g+1, g+1+n, cmp);
cnt = n;
for(int i = 2; i<=n; ++i){
// cout<<g[i].dir<<" "<<g[i].k<<" "<<g[i].p<<endl;
if(g[i-1].x == g[i].x && g[i-1].y == g[i].y && g[i-1].p == 1 && g[i].p == 1) cnt--;
}
cout<<ans<<" "<<cnt;
return 0;
}编译器输出
a.cpp: In function ‘bool cmp(node, node)’:
a.cpp:27:1: warning: control reaches end of non-void function [-Wreturn-type]
}
^
a.cpp: In function ‘int main()’:
a.cpp:33:8: warning: ignoring return value of ‘int scanf(const char*, ...)’, declared with attribute warn_unused_result [-Wunused-result]
scanf("%lf %lf %lld", &a, &b, &c); //lf?f?
~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
| 测试点 | 结果 | 测试点得分 | 耗时 | 内存 |
|---|---|---|---|---|
| 0 | 答案正确 | 12 | 4.00 ms | 596 KB |
| 1 | 答案正确 | 1 | 4.00 ms | 452 KB |
| 2 | 答案正确 | 1 | 4.00 ms | 456 KB |
| 3 | 答案正确 | 2 | 84.00 ms | 6212 KB |
| 4 | 答案正确 | 2 | 52.00 ms | 5308 KB |
| 5 | 答案正确 | 1 | 77.00 ms | 6024 KB |
| 6 | 答案正确 | 6 | 79.00 ms | 5812 KB |
评测结果 答案正确 (25 分)
7-3 打怪升级 (25分)
很多游戏都有打怪升级的环节，玩家需要打败一系列怪兽去赢取成就和徽章。这里我们考虑一种简单的打怪升级游戏，游戏规则是，给定有 N 个堡垒的地图，堡垒之间有道路相连，每条道路上有一只怪兽把守。怪兽本身有能量，手里的武器有价值。打败怪兽需要的能量等于怪兽本身的能量，而怪兽一旦被打败，武器就归玩家所有 —— 当然缴获的武器价值越高，玩家就越开心。
你的任务有两件：
-
- 帮助玩家确定一个最合算的空降位置，即空降到地图中的某个堡垒，使得玩家从这个空降点出发，到攻下最难攻克（即耗费能量最多）的那个堡垒所需要的能量最小；
-
- 从这个空降点出发，帮助玩家找到攻克任意一个其想要攻克的堡垒的最省能量的路径。如果这种路径不唯一，则选择沿途缴获武器总价值最高的解，题目保证这种解是唯一的。
输入格式:
输入第一行给出两个正整数 N (≤1000) 和 M，其中 N 是堡垒总数，M 是怪兽总数。为简单起见，我们将堡垒从 1 到 N 编号。随后 M 行，第 i 行给出了第 i 只怪兽的信息，格式如下：
B1 B2 怪兽能量 武器价值
其中 B1 和 B2 是怪兽把守的道路两端的堡垒编号。题目保证每对堡垒之间只有一只怪兽把守，并且 怪兽能量 和 武器价值 都是不超过 100 的正整数。
再后面是一个正整数 K（≤N）和玩家想要攻克的 K 个目标堡垒的编号。
输出格式:
首先在一行中输出玩家空降的堡垒编号 B0。如果有多种可能，则输出编号最小的那个。
随后依次为玩家想要攻克的每个堡垒 B 推荐最省能量的攻克路径，并列出需要耗费的能量值和沿途缴获武器的总价值。注意如果最省力的路径不唯一，则选择沿途缴获武器总价值最高的解。格式为：
B0->途经堡垒1->...->B
总耗费能量 武器总价值
输入样例:
6 12
1 2 10 5
2 3 16 20
3 1 4 2
2 4 20 22
4 5 2 2
5 3 12 6
4 6 8 5
6 5 10 5
6 1 20 25
1 5 8 5
2 5 2 1
2 6 8 5
4
2 3 6 5
输出样例:
5
5->2
2 1
5->1->3
12 7
5->4->6
10 7
5
0 0
编译器
NO_COMPILER
代码
#include<bits/stdc++.h>
using namespace std;
int n, m, a, b, c, d, q, p;
int f[1005][1005];
const int N = 2000000;
int ne[N], w[N], ww[N], e[N], h[N], idx, dist[1005];
bool st[1005];
struct node{
int distance, power, name;
};
struct cmp{
bool operator() (node x, node y){
if(x.distance != y.distance) return x.distance > y.distance;
else{
if(x.power != y.power) return x.power < y.power;
else return x.name < y.name;
}
}
};
int pre[1005];//难点1
int pw[1005];//难点2
void add(int a, int b, int c, int d){
e[idx] = b, w[idx] = c, ww[idx] = d, ne[idx] = h[a], h[a] = idx++;
}
void dijk(int s){
priority_queue<node, vector<node>, cmp> heap;
heap.push({0, 0, s});
dist[s] = 0;
while(heap.size()){
node head = heap.top();
heap.pop();
int ver = head.name, distance = head.distance, power = head.power;
if(st[ver]) continue;
st[ver] = 1;
for(int i = h[ver]; i!=-1; i = ne[i]){
int j = e[i];
if(distance + w[i] < dist[j]){
pre[j] = ver;
dist[j] = distance + w[i];
pw[j] = power + ww[i];
heap.push({dist[j], pw[j], j});
}
else if(distance + w[i] == dist[j]){
if(power + ww[i] > pw[j]){
pre[j] = ver;
dist[j] = distance + w[i];
pw[j] = power + ww[i];
heap.push({dist[j], pw[j], j});
}
}
}
}
// cout<<"debug";
}
int main(){
memset(h, -1, sizeof h);
memset(dist, 127, sizeof dist);
cin>>n>>m;
memset(f, 63, sizeof f);
for(int i = 1; i<=m; ++i){
cin>>a>>b>>c>>d;
f[a][b] = c;
f[b][a] = c;
add(a,b,c,d);
add(b,a,c,d);
}
for(int k = 1; k<=n; ++k)
for(int i = 1; i<=n; ++i)
for(int j = 1; j<=n; ++j)
f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
int ans1 = 0;
int ans1max = 100000000;
for(int i = 1; i<=n; ++i){
int curmax = 0;
for(int j = 1; j<=n; ++j){
curmax = max(curmax, f[i][j]);
}
if(curmax<ans1max){
ans1 = i;
ans1max = curmax;
}
}
cout<<ans1<<endl;
dijk(ans1);
cin>>q;
for(int i = 1; i<=q; ++i){
cin>>p;
vector<int> ans2;
int cur = p;
while(cur!=ans1){
ans2.push_back(cur);
cur = pre[cur];
}
ans2.push_back(ans1);
for(int i = ans2.size()-1; i>=0; --i){
cout<<ans2[i];
if(i!=0) cout<<"->";
}
cout<<"\n";
cout<<dist[p]<<" "<<pw[p]<<endl;
}
return 0;
}编译器输出
| 测试点 | 结果 | 测试点得分 | 耗时 | 内存 |
|---|---|---|---|---|
| 0 | 答案正确 | 13 | 12.00 ms | 12348 KB |
| 1 | 答案正确 | 5 | 12.00 ms | 12228 KB |
| 2 | 答案正确 | 1 | 12.00 ms | 12352 KB |
| 3 | 答案正确 | 2 | 813.00 ms | 12392 KB |
| 4 | 答案正确 | 4 | 1154.00 ms | 30820 KB |
评测结果 答案正确 (25 分)
7-4 疫情防控 (30分)
疫情尚未结束，严防疫情反复。为了做好疫情防控工作，国内设置了地区风险等级，对于中高风险地区的人员采取限制移动、居家隔离等手段。
为了研究疫情防控对于跨地区交通运输的影响，假设现在有 N 个机场，M 条航线，每天都会新增一个防控地区，一个防控地区会导致一个机场无法正常运作，航线也自然无法正常运行，每天会有 Qi 对旅客从 Xi 机场前往 Yi 机场，请计算有多少对旅客会受到影响无法完成行程。
旅客只要能直达或通过若干次中转，且乘坐的所有航线的出发和到达机场都正常运作，即视作可完成行程。
输入格式:
输入第一行是三个整数 N,M,D (1≤N≤5×104, 1≤M≤2×105, 1≤D≤103), 表示机场数、航线数以及新增防控地区的天数。
接下来首先有 M 行，每行给出空格分隔的两个数字 A 和 B，表示编号为 A 和 B 的机场之间有一条航线。航线是双向的，机场编号从 1 到 N。
然后是 D 块输入，每块输入内第一行为空格分隔的两个整数 C 和 Q （1≤Q≤103)，表示新增机场编号为 C 所在的城市为防控地区，今天有 Q 段行程。数据保证新增的城市之前一定不是防控地区。
接下来的 Q 行，每行是空格分隔的两个数字 X 和 Y，表示编号为 X 和 Y 的机场的一段行程。行程有可能包括之前就已经成为防控地区的城市。
输出格式:
对于每天的询问，请在一行中输出在新增了一个防控地区后当天的行程有多少不能成行。
输入样例:
5 5 3
1 2
1 3
1 5
2 5
3 4
4 3
1 3
1 4
2 3
5 3
3 4
2 3
3 5
1 3
2 3
2 5
3 4
输出样例:
1
2
3
编译器
NO_COMPILER
代码
#include<bits/stdc++.h>
using namespace std;
bool openn[400005];//第i个地点是开通的
int n, m, d, a[400005], b[400005];//a b放的是地点
int c[400005], q[400005], fa[400005], ans[1005];
int xx[1005][1005], yy[1005][1005]; //第i天第j次询问的地点的编号
vector<int> nextt[50005];
int findd(int x){
if(fa[x] == x) return x;
else return fa[x] = findd(fa[x]);
}
int main(){
cin>>n>>m>>d;//机场数、航线数以及新增防控地区的天数
for(int i = 1; i<=n; ++i) openn[i] = 1;
for(int i = 1; i<=m; ++i){
cin>>a[i]>>b[i];
nextt[a[i]].push_back(b[i]);
nextt[b[i]].push_back(a[i]);
}
for(int i = 1; i<=d; ++i){
cin>>c[i]>>q[i];
for(int j = 1; j<=q[i]; ++j)
cin>>xx[i][j]>>yy[i][j];
//close
openn[c[i]] = 0;
}
for(int k = 1; k<=n; ++k) fa[k] = k;
//先连一次啊，别漏了啊
for(int i = 1; i<=m; ++i){
if(openn[a[i]] && openn[b[i]]) fa[findd(a[i])] = findd(b[i]);
}
for(int i = d; i>=1; --i){
if(d!=i){
//open && unite
int p1 = c[i+1];
openn[p1] = 1; //open
for(int j = 0; j<nextt[p1].size(); ++j){
int p2 = nextt[p1][j];
// cout<<"debug:"<<p1<<" "<<p2<<endl;
if( openn[ p2 ] )
fa[findd(p1)] = findd(p2);
}
}
//check
int temp = 0;
for(int j = 1; j<=q[i]; ++j){
if( findd(xx[i][j]) != findd(yy[i][j]) ) temp++;
}
ans[i] = temp;
}
for(int i = 1; i<=d; ++i) cout<<ans[i]<<endl;
return 0;
}编译器输出
a.cpp: In function ‘int main()’:
a.cpp:48:20: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
for(int j = 0; j<nextt[p1].size(); ++j){
~^~~~~~~~~~~~~~~~~
| 测试点 | 结果 | 测试点得分 | 耗时 | 内存 |
|---|---|---|---|---|
| 0 | 答案正确 | 15 | 5.00 ms | 1592 KB |
| 1 | 答案正确 | 1 | 5.00 ms | 1600 KB |
| 2 | 答案正确 | 1 | 5.00 ms | 1720 KB |
| 3 | 答案正确 | 5 | 12.00 ms | 2752 KB |
| 4 | 答案正确 | 8 | 553.00 ms | 28332 KB |
评测结果 答案正确 (30 分)
399
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
