1051 复数乘法 (15分)
复数可以写成 (A+Bi) 的常规形式，其中 A 是实部，B 是虚部，i 是虚数单位，满足 i2=−1；也可以写成极坐标下的指数形式 (R×e(Pi))，其中 R 是复数模，P 是辐角，i 是虚数单位，其等价于三角形式 R(cos§+isin§)。
现给定两个复数的 R 和 P，要求输出两数乘积的常规形式。
输入格式：
输入在一行中依次给出两个复数的 R1 , P1 , R2 , P2 ，数字间以空格分隔。
输出格式：
在一行中按照 A+Bi 的格式输出两数乘积的常规形式，实部和虚部均保留 2 位小数。注意：如果 B 是负数，则应该写成 A-|B|i 的形式。
输入样例：
2.3 3.5 5.2 0.4
输出样例：
-8.68-8.23i
20200811（一刷）:
e.g. -0.00 要输出成+0.00
#include <bits/stdc++.h>
using namespace std;
int main()
{
double r1,r2,p1,p2;cin>>r1>>p1>>r2>>p2;
double r,p;
r=r1*r2*cos(p1)*cos(p2)-r1*r2*sin(p1)*sin(p2);
p=r1*r2*cos(p1)*sin(p2)+r1*r2*cos(p2)*sin(p1);
if(fabs(r)<0.005) r=0;
if(fabs(p)<0.005) p=0;
cout<<fixed<<setprecision(2)<<r;
if(p>=0) cout<<"+";
else cout<<"-" ;
cout<<fixed<<setprecision(2)<<fabs(p)<<"i"<<endl;
return 0;
}
1052 卖个萌 (20分)
20200811（一刷）:
v.push_back(substr(……))
#include <bits/stdc++.h>
using namespace std;
int main()
{
vector<vector <string> > v;
vector<int> shu;
string s;
int m=0;
for(int i=0;i<3;i++)
{
getline(cin,s);
vector<string> r;
int x=0;
int l=s.length();
for(int j=0;j<l;j++)
{
if(s[j]=='[')
{
m=j;
while(m++<l)
{
if(s[m]==']')
{
r.push_back(s.substr(j+1,m-j-1));
x++;
break;
}
}
}
}
shu.push_back(x);
v.push_back(r);
}
int k;cin>>k;
int a,b,c,d,e;
for(int i=0;i<k;i++)
{
cin>>a>>b>>c>>d>>e;
if(a<1||b<1||c<1||d<1||e<1||a>shu[0]||b>shu[1]||c>shu[2]||d>shu[1]||e>shu[0]) cout << "Are you kidding me? @\\/@" << endl;
else cout<<v[0][a-1]<<"("<<v[1][b-1]<<v[2][c-1]<<v[1][d-1]<<")"<<v[0][e-1]<<endl;
}
return 0;
}
1053 住房空置率 (20分)
在不打扰居民的前提下，统计住房空置率的一种方法是根据每户用电量的连续变化规律进行判断。判断方法如下：
在观察期内，若存在超过一半的日子用电量低于某给定的阈值 e，则该住房为“可能空置”；
若观察期超过某给定阈值 D 天，且满足上一个条件，则该住房为“空置”。
现给定某居民区的住户用电量数据，请你统计“可能空置”的比率和“空置”比率，即以上两种状态的住房占居民区住房总套数的百分比。
输入格式：
输入第一行给出正整数 N（≤1000），为居民区住房总套数；正实数 e，即低电量阈值；正整数 D，即观察期阈值。随后 N 行，每行按以下格式给出一套住房的用电量数据：
K E1 E2 … EK
其中 K 为观察的天数，Ei 为第 i 天的用电量。
输出格式：
在一行中输出“可能空置”的比率和“空置”比率的百分比值，其间以一个空格分隔，保留小数点后 1 位。
输入样例：
5 0.5 10
6 0.3 0.4 0.5 0.2 0.8 0.6
10 0.0 0.1 0.2 0.3 0.0 0.8 0.6 0.7 0.0 0.5
5 0.4 0.3 0.5 0.1 0.7
11 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1
11 2 2 2 1 1 0.1 1 0.1 0.1 0.1 0.1
输出样例：
40.0% 20.0%
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,d,kn=0,kz=0;double a;
cin>>n>>a>>d;
for(int i=0;i<n;i++)
{
int k;cin>>k;
int kk=(k/2)+1;int m=0;
double b[k];
for(int j=0;j<k;j++)
{
cin>>b[j];
if(b[j]<a) m++;
}
if(m>=kk&&k>d) kz++;
else if(m>=kk) kn++;
}
double knb=(double)(kn*100)/n;
double kzb=(double)(kz*100)/n;
cout<<fixed<<setprecision(1)<<knb<<"% "<<fixed<<setprecision(1)<<kzb<<"%"<<endl;
return 0;
}
1054 求平均值 (20分)
本题的基本要求非常简单：给定 N 个实数，计算它们的平均值。但复杂的是有些输入数据可能是非法的。一个“合法”的输入是 [−1000,1000] 区间内的实数，并且最多精确到小数点后 2 位。当你计算平均值的时候，不能把那些非法的数据算在内。
输入格式：
输入第一行给出正整数 N（≤100）。随后一行给出 N 个实数，数字间以一个空格分隔。
输出格式：
对每个非法输入，在一行中输出 ERROR: X is not a legal number，其中 X 是输入。最后在一行中输出结果：The average of K numbers is Y，其中 K 是合法输入的个数，Y 是它们的平均值，精确到小数点后 2 位。如果平均值无法计算，则用 Undefined 替换 Y。如果 K 为 1，则输出 The average of 1 number is Y。
输入样例 1：
7
5 -3.2 aaa 9999 2.3.4 7.123 2.35
输出样例 1：
ERROR: aaa is not a legal number
ERROR: 9999 is not a legal number
ERROR: 2.3.4 is not a legal number
ERROR: 7.123 is not a legal number
The average of 3 numbers is 1.38
输入样例 2：
2
aaa -9999
输出样例 2：
ERROR: aaa is not a legal number
ERROR: -9999 is not a legal number
The average of 0 numbers is Undefined
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int cmp(char str1[],char str2[])
{
int l1=strlen(str1);
for(int i=0;i<l1;i++)
{
if(str1[i]!=str2[i]) return 1;
}
return 0;
}
int main()
{
int n;cin>>n;
double sum=0.0;int k=n;
char str1[50],str2[50];
for(int i=0;i<n;i++)
{
double temp;
scanf("%s",str1);
sscanf(str1,"%lf",&temp);
sprintf(str2,"%.2lf",temp);
if(fabs(temp)<=1000&&!cmp(str1,str2)) sum+=temp;
else
{
k--;
printf("ERROR: %s is not a legal number\n",str1);
}
}
if(k==0) printf("The average of 0 numbers is Undefined");
else if(k == 1) printf("The average of 1 number is %.2lf",sum);
else printf("The average of %d numbers is %.2lf",k,sum/k);
return 0;
}
1055 集体照 (25分)
拍集体照时队形很重要，这里对给定的 N 个人 K 排的队形设计排队规则如下：
每排人数为 N/K（向下取整），多出来的人全部站在最后一排；
后排所有人的个子都不比前排任何人矮；
每排中最高者站中间（中间位置为 m/2+1，其中 m 为该排人数，除法向下取整）；
每排其他人以中间人为轴，按身高非增序，先右后左交替入队站在中间人的两侧（例如5人身高为190、188、186、175、170，则队形为175、188、190、186、170。这里假设你面对拍照者，所以你的左边是中间人的右边）；
若多人身高相同，则按名字的字典序升序排列。这里保证无重名。
现给定一组拍照人，请编写程序输出他们的队形。
输入格式：
每个输入包含 1 个测试用例。每个测试用例第 1 行给出两个正整数 N（≤104 ，总人数）和 K（≤10，总排数）。随后 N 行，每行给出一个人的名字（不包含空格、长度不超过 8 个英文字母）和身高（[30, 300] 区间内的整数）。
输出格式：
输出拍照的队形。即K排人名，其间以空格分隔，行末不得有多余空格。注意：假设你面对拍照者，后排的人输出在上方，前排输出在下方。
输入样例：
10 3
Tom 188
Mike 170
Eva 168
Tim 160
Joe 190
Ann 168
Bob 175
Nick 186
Amy 160
John 159
输出样例：
Bob Tom Joe Nick
Ann Mike Eva
Tim Amy John
20200811（一刷）:
先将人按照身高排序，再按差值2的方式输出名字
#include <bits/stdc++.h>
using namespace std;
struct student
{
string name;
int height;
};
int cmp(struct student s1,struct student s2)
{
if(s1.height==s2.height) return s1.name<s2.name;
else return s1.height>s2.height;
}
int main()
{
int n,k;cin>>n>>k;
struct student stu[n];
for(int i=0;i<n;i++) cin>>stu[i].name>>stu[i].height;
sort(stu,stu+n,cmp);
int row=k,count=0;
while(row)
{
int l;
if(row==k) l=n-(n/k)*(k-1);
else l=n/k;
string a[l];
a[l/2]=stu[count].name;
int j=l/2-1;
for (int i=count+1;i<count+l;i=i+2)
{
a[j] = stu[i].name;j--;
}
j = l/2+1;
for (int i=count+2;i<count+l;i=i+2)
{
a[j] = stu[i].name;j++;
}
cout<<a[0];
for (int i=1;i<l;i++)
cout<<" "<<a[i];
cout<<endl;
count+=l;
row--;
}
return 0;
}
1056 组合数的和 (15分)
给定 N 个非 0 的个位数字，用其中任意 2 个数字都可以组合成 1 个 2 位的数字。要求所有可能组合出来的 2 位数字的和。例如给定 2、5、8，则可以组合出：25、28、52、58、82、85，它们的和为330。
输入格式：
输入在一行中先给出 N（1 < N < 10），随后给出 N 个不同的非 0 个位数字。数字间以空格分隔。
输出格式：
输出所有可能组合出来的2位数字的和。
输入样例：
3 2 8 5
输出样例：
330
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;cin>>n;
int a[n];
for(int i=0;i<n;i++) cin>>a[i];
int sum=0;
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
if(a[i]!=0&&a[j]!=0)
{
sum+=a[i]*10+a[j];
sum+=a[j]*10+a[i];
}
}
}
cout<<sum<<endl;
return 0;
}
1057 数零壹 (20分)
给定一串长度不超过 105的字符串，本题要求你将其中所有英文字母的序号（字母 a-z 对应序号 1-26，不分大小写）相加，得到整数 N，然后再分析一下 N 的二进制表示中有多少 0、多少 1。例如给定字符串 PAT (Basic)，其字母序号之和为：16+1+20+2+1+19+9+3=71，而 71 的二进制是 1000111，即有 3 个 0、4 个 1。
输入格式：
输入在一行中给出长度不超过 105 、以回车结束的字符串。
输出格式：
在一行中先后输出 0 的个数和 1 的个数，其间以空格分隔。注意：若字符串中不存在字母，则视为 N 不存在，也就没有 0 和 1。
输入样例：
PAT (Basic)
输出样例：
3 4
20200811（一刷）:
如果总和为0，那么输出应该是“0 0”
#include <bits/stdc++.h>
using namespace std;
int main()
{
int sum=0;int a0=0,a1=0;
string a; getline(cin,a);
int l=a.length();int k=0;
for(int i=0;i<l;i++)
{
if(a[i]==13) break;
if(a[i]>=65&&a[i]<=90)
{
sum+=a[i]-64;k++;
}
if(a[i]>=97&&a[i]<=122)
{
sum+=a[i]-96;k++;
}
}
for(int i=0;;i++)
{
if(sum%2==0) a0++;
else a1++;
sum/=2;
if(sum==0) break;
}
if(k==0) cout<<"0 0"<<endl;
else cout<<a0<<" "<<a1<<endl;
return 0;
}
1058 选择题 (20分)
批改多选题是比较麻烦的事情，本题就请你写个程序帮助老师批改多选题，并且指出哪道题错的人最多。
输入格式：
输入在第一行给出两个正整数 N（≤ 1000）和 M（≤ 100），分别是学生人数和多选题的个数。随后 M 行，每行顺次给出一道题的满分值（不超过 5 的正整数）、选项个数（不少于 2 且不超过 5 的正整数）、正确选项个数（不超过选项个数的正整数）、所有正确选项。注意每题的选项从小写英文字母 a 开始顺次排列。各项间以 1 个空格分隔。最后 N 行，每行给出一个学生的答题情况，其每题答案格式为 (选中的选项个数 选项1 ……)，按题目顺序给出。注意：题目保证学生的答题情况是合法的，即不存在选中的选项数超过实际选项数的情况。
输出格式：
按照输入的顺序给出每个学生的得分，每个分数占一行。注意判题时只有选择全部正确才能得到该题的分数。最后一行输出错得最多的题目的错误次数和编号（题目按照输入的顺序从 1 开始编号）。如果有并列，则按编号递增顺序输出。数字间用空格分隔，行首尾不得有多余空格。如果所有题目都没有人错，则在最后一行输出 Too simple。
输入样例：
3 4
3 4 2 a c
2 5 1 b
5 3 2 b c
1 5 4 a b d e
(2 a c) (2 b d) (2 a c) (3 a b e)
(2 a c) (1 b) (2 a b) (4 a b d e)
(2 b d) (1 e) (2 b c) (4 a b c d)
输出样例：
3
6
5
2 2 3 4
20200811（一刷）:
1.string a;char c;a+=c;//可以直接相加
2.scanf("(");scanf("\n")
#include <bits/stdc++.h>
using namespace std;
struct ti
{
int score;
int option;
int num;
string answer;
};
int main()
{
int n,m;cin>>n>>m;
char c;
int wrong[m];
for(int i=0;i<m;i++) wrong[i]=0;
struct ti t[m];
for(int i=0;i<m;i++)
{
cin>>t[i].score>>t[i].option>>t[i].num;
for(int j=0;j<t[i].num;j++)
{
cin>>c;
t[i].answer+=c;
}
}
int choosenum;
for(int i=0;i<n;i++)
{
int grade=0;
scanf("\n");
for(int j=0;j<m;j++)
{
string choose;
if(j!=0) scanf(" ");
scanf("(");cin>>choosenum;
for(int k=0;k<choosenum;k++)
{
char d;cin>>d;choose+=d;
}
scanf(")");
if(choose==t[j].answer) grade+=t[j].score;
else wrong[j]++;
}
cout<<grade<<endl;
}
int max=0;
for(int i=0;i<m;i++)
{
if(wrong[i]>max) max=wrong[i];
}
if(max==0)
{
cout<<"Too simple"<<endl;
return 0;
}
cout<<max;
for(int i=0;i<m;i++)
{
if(wrong[i]==max) cout<<" "<<i+1;
}
return 0;
}
1059 C语言竞赛 (20分)
C 语言竞赛是浙江大学计算机学院主持的一个欢乐的竞赛。既然竞赛主旨是为了好玩，颁奖规则也就制定得很滑稽：
0、冠军将赢得一份“神秘大奖”（比如很巨大的一本学生研究论文集……）。
1、排名为素数的学生将赢得最好的奖品 —— 小黄人玩偶！
2、其他人将得到巧克力。
给定比赛的最终排名以及一系列参赛者的 ID，你要给出这些参赛者应该获得的奖品。
输入格式：
输入第一行给出一个正整数 N（≤104 ），是参赛者人数。随后 N 行给出最终排名，每行按排名顺序给出一位参赛者的 ID（4 位数字组成）。接下来给出一个正整数 K 以及 K 个需要查询的 ID。
输出格式：
对每个要查询的 ID，在一行中输出 ID: 奖品，其中奖品或者是 Mystery Award（神秘大奖）、或者是 Minion（小黄人）、或者是 Chocolate（巧克力）。如果所查 ID 根本不在排名里，打印 Are you kidding?（耍我呢？）。如果该 ID 已经查过了（即奖品已经领过了），打印 ID: Checked（不能多吃多占）。
输入样例：
6
1111
6666
8888
1234
5555
0001
6
8888
0001
1111
2222
8888
2222
输出样例：
8888: Minion
0001: Chocolate
1111: Mystery Award
2222: Are you kidding?
8888: Checked
2222: Are you kidding?
20200811（一刷）:
判断素数：for(int i=2;i<=sqrt(n);i++)
#include <bits/stdc++.h>
using namespace std;
int su(int n)
{
int pan=0;
for(int i=2;i<sqrt(n)+1;i++)
{
if(n%i==0)
{
pan++;
break;
}
}
return pan;
}
struct student
{
int name;
int jiang;
int pan;
};
int main()
{
int n;cin>>n;
struct student stu[n];
for(int i=0;i<n;i++)
{
cin>>stu[i].name;
if(i==0) stu[i].jiang=0;
else if(su(i+1)==0) stu[i].jiang=1;
else stu[i].jiang=2;
stu[i].pan=0;
}
int k;cin>>k;
for(int i=0;i<k;i++)
{
int m;cin>>m; int ii=0;
for(int j=0;j<n;j++)
{
if(stu[j].name==m)
{
ii++;
if(stu[j].pan==0)
{
cout<<setfill('0')<<setw(4)<<m<<": ";
if(stu[j].jiang==0) cout<<"Mystery Award"<<endl;
else if(stu[j].jiang==1) cout<<"Minion"<<endl;
else cout<<"Chocolate"<<endl;
stu[j].pan=1;
}
else cout<<setfill('0')<<setw(4)<<m<<": Checked"<<endl;
break;
}
}
if(ii==0) cout<<setfill('0')<<setw(4)<<m<<": Are you kidding?"<<endl;
}
return 0;
}
1060 爱丁顿数 (25分)
英国天文学家爱丁顿很喜欢骑车。据说他为了炫耀自己的骑车功力，还定义了一个“爱丁顿数” E ，即满足有 E 天骑车超过 E 英里的最大整数 E。据说爱丁顿自己的 E 等于87。
现给定某人 N 天的骑车距离，请你算出对应的爱丁顿数 E（≤N）。
输入格式：
输入第一行给出一个正整数 N (≤105 )，即连续骑车的天数；第二行给出 N 个非负整数，代表每天的骑车距离。
输出格式：
在一行中给出 N 天的爱丁顿数。
输入样例：
10
6 7 6 9 3 10 8 2 7 8
输出样例：
6
20200811（一刷）:
1.绝对值
int——abs()
double——fabs()
2.将骑行天数排序，再与对应的天数进行比较
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;cin>>n;
int a[n],b[n];
for(int i=0;i<n;i++)
{
cin>>a[i];
b[i]=i+1;
}
sort(a,a+n,greater<int>());
int sum=0;
for(int i=0;i<n;i++)
{
if(a[i]>b[i]) sum++;
else break;
}
cout<<sum<<endl;
return 0;
}
1061 判断题 (15分)
判断题的评判很简单，本题就要求你写个简单的程序帮助老师判题并统计学生们判断题的得分。
输入格式：
输入在第一行给出两个不超过 100 的正整数 N 和 M，分别是学生人数和判断题数量。第二行给出 M 个不超过 5 的正整数，是每道题的满分值。第三行给出每道题对应的正确答案，0 代表“非”，1 代表“是”。随后 N 行，每行给出一个学生的解答。数字间均以空格分隔。
输出格式：
按照输入的顺序输出每个学生的得分，每个分数占一行。
输入样例：
3 6
2 1 3 3 4 5
0 0 1 0 1 1
0 1 1 0 0 1
1 0 1 0 1 0
1 1 0 0 1 1
输出样例：
13
11
12
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
struct ti
{
int score;
int answer;
};
int main()
{
int n,m;cin>>n>>m;
struct ti t[m];
for(int i=0;i<m;i++) cin>>t[i].score;
for(int i=0;i<m;i++) cin>>t[i].answer;
for(int i=0;i<n;i++)
{
int grade=0;
for(int j=0;j<m;j++)
{
int a;cin>>a;
if(a==t[j].answer) grade+=t[j].score;
}
cout<<grade<<endl;
}
return 0;
}
1062 最简分数 (20分)
一个分数一般写成两个整数相除的形式：N/M，其中 M 不为0。最简分数是指分子和分母没有公约数的分数表示形式。
现给定两个不相等的正分数 N1 /M1 和 N2 /M2 ，要求你按从小到大的顺序列出它们之间分母为 K 的最简分数。
输入格式：
输入在一行中按 N/M 的格式给出两个正分数，随后是一个正整数分母 K，其间以空格分隔。题目保证给出的所有整数都不超过 1000。
输出格式：
在一行中按 N/M 的格式列出两个给定分数之间分母为 K 的所有最简分数，按从小到大的顺序，其间以 1 个空格分隔。行首尾不得有多余空格。题目保证至少有 1 个输出。
输入样例：
7/18 13/20 12
输出样例：
5/12 7/12
20200811（一刷）:
需要swap(p1,p2）
#include <bits/stdc++.h>
using namespace std;
int gdb(int x,int y)
{
if(y==0) return x;
else return gdb(y,x%y);
}
int main()
{
int x1,x2,y1,y2,k;char a;cin>>x1>>a>>y1;cin>>x2>>a>>y2;cin>>k;
double p1=(double)x1/y1;double p2=(double)x2/y2;
int pp=0;
if(p1>p2) swap(p1,p2);
for(int i=1;i<k;i++)
{
double p=(double)i/k;
if(p>p1&&p<p2)
{
if(gdb(i,k)==1)
{
if(pp==0)
{
cout<<i<<"/"<<k;
pp=1;
}
else cout<<" "<<i<<"/"<<k;
}
}
}
return 0;
}
1063 计算谱半径 (20分)
在数学中，矩阵的“谱半径”是指其特征值的模集合的上确界。换言之，对于给定的 n 个复数空间的特征值 { a1 +b1 i,⋯,an+bn i }，它们的模为实部与虚部的平方和的开方，而“谱半径”就是最大模。
现在给定一些复数空间的特征值，请你计算并输出这些特征值的谱半径。
输入格式：
输入第一行给出正整数 N（≤ 10 000）是输入的特征值的个数。随后 N 行，每行给出 1 个特征值的实部和虚部，其间以空格分隔。注意：题目保证实部和虚部均为绝对值不超过 1000 的整数。
输出格式：
在一行中输出谱半径，四舍五入保留小数点后 2 位。
输入样例：
5
0 1
2 0
-1 0
3 3
0 -3
输出样例：
4.24
20200811（一刷）:
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;cin>>n;
int max=0;
for(int i=0;i<n;i++)
{
int a,b;cin>>a>>b;
int c=a*a+b*b;
if(c>max) max=c;
}
double d=sqrt(max);
cout<<fixed<<setprecision(2)<<d<<endl;
return 0;
}
1064 朋友数 (20分)
如果两个整数各位数字的和是一样的，则被称为是“朋友数”，而那个公共的和就是它们的“朋友证号”。例如 123 和 51 就是朋友数，因为 1+2+3 = 5+1 = 6，而 6 就是它们的朋友证号。给定一些整数，要求你统计一下它们中有多少个不同的朋友证号。
输入格式：
输入第一行给出正整数 N。随后一行给出 N 个正整数，数字间以空格分隔。题目保证所有数字小于 104。
输出格式：
首先第一行输出给定数字中不同的朋友证号的个数；随后一行按递增顺序输出这些朋友证号，数字间隔一个空格，且行末不得有多余空格。
输入样例：
8
123 899 51 998 27 33 36 12
输出样例：
4
3 6 9 26
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;cin>>n;
int a[n];int b[40];
for(int i=0;i<40;i++) b[i]=0;
for(int i=0;i<n;i++)
{
cin>>a[i];
int sum=0;
while(a[i]!=0)
{
sum+=a[i]%10;
a[i]/=10;
}
b[sum]++;
}
int k=0;
for(int i=0;i<40;i++)
{
if(b[i]!=0) k++;
}
cout<<k<<endl;
int p=0;
for(int i=0;i<40;i++)
{
if(b[i]!=0)
{
if(p==0)
{
cout<<i;p++;
}
else cout<<" "<<i;
}
}
return 0;
}
1065 单身狗 (25分)
“单身狗”是中文对于单身人士的一种爱称。本题请你从上万人的大型派对中找出落单的客人，以便给予特殊关爱。
输入格式：
输入第一行给出一个正整数 N（≤ 50 000），是已知夫妻/伴侣的对数；随后 N 行，每行给出一对夫妻/伴侣——为方便起见，每人对应一个 ID 号，为 5 位数字（从 00000 到 99999），ID 间以空格分隔；之后给出一个正整数 M（≤ 10 000），为参加派对的总人数；随后一行给出这 M 位客人的 ID，以空格分隔。题目保证无人重婚或脚踩两条船。
输出格式：
首先第一行输出落单客人的总人数；随后第二行按 ID 递增顺序列出落单的客人。ID 间用 1 个空格分隔，行的首尾不得有多余空格。
输入样例：
3
11111 22222
33333 44444
55555 66666
7
55555 44444 10000 88888 22222 11111 23333
输出样例：
5
10000 23333 44444 55555 88888
20200811（一刷）:
1.关键点：赋初值不可以赋为0
2.relation[丈夫]=妻子；
temprelation[妻子]=丈夫;
所以temprelation[relation[丈夫]]=丈夫;
#include <bits/stdc++.h>
using namespace std;
int main()
{
long long int relation[100000],tempid[100000],temprelation[100000],gou[100000];
for(int i=0;i<100000;i++)
{
relation[i]=-1;
tempid[i]=-1;
temprelation[i]=-1;
gou[i]=-1;
}
long long int tnum=0,gnum=0;
int n;cin>>n;
for(int i=0;i<n;i++)
{
long long int a,b;cin>>a>>b;
relation[a]=b;relation[b]=a;
}
int m;cin>>m;
for(int i=0;i<m;i++)
{
long long int id;
cin>>id;
tempid[tnum++]=id;
temprelation[id]=relation[id];
}
for(int i=0;i<tnum;i++)
{
long long int id1=tempid[i];
if(temprelation[relation[id1]]!=id1) gou[gnum++]=id1;
}
sort(gou,gou+gnum);
cout<<gnum<<endl;
for(int i=0;i<gnum;i++)
{
if(i!=0) cout<<" ";
cout<<setfill('0')<<setw(5)<<gou[i];
}
return 0;
}
1066 图像过滤 (15分)
图像过滤是把图像中不重要的像素都染成背景色，使得重要部分被凸显出来。现给定一幅黑白图像，要求你将灰度值位于某指定区间内的所有像素颜色都用一种指定的颜色替换。
输入格式：
输入在第一行给出一幅图像的分辨率，即两个正整数 M 和 N（0<M,N≤500），另外是待过滤的灰度值区间端点 A 和 B（0≤A<B≤255）、以及指定的替换灰度值。随后 M 行，每行给出 N 个像素点的灰度值，其间以空格分隔。所有灰度值都在 [0, 255] 区间内。
输出格式：
输出按要求过滤后的图像。即输出 M 行，每行 N 个像素灰度值，每个灰度值占 3 位（例如黑色要显示为 000），其间以一个空格分隔。行首尾不得有多余空格。
输入样例：
3 5 100 150 0
3 189 254 101 119
150 233 151 99 100
88 123 149 0 255
输出样例：
003 189 254 000 000
000 233 151 099 000
088 000 000 000 255
20200811（一刷）:
输入一行直接处理再输出发生运行时间过长，可以用二维数组进行存储再操作输出
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,m;cin>>n>>m;
int a,b,x;cin>>a>>b>>x;
int c[n][m];
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
cin>>c[i][j];
if(c[i][j]>=a&&c[i][j]<=b) c[i][j]=x;
}
}
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
if(j!=0) cout<<" ";
cout<<setfill('0')<<setw(3)<<c[i][j];
}
cout<<endl;
}
return 0;
}
1067 试密码 (20分)
当你试图登录某个系统却忘了密码时，系统一般只会允许你尝试有限多次，当超出允许次数时，账号就会被锁死。本题就请你实现这个小功能。
输入格式：
输入在第一行给出一个密码（长度不超过 20 的、不包含空格、Tab、回车的非空字符串）和一个正整数 N（≤ 10），分别是正确的密码和系统允许尝试的次数。随后每行给出一个以回车结束的非空字符串，是用户尝试输入的密码。输入保证至少有一次尝试。当读到一行只有单个 # 字符时，输入结束，并且这一行不是用户的输入。
输出格式：
对用户的每个输入，如果是正确的密码且尝试次数不超过 N，则在一行中输出 Welcome in，并结束程序；如果是错误的，则在一行中按格式输出 Wrong password: 用户输入的错误密码；当错误尝试达到 N 次时，再输出一行 Account locked，并结束程序。
输入样例 1：
Correct%pw 3
correct%pw
Correct@PW
whatisthepassword!
Correct%pw
输出样例 1：
Wrong password: correct%pw
Wrong password: Correct@PW
Wrong password: whatisthepassword!
Account locked
输入样例 2：
cool@gplt 3
coolman@gplt
coollady@gplt
cool@gplt
try again
输出样例 2：
Wrong password: coolman@gplt
Wrong password: coollady@gplt
Welcome in
20200811（一刷）:
密码不含空格，但用户输入可能含有空格
#include <bits/stdc++.h>
using namespace std;
int main()
{
string a;cin>>a;
int n;cin>>n;
getchar();
string b;
int sum=0;
while(getline(cin,b))
{
if(b=="#") break;
if(a==b)
{
cout<<"Welcome in"<<endl;
break;
}
else
{
cout<<"Wrong password: "<<b<<endl;
sum++;
}
if(sum==n)
{
cout<<"Account locked"<<endl;
break;
}
}
return 0;
}
1068 万绿丛中一点红 (20分)
对于计算机而言，颜色不过是像素点对应的一个 24 位的数值。现给定一幅分辨率为 M×N 的画，要求你找出万绿丛中的一点红，即有独一无二颜色的那个像素点，并且该点的颜色与其周围 8 个相邻像素的颜色差充分大。
输入格式：
输入第一行给出三个正整数，分别是 M 和 N（≤ 1000），即图像的分辨率；以及 TOL，是所求像素点与相邻点的颜色差阈值，色差超过 TOL 的点才被考虑。随后 N 行，每行给出 M 个像素的颜色值，范围在 [0,224 ) 内。所有同行数字间用空格或 TAB 分开。
输出格式：
在一行中按照 (x, y): color 的格式输出所求像素点的位置以及颜色值，其中位置 x 和 y 分别是该像素在图像矩阵中的列、行编号（从 1 开始编号）。如果这样的点不唯一，则输出 Not Unique；如果这样的点不存在，则输出 Not Exist。
输入样例 1：
8 6 200
0 0 0 0 0 0 0 0
65280 65280 65280 16711479 65280 65280 65280 65280
16711479 65280 65280 65280 16711680 65280 65280 65280
65280 65280 65280 65280 65280 65280 165280 165280
65280 65280 16777015 65280 65280 165280 65480 165280
16777215 16777215 16777215 16777215 16777215 16777215 16777215 16777215
输出样例 1：
(5, 3): 16711680
输入样例 2：
4 5 2
0 0 0 0
0 0 3 0
0 0 0 0
0 5 0 0
0 0 0 0
输出样例 2：
Not Unique
输入样例 3：
3 3 5
1 2 3
3 4 5
5 6 7
输出样例 3：
Not Exist
20200811（一刷）:
输出的格式(a,[空格]b）
#include <bits/stdc++.h>
using namespace std;
int n,m,tol,a[1005][1005];
map<int,int>f;
int main()
{
std::ios::sync_with_stdio(false);
cin>>m>>n>>tol;
int xx[8]={0,1,1,1,0,-1,-1,-1};
int yy[8]={-1,-1,0,1,1,1,0,-1};
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
cin>>a[i][j];f[a[i][j]]++;
}
}
int x,y;int count=0;int flag;int result;
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
if(f[a[i][j]]==1)
{
flag=1;
for(int k=0;k<8;k++)
{
int nx=i+xx[k];
int ny=j+yy[k];
if(nx<0||nx==n||ny<0||ny==m) continue;
if(abs(a[i][j]-a[nx][ny])<=tol) flag=0;
}
if(flag)
{
x=i;y=j;count++;
result=a[i][j];
}
}
}
}
if(count==0) cout<<"Not Exist"<<endl;
else if(count==1) cout<<"("<<y+1<<", "<<x+1<<"): "<<result<<endl;
else cout<<"Not Unique"<<endl;
return 0;
}
1069 微博转发抽奖 (20分)
小明 PAT 考了满分，高兴之余决定发起微博转发抽奖活动，从转发的网友中按顺序每隔 N 个人就发出一个红包。请你编写程序帮助他确定中奖名单。
输入格式：
输入第一行给出三个正整数 M（≤ 1000）、N 和 S，分别是转发的总量、小明决定的中奖间隔、以及第一位中奖者的序号（编号从 1 开始）。随后 M 行，顺序给出转发微博的网友的昵称（不超过 20 个字符、不包含空格回车的非空字符串）。
注意：可能有人转发多次，但不能中奖多次。所以如果处于当前中奖位置的网友已经中过奖，则跳过他顺次取下一位。
输出格式：
按照输入的顺序输出中奖名单，每个昵称占一行。如果没有人中奖，则输出 Keep going…。
输入样例 1：
9 3 2
Imgonnawin!
PickMe
PickMeMeMeee
LookHere
Imgonnawin!
TryAgainAgain
TryAgainAgain
Imgonnawin!
TryAgainAgain
输出样例 1：
PickMe
Imgonnawin!
TryAgainAgain
输入样例 2：
2 3 5
Imgonnawin!
PickMe
输出样例 2：
Keep going…
20200811（一刷）:
int times[n]记录冲突
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,k,m;cin>>n>>k>>m;scanf("/n");
string name[n];int times[n];
for(int i=0;i<n;i++)
{
cin>>name[i];scanf("/n");
times[i]=1;
}
int count=0;
for(int i=m-1;i<n;i++)
{
if(times[i]==1)
{
for(int j=i+1;j<n;j++)
{
if(name[j]==name[i]) times[j]++;
}
cout<<name[i]<<endl;
count++;
i+=k-1;
}
}
if(count==0) cout<<"Keep going..."<<endl;
return 0;
}
1070 结绳 (25分)
给定一段一段的绳子，你需要把它们串成一条绳。每次串连的时候，是把两段绳子对折，再如下图所示套接在一起。这样得到的绳子又被当成是另一段绳子，可以再次对折去跟另一段绳子串连。每次串连后，原来两段绳子的长度就会减半。
给定 N 段绳子的长度，你需要找出它们能串成的绳子的最大长度。
输入格式：
每个输入包含 1 个测试用例。每个测试用例第 1 行给出正整数 N (2≤N≤104 )；第 2 行给出 N 个正整数，即原始绳段的长度，数字间以空格分隔。所有整数都不超过104 。
输出格式：
在一行中输出能够串成的绳子的最大长度。结果向下取整，即取为不超过最大长度的最近整数。
输入样例：
8
10 15 12 3 4 13 1 15
输出样例：
14
20200811（一刷）:
floor()函数，把一个小数向下取整
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;cin>>n;
double a[n];
for(int i=0;i<n;i++) cin>>a[i];
sort(a,a+n);
double sum=a[0];
for(int i=1;i<n;i++)
{
sum=(a[i]+sum)/2;
}
cout<<floor(sum)<<endl;
return 0;
}
1071 小赌怡情 (15分)
常言道“小赌怡情”。这是一个很简单的小游戏：首先由计算机给出第一个整数；然后玩家下注赌第二个整数将会比第一个数大还是小；玩家下注 t 个筹码后，计算机给出第二个数。若玩家猜对了，则系统奖励玩家 t 个筹码；否则扣除玩家 t 个筹码。
注意：玩家下注的筹码数不能超过自己帐户上拥有的筹码数。当玩家输光了全部筹码后，游戏就结束。
输入格式：
输入在第一行给出 2 个正整数 T 和 K（≤ 100），分别是系统在初始状态下赠送给玩家的筹码数、以及需要处理的游戏次数。随后 K 行，每行对应一次游戏，顺序给出 4 个数字：n1 b t n2
其中 n1 和 n2 是计算机先后给出的两个[0, 9]内的整数，保证两个数字不相等。b 为 0 表示玩家赌小，为 1 表示玩家赌大。t 表示玩家下注的筹码数，保证在整型范围内。
输出格式：
对每一次游戏，根据下列情况对应输出（其中 t 是玩家下注量，x 是玩家当前持有的筹码量）：
玩家赢，输出 Win t! Total = x.；
玩家输，输出 Lose t. Total = x.；
玩家下注超过持有的筹码量，输出 Not enough tokens. Total = x.；
玩家输光后，输出 Game Over. 并结束程序。
输入样例 1：
100 4
8 0 100 2
3 1 50 1
5 1 200 6
7 0 200 8
输出样例 1：
Win 100! Total = 200.
Lose 50. Total = 150.
Not enough tokens. Total = 150.
Not enough tokens. Total = 150.
输入样例 2：
100 4
8 0 100 2
3 1 200 1
5 1 200 6
7 0 200 8
输出样例 2：
Win 100! Total = 200.
Lose 200. Total = 0.
Game Over.
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
int sum,n;cin>>sum>>n;
for(int i=0;i<n;i++)
{
int a,b,pan,x;cin>>a>>pan>>x>>b;
if(x>sum) cout<<"Not enough tokens. Total = "<<sum<<"."<<endl;
else
{
if((a>b&&pan==0)||(a<b&&pan==1))
{
sum+=x;
cout<<"Win "<<x<<"! Total = "<<sum<<"."<<endl;
}
else
{
sum-=x;
cout<<"Lose "<<x<<". Total = "<<sum<<"."<<endl;
if(sum==0)
{
cout<<"Game Over."<<endl;
break;
}
}
}
}
return 0;
}
1072 开学寄语 (20分)
下图是上海某校的新学期开学寄语：天将降大任于斯人也，必先删其微博，卸其 QQ，封其电脑，夺其手机，收其 ipad，断其 wifi，使其百无聊赖，然后，净面、理发、整衣，然后思过、读书、锻炼、明智、开悟、精进。而后必成大器也！
本题要求你写个程序帮助这所学校的老师检查所有学生的物品，以助其成大器。
输入格式：
输入第一行给出两个正整数 N（≤ 1000）和 M（≤ 6），分别是学生人数和需要被查缴的物品种类数。第二行给出 M 个需要被查缴的物品编号，其中编号为 4 位数字。随后 N 行，每行给出一位学生的姓名缩写（由 1-4 个大写英文字母组成）、个人物品数量 K（0 ≤ K ≤ 10）、以及 K 个物品的编号。
输出格式：
顺次检查每个学生携带的物品，如果有需要被查缴的物品存在，则按以下格式输出该生的信息和其需要被查缴的物品的信息（注意行末不得有多余空格）：
姓名缩写: 物品编号1 物品编号2 ……
最后一行输出存在问题的学生的总人数和被查缴物品的总数。
输入样例：
4 2
2333 6666
CYLL 3 1234 2345 3456
U 4 9966 6666 8888 6666
GG 2 2333 7777
JJ 3 0012 6666 2333
输出样例：
U: 6666 6666
GG: 2333
JJ: 6666 2333
3 5
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,m;cin>>n>>m;
int a[10000];
for(int i=0;i<10000;i++) a[i]=0;
for(int i=0;i<m;i++)
{
int b;cin>>b;
a[b]++;
}
int peo=0,thing=0;
for(int i=0;i<n;i++)
{
string name;cin>>name;
int num;cin>>num;
int flag=0;
for(int j=0;j<num;j++)
{
int d;cin>>d;
if(a[d]!=0)
{
if(flag==0) cout<<name<<":";
cout<<" "<<setfill('0')<<setw(4)<<d;
flag=1;
thing++;
}
}
if(flag==1)
{
peo++;
cout<<endl;
}
}
cout<<peo<<" "<<thing<<endl;
return 0;
}
1073 多选题常见计分法 (20分)
批改多选题是比较麻烦的事情，有很多不同的计分方法。有一种最常见的计分方法是：如果考生选择了部分正确选项，并且没有选择任何错误选项，则得到 50% 分数；如果考生选择了任何一个错误的选项，则不能得分。本题就请你写个程序帮助老师批改多选题，并且指出哪道题的哪个选项错的人最多。
输入格式：
输入在第一行给出两个正整数 N（≤1000）和 M（≤100），分别是学生人数和多选题的个数。随后 M 行，每行顺次给出一道题的满分值（不超过 5 的正整数）、选项个数（不少于 2 且不超过 5 的正整数）、正确选项个数（不超过选项个数的正整数）、所有正确选项。注意每题的选项从小写英文字母 a 开始顺次排列。各项间以 1 个空格分隔。最后 N 行，每行给出一个学生的答题情况，其每题答案格式为 (选中的选项个数 选项1 ……)，按题目顺序给出。注意：题目保证学生的答题情况是合法的，即不存在选中的选项数超过实际选项数的情况。
输出格式：
按照输入的顺序给出每个学生的得分，每个分数占一行，输出小数点后 1 位。最后输出错得最多的题目选项的信息，格式为：错误次数 题目编号（题目按照输入的顺序从1开始编号）-选项号。如果有并列，则每行一个选项，按题目编号递增顺序输出；再并列则按选项号递增顺序输出。行首尾不得有多余空格。如果所有题目都没有人错，则在最后一行输出 Too simple。
输入样例 1：
3 4
3 4 2 a c
2 5 1 b
5 3 2 b c
1 5 4 a b d e
(2 a c) (3 b d e) (2 a c) (3 a b e)
(2 a c) (1 b) (2 a b) (4 a b d e)
(2 b d) (1 e) (1 c) (4 a b c d)
输出样例 1：
3.5
6.0
2.5
2 2-e
2 3-a
2 3-b
输入样例 2：
2 2
3 4 2 a c
2 5 1 b
(2 a c) (1 b)
(2 a c) (1 b)
输出样例 2：
5.0
5.0
Too simple
20200811（一刷）:
思路:
C++ STL:
#include <bits/stdc++.h>
using namespace std;
struct Q
{
int RightNum;
int ChooseNum;
int Grade;
set <char> s;
};
int main()
{
int N, M, ChooseNumStu, wrongMax = 0, AllRight = 0;
char awr;
cin>>N>>M;
int wrongMat[M][5];
memset(wrongMat, 0, sizeof(wrongMat));//赋值为0
struct Q q[M];
for (int i = 0; i < M; i++)
{
scanf("%d %d %d", &q[i].Grade, &q[i].ChooseNum, &q[i].RightNum);
for (int k = 0; k < q[i].RightNum; k++)
{
scanf(" %c", &awr);
q[i].s.insert(awr);//rightanswer
}
}
getchar();
for (int i = 0; i < N; i++)
{
double sum = 0;
for (int j = 0; j < M; j++)
{
set <char> Answer;//answer
set <char>:: iterator it;//iterator
int flag = 0;
scanf("(%d", &ChooseNumStu);
for (int k = 0; k < ChooseNumStu; k++)
{
scanf(" %c", &awr);
Answer.insert(awr);
if (!q[j].s.count(awr))
{
wrongMat[j][awr-'a']++;
if (wrongMat[j][awr - 'a'] > wrongMax) wrongMax = wrongMat[j][awr - 'a'];
flag = 1;
}
}
for (it = q[j].s.begin(); it != q[j].s.end(); it++)
{
if (!Answer.count(*it))
{
AllRight = 1;
wrongMat[j][*it-'a']++;
if (wrongMat[j][*it - 'a'] > wrongMax) wrongMax = wrongMat[j][*it - 'a'];
}
}
scanf(")");
getchar();
if (!flag)
{
if (Answer == q[j].s) sum += q[j].Grade;
else
{
sum += 0.5 * q[j].Grade;
AllRight = 1;
}
}
}
printf("%0.1lf\n", sum);
}
if (!AllRight) printf("Too simple\n");
else
{
for (int i = 0; i < M; i++)
for (int j = 0; j < 5; j++)
if (wrongMat[i][j] == wrongMax) printf("%d %d-%c\n", wrongMax, i+1, j+'a');
}
return 0;
}
1074 宇宙无敌加法器 (20分)
地球人习惯使用十进制数，并且默认一个数字的每一位都是十进制的。而在 PAT 星人开挂的世界里，每个数字的每一位都是不同进制的，这种神奇的数字称为“PAT数”。每个 PAT 星人都必须熟记各位数字的进制表，例如“……0527”就表示最低位是 7 进制数、第 2 位是 2 进制数、第 3 位是 5 进制数、第 4 位是 10 进制数，等等。每一位的进制 d 或者是 0（表示十进制）、或者是 [2，9] 区间内的整数。理论上这个进制表应该包含无穷多位数字，但从实际应用出发，PAT 星人通常只需要记住前 20 位就够用了，以后各位默认为 10 进制。
在这样的数字系统中，即使是简单的加法运算也变得不简单。例如对应进制表“0527”，该如何计算“6203 + 415”呢？我们得首先计算最低位：3 + 5 = 8；因为最低位是 7 进制的，所以我们得到 1 和 1 个进位。第 2 位是：0 + 1 + 1（进位）= 2；因为此位是 2 进制的，所以我们得到 0 和 1 个进位。第 3 位是：2 + 4 + 1（进位）= 7；因为此位是 5 进制的，所以我们得到 2 和 1 个进位。第 4 位是：6 + 1（进位）= 7；因为此位是 10 进制的，所以我们就得到 7。最后我们得到：6203 + 415 = 7201。
输入格式：
输入首先在第一行给出一个 N 位的进制表（0 < N ≤ 20），以回车结束。 随后两行，每行给出一个不超过 N 位的非负的 PAT 数。
输出格式：
在一行中输出两个 PAT 数之和。
输入样例：
30527
06203
415
输出样例：
7201
20200811（一刷）:
是否有进位
#include <bits/stdc++.h>
using namespace std;
int main()
{
string a,b,c;getline(cin,a);getline(cin,b);getline(cin,c);
int la=a.length();int lb=b.length();int lc=c.length();
int l=la;
string nb,nc;
for(int i=0;i<l-lb;i++) nb+='0';
for(int i=l-lb;i<l;i++) nb+=b[i-l+lb];
for(int i=0;i<l-lc;i++) nc+='0';
for(int i=l-lc;i<l;i++) nc+=c[i-l+lc];
int result[30];for(int i=0;i<30;i++) result[i]=0;
int count=0;
int jin=0,wei=0;
for(int i=l-1;i>=0;i--)
{
int x=nb[i]-'0'+nc[i]-'0';
int y=a[i]-'0';
if(y==0) y=10;
wei=(jin+x)%y;
jin=(jin+x)/y;
result[count]=wei;count++;
}
if(jin>0)
{
result[count]=jin;count++;
}
int flag=0;int biao=0;
for(int i=29;i>=0;i--)
{
if(result[i]!=0)
{
flag=1;biao++;
}
if(flag==1) cout<<result[i];
}
if(biao==0) cout<<"0";
cout<<endl;
return 0;
}
1075 链表元素分类 (25分)
给定一个单链表，请编写程序将链表元素进行分类排列，使得所有负值元素都排在非负值元素的前面，而 [0, K] 区间内的元素都排在大于 K 的元素前面。但每一类内部元素的顺序是不能改变的。例如：给定链表为 18→7→-4→0→5→-6→10→11→-2，K 为 10，则输出应该为 -4→-6→-2→7→0→5→10→18→11。
输入格式：
每个输入包含一个测试用例。每个测试用例第 1 行给出：第 1 个结点的地址；结点总个数，即正整数N (≤105 )；以及正整数K (≤103 )。结点的地址是 5 位非负整数，NULL 地址用 −1 表示。
接下来有 N 行，每行格式为：
Address Data Next
其中 Address 是结点地址；Data 是该结点保存的数据，为 [−105,105 ] 区间内的整数；Next 是下一结点的地址。题目保证给出的链表不为空。
输出格式：
对每个测试用例，按链表从头到尾的顺序输出重排后的结果链表，其上每个结点占一行，格式与输入相同。
输入样例：
00100 9 10
23333 10 27777
00000 0 99999
00100 18 12309
68237 -6 23333
33218 -4 00000
48652 -2 -1
99999 5 68237
27777 11 48652
12309 7 33218
输出样例：
33218 -4 68237
68237 -6 48652
48652 -2 12309
12309 7 00000
00000 0 99999
99999 5 23333
23333 10 00100
00100 18 27777
27777 11 -1
20200811（一刷）:
思路：
atoi()——stoi()：
#include <bits/stdc++.h>
using namespace std;
const int maxn=100010;
struct node
{
int adr;
int data;
int next;
int order=3*maxn;
};
bool cmp(struct node n1,struct node n2)
{
return n1.order<n2.order;
}
int main()
{
std::ios::sync_with_stdio(false);
int hadr,n,k,adr;cin>>hadr>>n>>k;
struct node nds[maxn];
for(int i=0; i<n; i++)
{
cin>>adr;nds[adr].adr=adr;
cin>>nds[adr].data>>nds[adr].next;
}
int cnt1=0,cnt2=0,cnt3=0;
for(int i=hadr; i!=-1; i=nds[i].next)
{
if(nds[i].data<0)nds[i].order=cnt1++;
if(nds[i].data>=0&&nds[i].data<=k)nds[i].order=maxn+cnt2++;
if(nds[i].data>k)nds[i].order=2*maxn+cnt3++;
}
sort(nds,nds+maxn,cmp);
int cnt=cnt1+cnt2+cnt3;
for(int i=0;i<cnt-1;i++) cout<<setfill('0')<<setw(5)<<nds[i].adr<<" "<<nds[i].data<<" "<<setfill('0')<<setw(5)<<nds[i+1].adr<<endl;
cout<<setfill('0')<<setw(5)<<nds[cnt-1].adr<<" "<<nds[cnt-1].data<<" -1"<<endl;
return 0;
}
1076 Wifi密码 (15分)
下面是微博上流传的一张照片：“各位亲爱的同学们，鉴于大家有时需要使用 wifi，又怕耽误亲们的学习，现将 wifi 密码设置为下列数学题答案：A-1；B-2；C-3；D-4；请同学们自己作答，每两日一换。谢谢合作！！~”—— 老师们为了促进学生学习也是拼了…… 本题就要求你写程序把一系列题目的答案按照卷子上给出的对应关系翻译成 wifi 的密码。这里简单假设每道选择题都有 4 个选项，有且只有 1 个正确答案。
输入格式：
输入第一行给出一个正整数 N（≤ 100），随后 N 行，每行按照 编号-答案 的格式给出一道题的 4 个选项，T 表示正确选项，F 表示错误选项。选项间用空格分隔。
输出格式：
在一行中输出 wifi 密码。
输入样例：
8
A-T B-F C-F D-F
C-T B-F A-F D-F
A-F D-F C-F B-T
B-T A-F C-F D-F
B-F D-T A-F C-F
A-T C-F B-F D-F
D-T B-F C-F A-F
C-T A-F B-F D-F
输出样例：
13224143
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int print(char n)
{
if(n=='A') return 1;
else if(n=='B') return 2;
else if(n=='C') return 3;
else if(n=='D') return 4;
}
int main()
{
int n;cin>>n;
int x[n];
for(int i=0;i<n;i++)
{
string a,b,c,d;
cin>>a>>b>>c>>d;
if(a[2]=='T') x[i]=print(a[0]);
else if(b[2]=='T') x[i]=print(b[0]);
else if(c[2]=='T') x[i]=print(c[0]);
else if(d[2]=='T') x[i]=print(d[0]);
}
for(int i=0;i<n;i++) cout<<x[i];
cout<<endl;
return 0;
}
1077 互评成绩计算 (20分)
在浙大的计算机专业课中，经常有互评分组报告这个环节。一个组上台介绍自己的工作，其他组在台下为其表现评分。最后这个组的互评成绩是这样计算的：所有其他组的评分中，去掉一个最高分和一个最低分，剩下的分数取平均分记为 G1 ；老师给这个组的评分记为 G2 。该组得分为 (G1+G2 )/2，最后结果四舍五入后保留整数分。本题就要求你写个程序帮助老师计算每个组的互评成绩。
输入格式：
输入第一行给出两个正整数 N（> 3）和 M，分别是分组数和满分，均不超过 100。随后 N 行，每行给出该组得到的 N 个分数（均保证为整型范围内的整数），其中第 1 个是老师给出的评分，后面 N−1 个是其他组给的评分。合法的输入应该是 [0,M] 区间内的整数，若不在合法区间内，则该分数须被忽略。题目保证老师的评分都是合法的，并且每个组至少会有 3 个来自同学的合法评分。
输出格式：
为每个组输出其最终得分。每个得分占一行。
输入样例：
6 50
42 49 49 35 38 41
36 51 50 28 -1 30
40 36 41 33 47 49
30 250 -25 27 45 31
48 0 0 50 50 1234
43 41 36 29 42 29
输出样例：
42
33
41
31
37
39
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,m;cin>>n>>m;
for(int i=0;i<n;i++)
{
double sum=0;int a;int k=0;
int max=0,min=m;int b;
for(int j=0;j<n;j++)
{
cin>>a;
if(j==0) b=a;
else{
if(a>=0&&a<=m)
{
k++;
if(a>=max) max=a;
if(a<=min) min=a;
sum+=a;
}}
}
sum=sum-max-min;
k-=2;
double x1=(double)sum/k;
double x2=(double)(x1+b)/2;
int p=floor(x2*10);
if(p%10>=5)
{
p/=10;p++;
}
else p/=10;
cout<<p<<endl;
}
return 0;
}
1078 字符串压缩与解压 (20分)
文本压缩有很多种方法，这里我们只考虑最简单的一种：把由相同字符组成的一个连续的片段用这个字符和片段中含有这个字符的个数来表示。例如 ccccc 就用 5c 来表示。如果字符没有重复，就原样输出。例如 aba 压缩后仍然是 aba。
解压方法就是反过来，把形如 5c 这样的表示恢复为 ccccc。
本题需要你根据压缩或解压的要求，对给定字符串进行处理。这里我们简单地假设原始字符串是完全由英文字母和空格组成的非空字符串。
输入格式：
输入第一行给出一个字符，如果是 C 就表示下面的字符串需要被压缩；如果是 D 就表示下面的字符串需要被解压。第二行给出需要被压缩或解压的不超过 1000 个字符的字符串，以回车结尾。题目保证字符重复个数在整型范围内，且输出文件不超过 1MB。
输出格式：
根据要求压缩或解压字符串，并在一行中输出结果。
输入样例 1：
C
TTTTThhiiiis isssss a tesssst CAaaa as
输出样例 1：
5T2h4is i5s a3 te4st CA3a as
输入样例 2：
D
5T2h4is i5s a3 te4st CA3a as10Z
输出样例 2：
TTTTThhiiiis isssss a tesssst CAaaa asZZZZZZZZZZ
20200811（一刷）:
string：
思路：
#include <bits/stdc++.h>
using namespace std;
int to_string(string s)
{
stringstream ss;
int n;
ss<<s;
ss>>n;
return n;
}
int main()
{
string s1,s2;getline(cin,s1);getline(cin,s2);
int l=s2.length();
if(s1=="C")
{
int count=0;s2=s2+"0";
for(int i=1;i<l+1;i++)
{
if(s2[i]==s2[i-1]) count++;
else
{
if(count==0) cout<<s2[i-1];
else cout<<count+1<<s2[i-1];
count=0;
}
}
}
else
{
for(int i=0;i<l;i++)
{
string count="";
while(s2[i]>='0'&&s2[i]<='9')
{
count+=s2[i];
i++;
}
if(!count.compare("")) cout<<s2[i];
else
{
int num=to_string(count);
for(int j=0;j<num;j++) cout<<s2[i];
count="";
}
}
}
return 0;
}
1079 延迟的回文数 (20分)
给定一个 k+1 位的正整数 N，写成 ak ⋯a1 a0 的形式，其中对所有 i 有 0≤ai <10 且 ak >0。N 被称为一个回文数，当且仅当对所有 i 有 ai =ak−i 。零也被定义为一个回文数。
非回文数也可以通过一系列操作变出回文数。首先将该数字逆转，再将逆转数与该数相加，如果和还不是一个回文数，就重复这个逆转再相加的操作，直到一个回文数出现。如果一个非回文数可以变出回文数，就称这个数为延迟的回文数。（定义翻译自 https://en.wikipedia.org/wiki/Palindromic_number ）
给定任意一个正整数，本题要求你找到其变出的那个回文数。
输入格式：
输入在一行中给出一个不超过1000位的正整数。
输出格式：
对给定的整数，一行一行输出其变出回文数的过程。每行格式如下
A + B = C
其中 A 是原始的数字，B 是 A 的逆转数，C 是它们的和。A 从输入的整数开始。重复操作直到 C 在 10 步以内变成回文数，这时在一行中输出 C is a palindromic number.；或者如果 10 步都没能得到回文数，最后就在一行中输出 Not found in 10 iterations.。
输入样例 1：
97152
输出样例 1：
97152 + 25179 = 122331
122331 + 133221 = 255552
255552 is a palindromic number.
输入样例 2：
196
输出样例 2：
196 + 691 = 887
887 + 788 = 1675
1675 + 5761 = 7436
7436 + 6347 = 13783
13783 + 38731 = 52514
52514 + 41525 = 94039
94039 + 93049 = 187088
187088 + 880781 = 1067869
1067869 + 9687601 = 10755470
10755470 + 07455701 = 18211171
Not found in 10 iterations.
20200811（一刷）:
最后的进位不要忘记
#include <bits/stdc++.h>
using namespace std;
int main()
{
string n;cin>>n;
int count=0;int pan=0;
while(count<10)
{
string m=n; reverse(m.begin(),m.end());
if(m==n)
{
cout<<n<<" is a palindromic number."<<endl;
pan=1;
break;
}
int l=n.length();
string c;int jin=0;
for(int i=l-1;i>=0;i--)
{
int x=jin+n[i]-'0'+m[i]-'0';
jin=x/10;
c+=x%10+'0';
}
if(jin!=0) c+=jin+'0';
reverse(c.begin(),c.end());
cout<<n<<" + "<<m<<" = "<<c<<endl;
n=c;
count++;
}
if(pan==0) cout<<"Not found in 10 iterations."<<endl;
return 0;
}
1080 MOOC期终成绩 (25分)
对于在中国大学MOOC（http://www.icourse163.org/ ）学习“数据结构”课程的学生，想要获得一张合格证书，必须首先获得不少于200分的在线编程作业分，然后总评获得不少于60分（满分100）。总评成绩的计算公式为 G=(Gmid−term ×40%+Gfinal ×60%)，如果 Gmid−term>Gfinal ；否则总评 G 就是 Gfinal 。这里 Gmid−term和 Gfinal分别为学生的期中和期末成绩。
现在的问题是，每次考试都产生一张独立的成绩单。本题就请你编写程序，把不同的成绩单合为一张。
输入格式：
输入在第一行给出3个整数，分别是 P（做了在线编程作业的学生数）、M（参加了期中考试的学生数）、N（参加了期末考试的学生数）。每个数都不超过10000。
接下来有三块输入。第一块包含 P 个在线编程成绩 Gp ；第二块包含 M 个期中考试成绩 Gmid−term ；第三块包含 N 个期末考试成绩 Gfinal 。每个成绩占一行，格式为：学生学号 分数。其中学生学号为不超过20个字符的英文字母和数字；分数是非负整数（编程总分最高为900分，期中和期末的最高分为100分）。
输出格式：
打印出获得合格证书的学生名单。每个学生占一行，格式为：
学生学号 GpGmid−termGfinalG
如果有的成绩不存在（例如某人没参加期中考试），则在相应的位置输出“−1”。输出顺序为按照总评分数（四舍五入精确到整数）递减。若有并列，则按学号递增。题目保证学号没有重复，且至少存在1个合格的学生。
输入样例：
6 6 7
01234 880
a1903 199
ydjh2 200
wehu8 300
dx86w 220
missing 400
ydhfu77 99
wehu8 55
ydjh2 98
dx86w 88
a1903 86
01234 39
ydhfu77 88
a1903 66
01234 58
wehu8 84
ydjh2 82
missing 99
dx86w 81
输出样例：
missing 400 -1 99 99
ydjh2 200 98 82 88
dx86w 220 88 81 84
wehu8 300 55 84 84
20200811（一刷）:
思路：
#include <bits/stdc++.h>
using namespace std;
struct node
{
string name;
int pro;
int mid;
int fin;
int score;
};
bool cmp(struct node n1,struct node n2)
{
if(n1.score!=n2.score) return n1.score>n2.score;
else return n1.name<n2.name;
}
int main()
{
std::ios::sync_with_stdio(false);
int p,m,f;cin>>p>>m>>f;
string a;int b;
map<string,int> ids;
vector<node> v,ans;
int count=1;
for(int i=0;i<p;i++)
{
cin>>a>>b;
if(b>=200)
{
ids[a]=count++;
v.push_back(node{a,b,-1,-1,0});
}
}
for(int i=0;i<m;i++)
{
cin>>a>>b;
if(ids[a]!=0) v[ids[a]-1].mid=b;
}
for(int i=0;i<f;i++)
{
cin>>a>>b;
if(ids[a]!=0)
{
int temp=ids[a]-1;
v[temp].fin=b;
if(v[temp].mid>v[temp].fin) v[temp].score=0.4*v[temp].mid+0.6*v[temp].fin+0.5;
else v[temp].score=v[temp].fin;
}
}
//for(int i=0;i<v.size();i++) if(v[i].score>=60) ans.push_back(v[i]);
sort(v.begin(),v.end(),cmp);
for(int i=0;i<v.size();i++) if(v[i].score>=60) cout<<v[i].name<<" "<<v[i].pro<<" "<<v[i].mid<<" "<<v[i].fin<<" "<<v[i].score<<endl;
return 0;
}
1081 检查密码 (15分)
本题要求你帮助某网站的用户注册模块写一个密码合法性检查的小功能。该网站要求用户设置的密码必须由不少于6个字符组成，并且只能有英文字母、数字和小数点 .，还必须既有字母也有数字。
输入格式：
输入第一行给出一个正整数 N（≤ 100），随后 N 行，每行给出一个用户设置的密码，为不超过 80 个字符的非空字符串，以回车结束。
输出格式：
对每个用户的密码，在一行中输出系统反馈信息，分以下5种：
如果密码合法，输出Your password is wan mei.；
如果密码太短，不论合法与否，都输出Your password is tai duan le.；
如果密码长度合法，但存在不合法字符，则输出Your password is tai luan le.；
如果密码长度合法，但只有字母没有数字，则输出Your password needs shu zi.；
如果密码长度合法，但只有数字没有字母，则输出Your password needs zi mu.。
输入样例：
5
123s
zheshi.wodepw
1234.5678
WanMei23333
pass*word.6
输出样例：
Your password is tai duan le.
Your password needs shu zi.
Your password needs zi mu.
Your password is wan mei.
Your password is tai luan le.
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;cin>>n;getchar();
for(int i=0;i<n;i++)
{
string a; getline(cin,a);
int l=a.length();
if(l<6) cout<<"Your password is tai duan le."<<endl;
else
{
int s=0,y=0;int pan=0;
for(int i=0;i<l;i++)
{
if((a[i]>='a'&&a[i]<='z')||(a[i]>='A'&&a[i]<='Z')) y++;
else if(a[i]>='0'&&a[i]<='9') s++;
else
{
if(a[i]!='.') pan++;
}
}
if(pan==0)
{
if(s==0) cout<<"Your password needs shu zi."<<endl;
else if(y==0) cout<<"Your password needs zi mu."<<endl;
else cout<<"Your password is wan mei."<<endl;
}
else cout<<"Your password is tai luan le."<<endl;
}
}
}
1082
忘记写博客了，二刷的时候在补上！
1083 是否存在相等的差 (20分)
给定 N 张卡片，正面分别写上 1、2、……、N，然后全部翻面，洗牌，在背面分别写上 1、2、……、N。将每张牌的正反两面数字相减（大减小），得到 N 个非负差值，其中是否存在相等的差？
输入格式：
输入第一行给出一个正整数 N（2 ≤ N ≤ 10 000），随后一行给出 1 到 N 的一个洗牌后的排列，第 i 个数表示正面写了 i 的那张卡片背面的数字。
输出格式：
按照“差值 重复次数”的格式从大到小输出重复的差值及其重复的次数，每行输出一个结果。
输入样例：
8
3 5 8 6 2 1 4 7
输出样例：
5 2
3 3
2 2
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;cin>>n;int a[10005];
for(int i=0;i<10005;i++) a[i]=0;
for(int i=0;i<n;i++)
{
int b;cin>>b;
a[abs(i+1-b)]++;
}
for(int i=10004;i>=0;i--)
{
if(a[i]>1) cout<<i<<" "<<a[i]<<endl;
}
return 0;
}
1084 外观数列 (20分)
外观数列是指具有以下特点的整数序列：
d, d1, d111, d113, d11231, d112213111, …
它从不等于 1 的数字 d 开始，序列的第 n+1 项是对第 n 项的描述。比如第 2 项表示第 1 项有 1 个 d，所以就是 d1；第 2 项是 1 个 d（对应 d1）和 1 个 1（对应 11），所以第 3 项就是 d111。又比如第 4 项是 d113，其描述就是 1 个 d，2 个 1，1 个 3，所以下一项就是 d11231。当然这个定义对 d = 1 也成立。本题要求你推算任意给定数字 d 的外观数列的第 N 项。
输入格式：
输入第一行给出 [0,9] 范围内的一个整数 d、以及一个正整数 N（≤ 40），用空格分隔。
输出格式：
在一行中给出数字 d 的外观数列的第 N 项。
输入样例：
1 8
输出样例：
1123123111
20200811（一刷）:
题目比较难理解，需要仔细分析好好看看
错误：
正确：
#include <bits/stdc++.h>
using namespace std;
int main()
{
string d;int n;cin>>d>>n;
while(n>1)
{
string answer;int count=0;char a=d[0];
for(int i=0;i<d.length();i++)
{
if(d[i]==a) count++;
else
{
answer+=a;
answer+=count+'0';
a=d[i];
count=1;
}
}
answer+=a;
answer+=count+'0';
d=answer;
n--;
}
cout<<d<<endl;
return 0;
}
1085 PAT单位排行 (25分)
每次 PAT 考试结束后，考试中心都会发布一个考生单位排行榜。本题就请你实现这个功能。
输入格式：
输入第一行给出一个正整数 N（≤105 ），即考生人数。随后 N 行，每行按下列格式给出一个考生的信息：
准考证号 得分 学校
其中准考证号是由 6 个字符组成的字符串，其首字母表示考试的级别：B代表乙级，A代表甲级，T代表顶级；得分是 [0, 100] 区间内的整数；学校是由不超过 6 个英文字母组成的单位码（大小写无关）。注意：题目保证每个考生的准考证号是不同的。
输出格式：
首先在一行中输出单位个数。随后按以下格式非降序输出单位的排行榜：
排名 学校 加权总分 考生人数
其中排名是该单位的排名（从 1 开始）；学校是全部按小写字母输出的单位码；加权总分定义为乙级总分/1.5 + 甲级总分 + 顶级总分*1.5的整数部分；考生人数是该属于单位的考生的总人数。
学校首先按加权总分排行。如有并列，则应对应相同的排名，并按考生人数升序输出。如果仍然并列，则按单位码的字典序输出。
输入样例：
10
A57908 85 Au
B57908 54 LanX
A37487 60 au
T28374 67 CMU
T32486 24 hypu
A66734 92 cmu
B76378 71 AU
A47780 45 lanx
A72809 100 pku
A03274 45 hypu
输出样例：
5
1 cmu 192 2
1 au 192 3
3 pku 100 1
4 hypu 81 2
4 lanx 81 2
20200811（一刷）:
思路：
#include <bits/stdc++.h>
using namespace std;
struct school
{
string name;
int grade;
int people;
int rank;
}S[100001];
int cmp(struct school s1,struct school s2)
{
if (s1.grade != s2.grade) return s1.grade > s2.grade;
else
{
if (s1.people != s2.people) return s1.people < s2.people;
else return s1.name<s2.name;
}
}
string ToLower(string s)
{
for (int i = 0; i < s.length(); i++) s[i] = tolower(s[i]);
return s;
}
int main()
{
std::ios::sync_with_stdio(false);
int n,idx = 0;double grade;
string id, name;cin>>n;
map <string, double> mGrade, mNum, mName;
for (int i = 0; i < n; i++)
{
cin>>id>>grade>>name;
name=ToLower(name);
if (!mName[name])
{
S[idx++].name=name;
mName[name]++;
}
mNum[name]++;
if (id[0] == 'T') mGrade[name] += grade*1.5;
else if (id[0] == 'A') mGrade[name] += grade;
else mGrade[name] += grade/1.5;
}
for (int i = 0; i < idx; i++)
{
S[i].grade = (int)mGrade[S[i].name];
S[i].people = mNum[S[i].name];
}
sort(S, S+idx, cmp);
cout<<idx<<endl;
S[0].rank = 1;
cout << 1 << " " << S[0].name << " " << S[0].grade << " " << S[0].people << endl;
for (int i = 1; i < idx; i++)
{
if (S[i].grade == S[i-1].grade) S[i].rank = S[i-1].rank;
else S[i].rank = i+1;
cout<<S[i].rank<<" "<<S[i].name<<" "<<S[i].grade<<" "<<S[i].people<<endl;
}
return 0;
}
1086 就不告诉你 (15分)
做作业的时候，邻座的小盆友问你：“五乘以七等于多少？”你应该不失礼貌地围笑着告诉他：“五十三。”本题就要求你，对任何一对给定的正整数，倒着输出它们的乘积。
输入格式：
输入在第一行给出两个不超过 1000 的正整数 A 和 B，其间以空格分隔。
输出格式：
在一行中倒着输出 A 和 B 的乘积。
输入样例：
5 7
输出样例：
53
20200811（一刷）:
关键点：101*10=1010
不是0101，或者11
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,m;cin>>n>>m;
long long int sum=n*m;
int biao=0;
for(int i=0;;i++)
{
if(sum%10!=0) biao=1;
if(biao==1) cout<<sum%10;
sum/=10;
if(sum==0) break;
}
cout<<endl;
return 0;
}
1087 有多少不同的值 (20分)
当自然数 n 依次取 1、2、3、……、N 时，算式 ⌊n/2⌋+⌊n/3⌋+⌊n/5⌋ 有多少个不同的值？（注：⌊x⌋ 为取整函数，表示不超过 x 的最大自然数，即 x 的整数部分。）
输入格式：
输入给出一个正整数 N（2≤N≤104）。
输出格式：
在一行中输出题面中算式取到的不同值的个数。
输入样例：
2017
输出样例：
1480
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;cin>>n;
int b[20000];
for(int i=0;i<20000;i++) b[i]=0;
for(int i=1;i<=n;i++)
{
int x=i/2+i/3+i/5;
b[x]++;
}
int sum=0;
for(int i=0;i<20000;i++)
{
if(b[i]!=0) sum++;
}
cout<<sum<<endl;
return 0;
}
1088 三人行 (20分)
子曰：“三人行，必有我师焉。择其善者而从之，其不善者而改之。”
本题给定甲、乙、丙三个人的能力值关系为：甲的能力值确定是 2 位正整数；把甲的能力值的 2 个数字调换位置就是乙的能力值；甲乙两人能力差是丙的能力值的 X 倍；乙的能力值是丙的 Y 倍。请你指出谁比你强应“从之”，谁比你弱应“改之”。
输入格式：
输入在一行中给出三个数，依次为：M（你自己的能力值）、X 和 Y。三个数字均为不超过 1000 的正整数。
输出格式：
在一行中首先输出甲的能力值，随后依次输出甲、乙、丙三人与你的关系：如果其比你强，输出 Cong；平等则输出 Ping；比你弱则输出 Gai。其间以 1 个空格分隔，行首尾不得有多余空格。
注意：如果解不唯一，则以甲的最大解为准进行判断；如果解不存在，则输出 No Solution。
输入样例 1：
48 3 7
输出样例 1：
48 Ping Cong Gai
输入样例 2：
48 11 6
输出样例 2：
No Solution
20200811（一刷）:
输出的是甲的值而不是自己的值
#include <bits/stdc++.h>
using namespace std;
void print(double n,int i)
{
double ii=(double)i;
if(n>ii) cout<<" Cong";
else if(n==ii) cout<<" Ping";
else cout<<" Gai";
}
int main()
{
int i,x,y;cin>>i>>x>>y;
double a,b,c;int biao=0;
for(int j=99;j>=10;j--)
{
a=j;
b=j%10*10+j/10;
c=abs(a-b)*1.0/x;
if(b==c*y)
{
biao++;
break;
}
}
if(biao==0) cout<<"No Solution"<<endl;
else
{
cout<<a;print(a,i);print(b,i);print(c,i);cout<<endl;
}
return 0;
}
1089 狼人杀-简单版 (20分)
以下文字摘自《灵机一动·好玩的数学》：“狼人杀”游戏分为狼人、好人两大阵营。在一局“狼人杀”游戏中，1 号玩家说：“2 号是狼人”，2 号玩家说：“3 号是好人”，3 号玩家说：“4 号是狼人”，4 号玩家说：“5 号是好人”，5 号玩家说：“4 号是好人”。已知这 5 名玩家中有 2 人扮演狼人角色，有 2 人说的不是实话，有狼人撒谎但并不是所有狼人都在撒谎。扮演狼人角色的是哪两号玩家？
本题是这个问题的升级版：已知 N 名玩家中有 2 人扮演狼人角色，有 2 人说的不是实话，有狼人撒谎但并不是所有狼人都在撒谎。要求你找出扮演狼人角色的是哪几号玩家？
输入格式：
输入在第一行中给出一个正整数 N（5≤N≤100）。随后 N 行，第 i 行给出第 i 号玩家说的话（1≤i≤N），即一个玩家编号，用正号表示好人，负号表示狼人。
输出格式：
如果有解，在一行中按递增顺序输出 2 个狼人的编号，其间以空格分隔，行首尾不得有多余空格。如果解不唯一，则输出最小序列解 —— 即对于两个序列 A=a[1],…,a[M] 和 B=b[1],…,b[M]，若存在 0≤k<M 使得 a[i]=b[i] （i≤k），且 a[k+1]<b[k+1]，则称序列 A 小于序列 B。若无解则输出 No Solution。
输入样例 1：
5
-2
+3
-4
+5
+4
输出样例 1：
1 4
输入样例 2：
6
+6
+3
+1
-5
-2
+4
输出样例 2（解不唯一）：
1 5
输入样例 3：
5
-2
-3
-4
-5
-1
输出样例 3：
No Solution
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;cin>>n;
vector<int> say(n+1);
for(int i=1;i<=n;i++) cin>>say[i];
for(int i=1;i<=n;i++)
{
for(int j=i+1;j<=n;j++)
{
vector<int> she(n+1,1);
she[i]=-1;she[j]=-1;
vector<int> lie;
for(int k=1;k<=n;k++) if(say[k]*she[abs(say[k])]<0) lie.push_back(k);
if(lie.size()==2&&she[lie[0]]+she[lie[1]]==0)
{
cout<<i<<" "<<j<<endl;
return 0;
}
}
}
cout<<"No Solution"<<endl;
return 0;
}
1090 危险品装箱 (25分)
集装箱运输货物时，我们必须特别小心，不能把不相容的货物装在一只箱子里。比如氧化剂绝对不能跟易燃液体同箱，否则很容易造成爆炸。
本题给定一张不相容物品的清单，需要你检查每一张集装箱货品清单，判断它们是否能装在同一只箱子里。
输入格式：
输入第一行给出两个正整数：N (≤104) 是成对的不相容物品的对数；M (≤100) 是集装箱货品清单的单数。
随后数据分两大块给出。第一块有 N 行，每行给出一对不相容的物品。第二块有 M 行，每行给出一箱货物的清单，格式如下：
K G[1] G[2] … G[K]
其中 K (≤1000) 是物品件数，G[i] 是物品的编号。简单起见，每件物品用一个 5 位数的编号代表。两个数字之间用空格分隔。
输出格式：
对每箱货物清单，判断是否可以安全运输。如果没有不相容物品，则在一行中输出 Yes，否则输出 No。
输入样例：
6 3
20001 20002
20003 20004
20005 20006
20003 20001
20005 20004
20004 20006
4 00001 20004 00002 20003
5 98823 20002 20003 20006 10010
3 12345 67890 23333
输出样例：
No
Yes
Yes
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
std::ios::sync_with_stdio(false);
int n,k,t1,t2;scanf("%d%d",&n,&k);
map<int,vector<int> > m;
for (int i = 0; i < n; i++)
{
scanf("%d%d", &t1, &t2);
m[t1].push_back(t2);
m[t2].push_back(t1);
}
while (k--)
{
int cnt, flag = 0, a[100000] = {0};
scanf("%d", &cnt);
vector<int> v(cnt);
for (int i = 0; i < cnt; i++)
{
scanf("%d", &v[i]);
a[v[i]] = 1;
}
for (int i = 0; i < v.size(); i++)
for (int j = 0; j < m[v[i]].size(); j++)
if (a[m[v[i]][j]] == 1) flag = 1;
if(flag==1) cout<<"No"<<endl;
else cout<<"Yes"<<endl;
}
return 0;
}
1091 N-自守数 (15分)
如果某个数 K 的平方乘以 N 以后，结果的末尾几位数等于 K，那么就称这个数为“N-自守数”。例如 3×922 =25392，而 25392 的末尾两位正好是 92，所以 92 是一个 3-自守数。
本题就请你编写程序判断一个给定的数字是否关于某个 N 是 N-自守数。
输入格式：
输入在第一行中给出正整数 M（≤20），随后一行给出 M 个待检测的、不超过 1000 的正整数。
输出格式：
对每个需要检测的数字，如果它是 N-自守数就在一行中输出最小的 N 和 NK2的值，以一个空格隔开；否则输出 No。注意题目保证 N<10。
输入样例：
3
92 5 233
输出样例：
3 25392
1 25
No
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;cin>>n;
for(int i=0;i<n;i++)
{
int k;cin>>k;
int m=k;int a=1;
while(m!=0)
{
m/=10;
a*=10;
}
int pan=0;
for(int j=1;j<10;j++)
{
if((j*k*k)%a==k)
{
cout<<j<<" "<<j*k*k<<endl;
pan=1;
break;
}
}
if(pan==0) cout<<"No"<<endl;
}
return 0;
}
1092 最好吃的月饼 (20分)
月饼是久负盛名的中国传统糕点之一，自唐朝以来，已经发展出几百品种。
若想评比出一种“最好吃”的月饼，那势必在吃货界引发一场腥风血雨…… 在这里我们用数字说话，给出全国各地各种月饼的销量，要求你从中找出销量冠军，认定为最好吃的月饼。
输入格式：
输入首先给出两个正整数 N（≤1000）和 M（≤100），分别为月饼的种类数（于是默认月饼种类从 1 到 N 编号）和参与统计的城市数量。
接下来 M 行，每行给出 N 个非负整数（均不超过 1 百万），其中第 i 个整数为第 i 种月饼的销量（块）。数字间以空格分隔。
输出格式：
在第一行中输出最大销量，第二行输出销量最大的月饼的种类编号。如果冠军不唯一，则按编号递增顺序输出并列冠军。数字间以 1 个空格分隔，行首尾不得有多余空格。
输入样例：
5 3
1001 992 0 233 6
8 0 2018 0 2008
36 18 0 1024 4
输出样例：
2018
3 5
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,m;cin>>n>>m;
int a[n][2];
for(int i=0;i<n;i++)
{
a[i][0]=0;a[i][1]=i+1;
}
for(int j=0;j<m;j++)
{
for(int k=0;k<n;k++)
{
int b;cin>>b;
a[k][0]+=b;
}
}
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
if(a[j][0]>a[i][0])
{
int temp=a[i][0];a[i][0]=a[j][0];a[j][0]=temp;
temp=a[i][1];a[i][1]=a[j][1];a[j][1]=temp;
}
else if(a[j][0]==a[i][0]&&a[j][1]<a[i][1])
{
int temp=a[i][0];a[i][0]=a[j][0];a[j][0]=temp;
temp=a[i][1];a[i][1]=a[j][1];a[j][1]=temp;
}
}
}
cout<<a[0][0]<<endl;cout<<a[0][1];
for(int i=1;i<n;i++)
{
if(a[i][0]==a[0][0])
{
cout<<" "<<a[i][1];
}
}
cout<<endl;
return 0;
}
1093 字符串A+B (20分)
给定两个字符串 A 和 B，本题要求你输出 A+B，即两个字符串的并集。要求先输出 A，再输出 B，但重复的字符必须被剔除。
输入格式：
输入在两行中分别给出 A 和 B，均为长度不超106的、由可见 ASCII 字符 (即码值为32~126)和空格组成的、由回车标识结束的非空字符串。
输出格式：
在一行中输出题面要求的 A 和 B 的和。
输入样例：
This is a sample test
to show you_How it works
输出样例：
This ampletowyu_Hrk
20200811（一刷）:
#include <bits/stdc++.h>
using namespace std;
int main()
{
string a,b;
getline(cin,a);getline(cin,b);
string c;c=a+b;
int d[130];
for(int i=0;i<130;i++) d[i]=0;
int l=c.length();
for(int i=0;i<l;i++)
{
int x=c[i];
if(d[x]==0)
{
cout<<c[i];d[x]++;
}
}
return 0;
}
1094 谷歌的招聘 (20分)
2004 年 7 月，谷歌在硅谷的 101 号公路边竖立了一块巨大的广告牌（如下图）用于招聘。内容超级简单，就是一个以 .com 结尾的网址，而前面的网址是一个 10 位素数，这个素数是自然常数 e 中最早出现的 10 位连续数字。能找出这个素数的人，就可以通过访问谷歌的这个网站进入招聘流程的下一步。
自然常数 e 是一个著名的超越数，前面若干位写出来是这样的:
e=2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427427466391932003059921… 其中粗体标出的 10 位数就是答案。
本题要求你编程解决一个更通用的问题：从任一给定的长度为 L 的数字中，找出最早出现的 K 位连续数字所组成的素数。
输入格式：
输入在第一行给出 2 个正整数，分别是 L（不超过 1000 的正整数，为数字长度）和 K（小于 10 的正整数）。接下来一行给出一个长度为 L 的正整数 N。
输出格式：
在一行中输出 N 中最早出现的 K 位连续数字所组成的素数。如果这样的素数不存在，则输出 404。注意，原始数字中的前导零也计算在位数之内。例如在 200236 中找 4 位素数，0023 算是解；但第一位 2 不能被当成 0002 输出，因为在原始数字中不存在这个 2 的前导零。
输入样例 1：
20 5
23654987725541023819
输出样例 1：
49877
输入样例 2：
10 3
2468024680
输出样例 2：
404
20200811（一刷）:
思路：
#include <bits/stdc++.h>
using namespace std;
bool isPrim(int N)
{
for (int i = 2; i <= sqrt(N); i++)
if (N%i == 0)
return false;
return true;
}
int main()
{
int N, K;
string str;
cin >> N >> K >> str;
for (int i = 0, j = K - 1; j < str.size(); j++,i++)
{
string temp = str.substr(i, K);
string ss = temp;
int num = atoi(temp.c_str());
if (isPrim(num))
{
cout << ss << endl;
return 0;
}
}
cout << "404" << endl;
return 0;
}
1095 解码PAT准考证 (25分)
PAT 准考证号由 4 部分组成：
第 1 位是级别，即 T 代表顶级；A 代表甲级；B 代表乙级；
第 2~4 位是考场编号，范围从 101 到 999；
第 5~10 位是考试日期，格式为年、月、日顺次各占 2 位；
最后 11~13 位是考生编号，范围从 000 到 999。
现给定一系列考生的准考证号和他们的成绩，请你按照要求输出各种统计信息。
输入格式：
输入首先在一行中给出两个正整数 N（≤104）和 M（≤100），分别为考生人数和统计要求的个数。
接下来 N 行，每行给出一个考生的准考证号和其分数（在区间 [0,100] 内的整数），其间以空格分隔。
考生信息之后，再给出 M 行，每行给出一个统计要求，格式为：类型 指令，其中
类型 为 1 表示要求按分数非升序输出某个指定级别的考生的成绩，对应的 指令 则给出代表指定级别的字母；
类型 为 2 表示要求将某指定考场的考生人数和总分统计输出，对应的 指令 则给出指定考场的编号；
类型 为 3 表示要求将某指定日期的考生人数分考场统计输出，对应的 指令 则给出指定日期，格式与准考证上日期相同。
输出格式：
对每项统计要求，首先在一行中输出 Case #: 要求，其中 # 是该项要求的编号，从 1 开始；要求 即复制输入给出的要求。随后输出相应的统计结果：
类型 为 1 的指令，输出格式与输入的考生信息格式相同，即 准考证号 成绩。对于分数并列的考生，按其准考证号的字典序递增输出（题目保证无重复准考证号）；
类型 为 2 的指令，按 人数 总分 的格式输出；
类型 为 3 的指令，输出按人数非递增顺序，格式为 考场编号 总人数。若人数并列则按考场编号递增顺序输出。
如果查询结果为空，则输出 NA。
输入样例：
8 4
B123180908127 99
B102180908003 86
A112180318002 98
T107150310127 62
A107180908108 100
T123180908010 78
B112160918035 88
A107180908021 98
1 A
2 107
3 180908
2 999
输出样例：
Case 1: 1 A
A107180908108 100
A107180908021 98
A112180318002 98
Case 2: 2 107
3 260
Case 3: 3 180908
107 2
123 2
102 1
Case 4: 2 999
NA
20200811（一刷）:
知识点
unordered_map():
错误
正确
#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;
struct node
{
string t;
int value;
};
bool cmp(struct node a,struct node b)
{
return a.value != b.value ? a.value > b.value : a.t < b.t;
}
int main()
{
int n, k, num;string s;
cin >> n >> k;
vector<node> v(n);
for (int i = 0; i < n; i++) cin >> v[i].t >> v[i].value;
for (int i = 1; i <= k; i++)
{
cin >> num >> s;printf("Case %d: %d %s\n", i, num, s.c_str());
vector<node> ans;int cnt = 0, sum = 0;
if (num == 1)
{
for (int j = 0; j < n; j++) if (v[j].t[0] == s[0]) ans.push_back(v[j]);
}
else if (num == 2)
{
for (int j = 0; j < n; j++)
{
if (v[j].t.substr(1, 3) == s)
{
cnt++;
sum += v[j].value;
}
}
if (cnt != 0) printf("%d %d\n", cnt, sum);
}
else if (num == 3)
{
unordered_map<string, int> m;
for (int j = 0; j < n; j++)
if (v[j].t.substr(4, 6) == s) m[v[j].t.substr(1, 3)]++;
for (auto it : m) ans.push_back({it.first, it.second});
}
sort(ans.begin(), ans.end(),cmp);
for (int j = 0; j < ans.size(); j++) printf("%s %d\n", ans[j].t.c_str(), ans[j].value);
if (((num == 1 || num == 3) && ans.size() == 0) || (num == 2 && cnt == 0)) printf("NA\n");
}
return 0;
}
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
