目录
CSP-J2021-1分糖果
总时间限制:
10000ms
单个测试点时间限制:
1000ms
内存限制:
524288kB
描述
红太阳幼儿园的小朋友们开始分糖果啦！
红太阳幼儿园有 n 个小朋友，你是其中之一。保证 n≥2。
有一天你在幼儿园的后花园里发现无穷多颗糖果，你打算拿一些糖果回去分给幼儿园的小朋友们。
由于你只是个平平无奇的幼儿园小朋友，所以你的体力有限，至多只能拿 R 块糖回去。
但是拿的太少不够分的，所以你至少要拿 L 块糖回去。保证 n≤L≤R。
也就是说，如果你拿了 k 块糖，那么你需要保证 L≤k≤R。
如果你拿了 k 块糖，你将把这 k 块糖放到篮子里，并要求大家按照如下方案分糖果：只要篮子里有不少于 n 块糖果，幼儿园的所有 n 个小朋友（包括你自己）都从篮子中拿走恰好一块糖，直到篮子里的糖数量少于 n 块。此时篮子里剩余的糖果均归你所有——这些糖果是作为你搬糖果的奖励。
作为幼儿园高质量小朋友，你希望让作为你搬糖果的奖励的糖果数量（而不是你最后获得的总糖果数量！）尽可能多；因此你需要写一个程序，依次输入 n, L, R，并输出你最多能获得多少作为你搬糖果的奖励的糖果数量。
输入
输入一行，包含三个正整数 n, L, R，分别表示小朋友的个数、糖果数量的下界和上界。
输出
输出一行一个整数，表示你最多能获得的作为你搬糖果的奖励的糖果数量。
样例输入
样例输入1 7 16 23 样例输入2 10 14 18 样例输入3 233 4567 4657
样例输出
样例输出1 6 样例输出2 8 样例输出3 230
提示
【样例解释 #1】
拿 k=20 块糖放入篮子里。
篮子里现在糖果数 20≥n=7，因此所有小朋友获得一块糖；
篮子里现在糖果数变成 13≥n=7，因此所有小朋友获得一块糖；
篮子里现在糖果数变成 6容易发现，你获得的作为你搬糖果的奖励的糖果数量不可能超过 6 块（不然，篮子里的糖果数量最后仍然不少于 n，需要继续每个小朋友拿一块），因此答案是 6。
【样例解释 #2】
容易发现，当你拿的糖数量 k 满足 14=L≤k≤R=18 时，所有小朋友获得一块糖后，剩下的 k−10 块糖总是作为你搬糖果的奖励的糖果数量，因此拿 k=18 块是最优解，答案是 8。
【数据范围】
对于所有数据，保证 2≤n≤L≤R≤109。共 14 组测试数据，其中 10 组官方数据、4 组张老师和杜老师编程课添加数据。
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,l,r;
cin>>n>>l>>r;
int k,a=0;
if(r/n>l/n)a=n-1;
else a=r%n;
cout<<a;
return 0;
} 思路：/*根据余数相关性质，0<(mod n)<n-1，也就是将糖果分给n个小朋友，余数的最大值为n -1。但是从L到R一定能取得最大值
- 1吗，不一定!分两种情况:
10
如果工和R不在一个周期内，那么从工到R中一定存在(mod n)最大值n-1。例如当n=7,L=16.R= 23，L和R不在同一周
期内，此时区间[16,23]中存在20%7 = 6。
如果工和R在一个周期内，那么工到R中(mod n)最大值为R%n，即区间工,R|中最大值R%n的结果。例如n = 10,L=
14,R = 18，工和R在同一周期中，此时区间|14,18]中(mod 10)的最大值为18%10 = 8
*/
CSP-J2021-2插入排序
总时间限制:
25000ms
单个测试点时间限制:
1000ms
内存限制:
524288kB
描述
插入排序是一种非常常见且简单的排序算法。小 Z 是一名大一的新生，今天 H 老师刚刚在上课的时候讲了插入排序算法。
假设比较两个元素的时间为 O(1)，则插入排序可以以 O(n2) 的时间复杂度完成长度为 n 的数组的排序。不妨假设这 n 个数字分别存储在 a1, a2, ..., an 之中，则如下伪代码给出了插入排序算法的一种最简单的实现方式：
这下面是 C/C++ 的示范代码：
for (int i = 1; i <= n; i++)
for (int j = i; j >= 2; j--)
if (a[j] < a[j-1]) {
int t = a[j-1];
a[j-1] = a[j];
a[j] = t;
}这下面是 Pascal 的示范代码：
for i:=1 to n do
for j:=i downto 2 do
if a[j]<a[j-1] then
begin
t:=a[i];
a[i]:=a[j];
a[j]:=t;
end;为了帮助小 Z 更好的理解插入排序，小 Z 的老师 H 老师留下了这么一道家庭作业：
H 老师给了一个长度为 n 的数组 a，数组下标从 1 开始，并且数组中的所有元素均为非负整数。小 Z 需要支持在数组 a 上的 Q 次操作，操作共两种，参数分别如下：
- 1 x v：这是第一种操作，会将 a 的第 x 个元素，也就是 ax 的值，修改为 v。保证 1≤x≤n，1≤v≤109。注意这种操作会改变数组的元素，修改得到的数组会被保留，也会影响后续的操作。
- 2 x：这是第二种操作，假设 H 老师按照上面的伪代码对 a 数组进行排序，你需要告诉 H 老师原来 a 的第 x 个元素，也就是 ax，在排序后的新数组所处的位置。保证 1≤x≤n。注意这种操作不会改变数组的元素，排序后的数组不会被保留，也不会影响后续的操作。
H 老师不喜欢过多的修改，所以他保证类型 1 的操作次数不超过 5000。
小 Z 没有学过计算机竞赛，因此小 Z 并不会做这道题。他找到了你来帮助他解决这个问题。
输入
第一行，包含两个正整数 n, Q，表示数组长度和操作次数。
第二行，包含 n 个空格分隔的非负整数，其中第 i 个非负整数表示 ai。
接下来 Q 行，每行 2 个或 3 个正整数，表示一次操作，操作格式见【题目描述】。
输出
对于每一次类型为 2 的询问，输出一行一个正整数表示答案。
样例输入
3 4 3 2 1 2 3 1 3 2 2 2 2 3
样例输出
1 1 2
提示
【样例解释 #1】
在修改操作之前，假设 H 老师进行了一次插入排序，则原序列的三个元素在排序结束后所处的位置分别是 3,2,1。
在修改操作之后，假设 H 老师进行了一次插入排序，则原序列的三个元素在排序结束后所处的位置分别是 3,1,2。
注意虽然此时 a2=a3，但是我们不能将其视为相同的元素。
【样例 #2】
见附件中的 sort2.in 与 sort2.ans。
该测试点数据范围同测试点 1∼2。
【样例 #3】
见附件中的 sort3.in 与 sort3.ans。
该测试点数据范围同测试点 3∼7。
【样例 #4】
见附件中的 sort4.in 与 sort4.ans。
该测试点数据范围同测试点 12∼14。
【数据范围】
对于所有测试数据，满足 1≤n≤8000，1≤Q≤2×105，1≤x≤n，1≤v,ai≤109。
对于所有测试数据，保证在所有 Q 次操作中，至多有 5000 次操作属于类型一。
各测试点附加限制及分值如下表所示。
#include<bits/stdc++.h>
using namespace std;
int b[8005];
struct node{
int a;//数值
int w;//原位置
}a[8005];
int main(){
int n,q;
cin>>n>>q;
for(int i=1;i<=n;i++){
cin>>a[i].a;
a[i].w=i;
}
for(int i=1;i<=n;i++){
for(int j=i;j>=2;j--){
if(a[j].a<a[j-1].a)swap(a[j],a[j-1]);
else break;
}
}
for(int i=1;i<=n;i++){
b[a[i].w]=i;
}
for(int i=1;i<=q;i++){
int t;
cin>>t;
if(t==1){
int x,v;
cin>>x>>v;
a[b[x]].a=v;
for(int k=2;k<=n;k++){
for(int j=k;j>=2;j--){
if(a[j].a<a[j-1].a||a[j].a==a[j-1].a&&a[j].w<a[j-1].w){
swap(a[j],a[j-1]);
swap(b[a[j].w],b[a[j-1].w]);
}else break;
}
}
}
else{
int x;
cin>>x;
cout<<b[x]<<endl;
}
}
return 0;
} 对于案例一：
/*
3 4
3 2 1
1 3 3
2 2 2
3 1 1
2 3
1
1 3 2
2 2 3
2 3 1
3 1 2
2 2
1
2 3
原来第二个元素的位置 是1
原来 第三个元素的位置是 2
原来第一个元素的位置是3*/
CSP-J2021-3网络连接
总时间限制:
20000ms
单个测试点时间限制:
1000ms
内存限制:
524288kB
描述
TCP/IP 协议是网络通信领域的一项重要协议。今天你的任务，就是尝试利用这个协议，还原一个简化后的网络连接场景。
在本问题中，计算机分为两大类：服务机（Server）和客户机（Client）。服务机负责建立连接，客户机负责加入连接。
需要进行网络连接的计算机共有 n 台，编号为 1 ∼ n，这些机器将按编号递增的顺序，依次发起一条建立连接或加入连接的操作。
每台机器在尝试建立或加入连接时需要提供一个地址串。服务机提供的地址串表示它尝试建立连接的地址，客户机提供的地址串表示它尝试加入连接的地址。
一个符合规范的地址串应当具有以下特征：
- 必须形如 a.b.c.d:e 的格式，其中 a,b,c,d,e 均为非负整数；
- 0≤a,b,c,d≤255，0≤e≤65535；
- a,b,c,d,e 均不能含有多余的前导 0。
相应地，不符合规范的地址串可能具有以下特征：
- 不是形如 a.b.c.d:e 格式的字符串，例如含有多于 3 个字符 . 或多于 1 个字符 : 等情况；
- 整数 a,b,c,d,e 中某一个或多个超出上述范围；
- 整数 a,b,c,d,e 中某一个或多个含有多余的前导 0。
例如，地址串 192.168.0.255:80 是符合规范的，但 192.168.0.999:80、192.168.00.1:10、192.168.0.1:088、192:168:0:1.233 均是不符合规范的。
如果服务机或客户机在发起操作时提供的地址串不符合规范，这条操作将被直接忽略。
在本问题中，我们假定凡是符合上述规范的地址串均可参与正常的连接，你无需考虑每个地址串的实际意义。
由于网络阻塞等原因，不允许两台服务机使用相同的地址串，如果此类现象发生，后一台尝试建立连接的服务机将会无法成功建立连接；除此之外，凡是提供符合规范的地址串的服务机均可成功建立连接。
如果某台提供符合规范的地址的客户机在尝试加入连接时，与先前某台已经成功建立连接的服务机提供的地址串相同，这台客户机就可以成功加入连接，并称其连接到这台服务机；如果找不到这样的服务机，则认为这台客户机无法成功加入连接。
请注意，尽管不允许两台不同的服务机使用相同的地址串，但多台客户机使用同样的地址串，以及同一台服务机同时被多台客户机连接的情况是被允许的。
你的任务很简单：在给出每台计算机的类型以及地址串之后，判断这台计算机的连接情况。
输入
第一行，一个正整数 n。
接下来 n 行，每行两个字符串 op, ad，按照编号从小到大给出每台计算机的类型及地址串。
其中 op 保证为字符串 Server 或 Client 之一，ad 为一个长度不超过 25 的，仅由数字、字符 . 和字符 : 组成的非空字符串。
每行的两个字符串之间用恰好一个空格分隔开，每行的末尾没有多余的空格。
输出
输出共 n 行，每行一个正整数或字符串表示第 i 台计算机的连接状态。其中：
如果第 i 台计算机为服务机，则：
1. 如果其提供符合规范的地址串且成功建立连接，输出字符串 OK。
2. 如果其提供符合规范的地址串，但由于先前有相同地址串的服务机而无法成功建立连接，输出字符串 FAIL。
3. 如果其提供的地址串不是符合规范的地址串，输出字符串 ERR。
如果第 i 台计算机为客户机，则：
1. 如果其提供符合规范的地址串且成功加入连接，输出一个正整数表示这台客户机连接到的服务机的编号。
2. 如果其提供符合规范的地址串，但无法成功加入连接时，输出字符串 FAIL。
3. 如果其提供的地址串不是符合规范的地址串，输出字符串 ERR。
样例输入
样例输入1 5 Server 192.168.1.1:8080 Server 192.168.1.1:8080 Client 192.168.1.1:8080 Client 192.168.1.1:80 Client 192.168.1.1:99999 样例输入2 10 Server 192.168.1.1:80 Client 192.168.1.1:80 Client 192.168.1.1:8080 Server 192.168.1.1:80 Server 192.168.1.1:8080 Server 192.168.1.999:0 Client 192.168.1.1.8080 Client 192.168.1.1:8080 Client 192.168.1.1:80 Client 192.168.1.999:0 样例输入3 见下载附件中的 network3.in 样例输入4 见下载附件中的 network4.in
样例输出
样例输出1 OK FAIL 1 FAIL ERR 样例输出2 OK 1 FAIL FAIL OK ERR ERR 5 1 ERR 样例输出3 见下载附件中的 network3.ans 样例输出4 见下载附件中的 network4.ans
提示
【样例解释 #1】
计算机 1 为服务机，提供符合规范的地址串 192.168.1.1:8080，成功建立连接；
计算机 2 为服务机，提供与计算机 1 相同的地址串，未能成功建立连接；
计算机 3 为客户机，提供符合规范的地址串 192.168.1.1:8080，成功加入连接，并连接到服务机 1；
计算机 4 为客户机，提供符合规范的地址串 192.168.1.1:80，找不到服务机与其连接；
计算机 5 为客户机，提供的地址串 192.168.1.1:99999 不符合规范。
【数据范围】
"性质 1" 为：保证所有的地址串均符合规范；
"性质 2" 为：保证对于任意两台不同的计算机，如果它们同为服务机或者同为客户机，则它们提供的地址串一定不同；
"性质 3" 为：保证任意一台服务机的编号都小于所有的客户机；
"性质 4" 为：保证所有的地址串均形如 a.b.c.d:e 的格式，其中 a,b,c,d,e 均为不超过 109 且不含有多余前导 0 的非负整数；
"性质 5" 为：保证所有的地址串均形如 a.b.c.d:e 的格式，其中 a,b,c,d,e 均为只含有数字的非空字符串。
对于 100% 的数据，保证 1≤n≤1000。
#copy的
#include<bits/stdc++.h>
using namespace std;
struct node {
string ip;//地址串
int m;//序号
}a[10005];
int fun(char ad[]) {//判断是否符合规范的函数
int i,j,cnt1=0,cnt2=0,a,b,c,d,e;
char s[300];//cn1存'.'的数量，cn2存':'的数量
sscanf(ad,"%d.%d.%d.%d:%d",&a,&b,&c,&d,&e);//取出abcde的值
sprintf(s,"%d.%d.%d.%d:%d",a,b,c,d,e);//重新保存
for(i=0;i<strlen(ad);i++) {//计算'.'':'的数量
if(ad[i]=='.') cnt1++;//'.'的数量
if(ad[i]==':') cnt2++;//':'的数量
}
if(cnt1==3&&cnt2==1&&strlen(ad)==strlen(s)&&a>=0&&a<=255&&b>=0&&b<=255&&c>=0&&c<=255&&d>=0&&d<=255&&e>=0&&e<=65536)
return 1;//符合规范
return 0;//不符合规范
}
int main() {
int n,i,j,t=0;//t表示共有几个符合规范的服务机
char op[100],ad[300];//op存计算机类型，ad存计算机的地址串
bool flag;//判断能否加入的状态变量
cin>>n;
for(i=1;i<=n;i++) {//n个计算机
cin>>op>>ad;//型号和地址
string s=ad;//保存地址
if(fun(ad)==0) {//不符合规范
cout<<"ERR"<<endl;
continue;//下一组数据
}
if(op[0]=='S') {//服务机
flag=true;//状态，表示可以建立或连接
for(j=1;j<=t;j++)//遍历每个服务机
if(s==a[j].ip) {//如果有同地址的服务机
flag=false;//表示不能建立
cout<<"FAIL"<<endl;//输出
break;//提前结束循环
}
if(flag==true) {//可以建立
cout<<"OK"<<endl;//输出
a[++t].ip=s;//存储它的ip地址
a[t].m=i;//存储下标
}
}
else {//客户机
flag=true;
for(j=1;j<=t;j++) {//遍历服务机
if(a[j].ip==s) {//有相同地址的服务机
cout<<a[j].m<<endl;//输出它的下标
flag=false;//标记可以连接
break;//提前退出循环
}
}
if(flag==true) {//没有同地址的服务机
cout<<"FAIL"<<endl;//不能连接
}
}
}
return 0;
}CSP-J2021-4小熊的果篮
总时间限制:
10000ms
单个测试点时间限制:
1000ms
内存限制:
524288kB
描述
小熊的水果店里摆放着一排 n 个水果。每个水果只可能是苹果或桔子，从左到右依次用正整数 1,2,…,n 编号。连续排在一起的同一种水果称为一个"块"。小熊要把这一排水果挑到若干个果篮里，具体方法是：每次都把每一个"块"中最左边的水果同时挑出，组成一个果篮。重复这一操作，直至水果用完。注意，每次挑完一个果篮后，"块"可能会发生变化。比如两个苹果"块"之间的唯一桔子被挑走后，两个苹果"块"就变成了一个"块"。请帮小熊计算每个果篮里包含的水果。
输入
第一行，包含一个正整数 n，表示水果的数量。
第二行，包含 n 个空格分隔的整数，其中第 i 个数表示编号为 i 的水果的种类，1 代表苹果，0 代表桔子。
输出
输出若干行。
第 i 行表示第 i 次挑出的水果组成的果篮。从小到大排序输出该果篮中所有水果的编号，每两个编号之间用一个空格分隔。
样例输入
样例输入1 12 1 1 0 0 1 1 1 0 1 1 0 0 样例输入2 20 1 1 1 1 0 0 0 1 1 1 0 0 1 0 1 1 0 0 0 0 样例输入3 见下载附件中的 fruit3.in
样例输出
样例输出1 1 3 5 8 9 11 2 4 6 12 7 10 样例输出2 1 5 8 11 13 14 15 17 2 6 9 12 16 18 3 7 10 19 4 20 样例输出3 见下载附件中的 fruit3.ans
提示
【样例解释 #1】
这是第一组数据的样例说明。
所有水果一开始的情况是 [1,1,0,0,1,1,1,0,1,1,0,0]，一共有 6 个块。
在第一次挑水果组成果篮的过程中，编号为 1,3,5,8,9,11 的水果被挑了出来。
之后剩下的水果是 [1,0,1,1,1,0]，一共 4 个块。
在第二次挑水果组成果篮的过程中，编号为 2,4,6,12 的水果被挑了出来。
之后剩下的水果是 [1,1]，只有 1 个块。
在第三次挑水果组成果篮的过程中，编号为 7 的水果被挑了出来。
最后剩下的水果是 [1]，只有 1 个块。
在第四次挑水果组成果篮的过程中，编号为 10 的水果被挑了出来。
【数据范围】
对于 10% 的数据，n≤5。
对于 30% 的数据，n≤1000。
对于 70% 的数据，n≤50000。
对于 100% 的数据，1≤n≤2×105。
【提示】
由于数据规模较大，建议 C/C++ 选手使用 scanf 和 printf 语句输入、输出。
#include <bits/stdc++.h>
#define MAXN 200100
using namespace std;
int n, a[MAXN], l[MAXN], r[MAXN];
vector<int> b;
int main() {
scanf("%d", &n);
a[0] = a[n + 1] = -1, r[0] = 1, l[n + 1] = n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] != a[i - 1]) b.push_back(i);
l[i] = i - 1, r[i] = i + 1;
}
while (r[0] != n + 1) {
vector<int> tmp;
for (int i = 0; i < b.size(); i++) {
printf("%d ", b[i]);
int u = l[b[i]], v = r[b[i]];
r[u] = v, l[v] = u;
if (a[b[i]] != a[u] && a[b[i]] == a[v]) tmp.push_back(v);
}
puts("");
b = tmp;
}
return 0;
}
扫一扫
6999
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
