第二次训练赛都结束了，才想起来写写博客....唉，又精(wu)力(suo)充(shi)沛(shi)的度过了一天
A.成绩
题目描述
牛牛最近学习了 C++入门课程，这门课程的总成绩计算方法是：
总成绩 = 作业成绩 × 20% + 小测成绩 × 30% + 期末考试成绩 × 50%
牛牛想知道，这门课程自己最终能得到多少分。
输入
输入只有 1 行，包含三个非负整数A、 B、 C，分别表示牛牛的作业成绩、小测
成绩和期末考试成绩。相邻两个数之间用一个空格隔开，三项成绩满分都是 100 分。
输出
输出只有 1 行，包含一个整数，即牛牛这门课程的总成绩，满分也是 100 分。
样例输入
100 100 80
样例输出
90
提示
【输入输出样例 1 说明】
牛牛的作业成绩是 100 分，小测成绩是 100 分，期末考试成绩是 80 分，总成
绩是 100 × 20% + 100 × 30% + 80 × 50% = 20 + 30 + 40 = 90。
对于 30% 的数据， A = B = 0。
对于另外 30% 的数据， A = B = 100。
对于 100% 的数据， 0 ≤ A、 B、 C ≤ 100 且 A、 B、 C 都是 10 的整数倍
这个...，不说了...最开心的一道题了ε=ε=ε=(~￣▽￣)~
#include<bits/stdc++.h>
using namespace std;
int main()
{
double a,b,c;
double sum;
cin>>a>>b>>c;
cout<<a*0.2+b*0.3+c*0.5<<endl;
}
B.棋盘
题目描述
有一个m × m的棋盘，棋盘上每一个格子可能是红色、黄色或没有任何颜色的。你现在
要从棋盘的最左上角走到棋盘的最右下角。
任何一个时刻，你所站在的位置必须是有颜色的（不能是无色的）， 你只能向上、 下、
左、 右四个方向前进。当你从一个格子走向另一个格子时，如果两个格子的颜色相同，那你
不需要花费金币；如果不同，则你需要花费 1 个金币。
另外， 你可以花费 2 个金币施展魔法让下一个无色格子暂时变为你指定的颜色。但这个
魔法不能连续使用， 而且这个魔法的持续时间很短，也就是说，如果你使用了这个魔法，走
到了这个暂时有颜色的格子上，你就不能继续使用魔法； 只有当你离开这个位置，走到一个
本来就有颜色的格子上的时候，你才能继续使用这个魔法，而当你离开了这个位置（施展魔
法使得变为有颜色的格子）时，这个格子恢复为无色。
现在你要从棋盘的最左上角，走到棋盘的最右下角，求花费的最少金币是多少？
输入
数据的第一行包含两个正整数 m， n，以一个空格分开，分别代表棋盘的大小，棋盘上
有颜色的格子的数量。
接下来的 n 行，每行三个正整数 x， y， c， 分别表示坐标为（x， y）的格子有颜色 c。
其中 c=1 代表黄色， c=0 代表红色。 相邻两个数之间用一个空格隔开。 棋盘左上角的坐标
为（1, 1），右下角的坐标为（m, m）。
棋盘上其余的格子都是无色。保证棋盘的左上角，也就是（1， 1） 一定是有颜色的。
输出
输出一行，一个整数，表示花费的金币的最小值，如果无法到达，输出-1。
样例输入
5 7
1 1 0
1 2 0
2 2 1
3 3 1
3 4 0
4 4 1
5 5 0
样例输出
8
提示
【输入输出样例 1 说明】 
从（1， 1）开始，走到（1， 2）不花费金币
从（1， 2）向下走到（2， 2）花费 1 枚金币
从（2， 2）施展魔法，将（2， 3）变为黄色，花费 2 枚金币
从（2， 2）走到（2， 3）不花费金币
从（2， 3）走到（3， 3）不花费金币
从（3， 3）走到（3， 4）花费 1 枚金币
从（3， 4）走到（4， 4）花费 1 枚金币
从（4， 4）施展魔法，将（4， 5）变为黄色，花费 2 枚金币，
从（4， 4）走到（4， 5）不花费金币
从（4， 5）走到（5， 5）花费 1 枚金币
共花费 8 枚金币。
emmmm....这个题dfs就可以，但是要记忆化搜索一下，记一下上一个格子的颜色，根据上一个和这一个格子颜色花费金币
#include<bits/stdc++.h>
using namespace std;
const int INF=1<<30;
int Map[1001][1001];
int n,m;
int a[4][2]={0,1,1,0,0,-1,-1,0};
int len[1001][1001]={0};
void dfs(int x,int y,int flag,int sum)
{
if(len[x][y]>sum)
{
len[x][y]=sum;
}
else
{
return;
}
for(int i=0;i<4;i++)
{
int xx=x+a[i][0];
int yy=y+a[i][1];
if(Map[xx][yy]==-1&&flag!=-1)
{
continue;
}
if(x<=n&&y<=n&&x>0&&y>0)
{
if(Map[xx][yy]==-1&&flag==-1)
{
dfs(xx,yy,Map[x][y],sum+2);
}
if(Map[xx][yy]!=-1)
{
if(Map[xx][yy]==Map[x][y]||Map[xx][yy]==flag)
{
dfs(xx,yy,-1,sum);
}
else
{
dfs(xx,yy,-1,sum+1);
}
}
}
}
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
Map[i][j]=-1;
len[i][j]=INF;
}
}
for(int i=1;i<=m;i++)
{
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
Map[a][b]=c;
}
dfs(1,1,-1,0);
if(len[n][n]==INF)
printf("-1");
else
printf("%d",len[n][n]);
return 0;
}
C.跳房子
题目描述
跳房子，也叫跳飞机，是一种世界性的儿童游戏，也是中国民间传统的体育游戏之一。
跳房子的游戏规则如下：
在地面上确定一个起点，然后在起点右侧画 n 个格子，这些格子都在同一条直线上。每个格子内有一个数字（整数），表示到达这个 格子能得到的分数。玩家第一次从起点开始向右跳，跳到起点右侧的一个格子内。第二次再从当前位置继续向右跳，依此类推。规则规定：
玩家每次都必须跳到当前位置右侧的一个格子内。玩家可以在任意时刻结束游戏，获得的分数为曾经到达过的格子中的数字之和。
现在小 RR 研发了一款弹跳机器人来参加这个游戏。但是这个机器人有一个非常严重的缺陷，它每次向右弹跳的距离只能为固定的 dd 。小 RR 希望改进他的机器人，如果他花 gg 个金币改进他的机器人，那么他的机器人灵活性就能增加 g ，但是需要注意的是，每 次弹跳的距离至少为 1 。具体而言，当 g<dg<d 时，他的机器人每次可以选择向右弹跳的距离为 d−g,d−g+1,d−g+2 ，…， d+g−2 ， d+g−1 ， d+g ；否则（当 g≥dg≥d时），他的机器人每次可以选择向右弹跳的距离为 1 ， 2 ， 3 ，…， d+g−2 ， d+g−1 ， d+g 。
现在小 R 希望获得至少 k 分，请问他至少要花多少金币来改造他的机器人。
输入
第一行三个正整数 n ， d ， k ，分别表示格子的数目，改进前机器人弹跳的固定距离，以及希望至少获得的分数。相邻两个数 之间用一个空格隔开。
接下来 n 行，每行两个正整数 xi,si ，分别表示起点到第 i 个格子的距离以及第 ii个格子的分数。两个数之间用一个空格隔开。保证 xi 按递增顺序输入。
输出
共一行，一个整数，表示至少要花多少金币来改造他的机器人。若无论如何他都无法获得至少 k 分，输出 −1 。
样例输入
7 4 10
2 6
5 -3
10 3
11 -3
13 1
17 6
20 2
样例输出
2
提示
【输入输出样例 1 说明】
2个金币改进后, 小 R 的机器人依次选择的向右弹跳的距离分别为2,3,5,3,4,3 先后到达的位置分别为 2,5,10,13,17,20对应1,2,3,5,6,7这66 个格子。这些格子中的数字之和15 即为小 R 获得的分数。
【数据规模与约定】
本题共
本题共 10 组测试数据,每组数据 10 分。
对于全部的数据满足1≤n≤500000,1≤d≤2000,1≤xi,k≤109,∣si∣<105
对于第 1,2组测试数据, n≤10；
对于第3,4,5 组测试数据, n≤500
对于第6,7,8 组测试数据, d=1
这个题...唉?，刚看这个题真的一头雾水，看到网上题解是说二分+DP,然后自己想了想 又灰溜溜的去补单调队列了，话说，单调队列真是个好东西，优化一层n,学起来简单，刚开始用难，但会用了就简单了，emmm...单调队列不会的可以自行百度一下，大佬们的博客讲的都挺清楚的%%%。
因为移动距离是d-g到d+g,所以很容易就想到二分了(并没有≡(▔﹏▔)≡)，然后dp就可以了，状态转移方程很容易想到dp[i]=max(dp[j])+s[i],因为不小于k就可以，所以dp[i]>=k就可以结束了，如果dp[n]也到达不了K,那这么多努力都白费了，竟然完成不了（肥宅大哭(;´༎ຶД༎ຶ`)23333
#include<bits/stdc++.h>
using namespace std;
struct node
{
int x,v; //v为x距离格的最大得分
} q[500005];
int n,d,k;
int x[500005],s[500005],dp[500005];
int check(int g)
{
int qmin=d-g,qmax=d+g,cur=0; //qmin和qmax是最小和最大跳跃距离
int head=1,tail=0; //剪枝，cur为未处理完的格子,若每次从0开始会TLE
if(qmin<=0) //d-g最小为1，总不能走0或负数吧
{
qmin=1;
}
memset(dp,0,sizeof dp);
for(int i=1;i<=n;i++)
{
for(cur;(cur<i)&&(x[cur]<=x[i]-qmin);cur++) //把距离当前格qmin内的未添加到
{ //单调队列的格子添加到单调队列
while((head<=tail)&&(q[tail].v<dp[cur])) //当然是要大的咯，这样花的money才少嘛
{ //所以构造的是严格的单调递增队列
tail--;
}
if(dp[cur]<=-1000000000)
{
continue; //无法到达的格子不添加
}
q[++tail].v=dp[cur];
q[tail].x=x[cur]; //将cur格添加到队列中
}-
while((head<=tail)&&(x[i]-q[head].x>qmax))
{
head++;
}
dp[i]=(head<=tail)? q[head].v+s[i]:-1000000000;
if(dp[i]>=k)
{
return 1;
}
}
return 0;
}
int main()
{
cin>>n>>d>>k;
for(int i=1;i<=n;i++)
{
cin>>x[i]>>s[i];
}
int l=0,r=x[n],ans=-1;//ans初值为-1，若完成不了直接输出
int m=(l+r)>>1; //二分
for(l;l<=r;m=(l+r)>>1)
{
if(check(m))
{
r=m-1;
ans=m;
}
else
{
l=m+1;
}
}
cout<<ans<<endl;
}
D.队列
题目描述
Sylvia 是一个热爱学习的女孩子。
前段时间， Sylvia 参加了学校的军训。众所周知，军训的时候需要站方阵。 Sylvia
所在的方阵中有n × m名学生，方阵的行数为 n，列数为 m。
为了便于管理，教官在训练开始时，按照从前到后，从左到右的顺序给方阵中
的学生从 1 到 n × m 编上了号码（参见后面的样例）。即：初始时，第 i 行第 j 列
的学生的编号是(i - 1) × m + j。
然而在练习方阵的时候，经常会有学生因为各种各样的事情需要离队。在一天
中，一共发生了 q 件这样的离队事件。每一次离队事件可以用数对(x,y)(1≤x≤n,
1≤y≤m)描述， 表示第 x 行第 y 列的学生离队。
在有学生离队后，队伍中出现了一个空位。为了队伍的整齐，教官会依次下达
这样的两条指令：
1. 向左看齐。这时第一列保持不动，所有学生向左填补空缺。不难发现在这条
指令之后，空位在第 x 行第 m 列。
2. 向前看齐。这时第一行保持不动，所有学生向前填补空缺。不难发现在这条
指令之后，空位在第 n 行第 m 列。
教官规定不能有两个或更多学生同时离队。即在前一个离队的学生归队之后，
下一个学生才能离队。因此在每一个离队的学生要归队时，队伍中有且仅有第 n 行
第 m 列一个空位，这时这个学生会自然地填补到这个位置。
因为站方阵真的很无聊，所以 Sylvia 想要计算每一次离队事件中，离队的同学
的编号是多少。
注意：每一个同学的编号不会随着离队事件的发生而改变，在发生离队事件后
方阵中同学的编号可能是乱序的。
输入
输入共 q+1 行。
第 1 行包含 3 个用空格分隔的正整数 n, m, q，表示方阵大小是 n,m,q,表示方阵大小是 n行m列，一共发生了q次事件。
接下来q行按照事件发生顺序描述了q件事件。每一行是两个整数x,y，用一个空格分隔，表示这个离队事件中离队的学生当时排在第x行第y列。
输出
按照事件输入的顺序，每一个事件输出一行一个整数，表示这个离队事件中离队学
生的编号。
样例输入
2 2 3
1 1
2 2
1 2
样例输出
1 1 4
提示
这个题....好像还没补....好吧，只能占坑了，等我回来ε=ε=ε=(~￣▽￣)~
E.小凯的疑惑
题目描述
小凯手中有两种面值的金币，两种面值均为正整数且彼此互素。 每种金币小凯都有
无数个。 在不找零的情况下， 仅凭这两种金币，有些物品他是无法准确支付的。 现在小
凯想知道在无法准确支付的物品中，最贵的价值是多少金币？ 注意：输入数据保证存在
小凯无法准确支付的商品。
输入
输入数据仅一行， 包含两个正整数 a 和 b， 它们之间用一个空格隔开， 表示小凯手
中金币的面值。
输出
输出仅一行，一个正整数 N，表示不找零的情况下， 小凯用手中的金币不能准
确支付的最贵的物品的价值。
样例输入
3 7
样例输出
11
提示
【输入输出样例 1 说明】
小凯手中有面值为 3和 7的金币无数个，在不找零的前提下无法准确支付价值为 1、
2、 4、 5、 8、 11 的物品，其中最贵的物品价值为 11，比 11 贵的物品都能买到，比如：
12 = 3 * 4 + 7 * 0
13 = 3 * 2 + 7 * 1
14 = 3 * 0 + 7 * 2
15 = 3 * 5 + 7 * 0
……
【数据规模与约定】
对于 30%的数据： 1 ≤ a， b ≤ 50。
对于 60%的数据： 1 ≤ a， b ≤ 10,000。
对于 100%的数据： 1 ≤ a， b ≤ 1,000,000,000。
这个题，就不得不说一说了，为什么呢？因为我是蒙对了的(啊哈哈哈哈)
这个题看上是个DP背包的题，我也这么做了，氮素！交上去却编译错误了，为啥为啥为啥，原来，数据太大了。好吧，xjb乱搞都搞出来了 总不能放弃了吧，于是我偷偷的 输出几个数 偷偷的找了下规律，哇塞竟然让我给看出来了，最短AC代码粗来了(ಥ _ ಥ)
那就说一下DP思路吧，看成一个完全背包，两种金币的数量是无穷的，背包的容量也是无穷的，虽然容量无穷吧，但我们要设一个最大值，不然一直装还装不装的完啦，还有没有时间去追番啦(❤ ω ❤)，那我们就设最大值的1000000吧，完全背包状态转移方程dp[i]=max(dp[i],dp[i-v[i]]+v[i] (在这价值和体积是一样滴~)，看哪些不能被装满，挑最大的那个就OK惹。
然后输出数找规律就出来了（大雾
//dp 背包
#include<bits/stdc++.h>
using namespace std;
const long long maxn=1000000;
long long dp[maxn];
int bag[3];
int main()
{
int a,b;
while(scanf("%d%d",&a,&b)!=EOF)
{
for(int j=0; j<maxn; j++)
{
dp[j]=-maxn;
}
bag[1]=a,bag[2]=b;
dp[0]=0;
for(int i=1; i<=2; i++)
{
for(int j=bag[i]; j<maxn; j++)
{
dp[j]=max(dp[j],dp[j-bag[i]]+bag[i]);
}
}
long long flag;
for(int i=1; i<maxn; i++)
{
if(dp[i]!=i)
{
flag=i;
}
}
printf("%d\n",flag);
}
return 0;
}
//规律
#include<bits/stdc++.h>
using namespace std;
long long a,b;
int main()
{
cin>>a>>b;
long long flag=a*b-(a+b);
cout<<flag<<endl;
return 0;
}
F.时间复杂度
题目描述
小明正在学习一种新的编程语言 A++，刚学会循环语句的他激动地写了好多程序并
给出了他自己算出的时间复杂度，可他的编程老师实在不想一个一个检查小明的程序，
于是你的机会来啦！下面请你编写程序来判断小明对他的每个程序给出的时间复杂度是
否正确。
A++语言的循环结构如下：
F i x y
循环体
E
其中“F i x y”表示新建变量 （i 变量 i 不可与未被销毁的变量重名）并初始化为 x，
然后判断 i 和 y 的大小关系，若 i 小于等于 y 则进入循环，否则不进入。每次循环结束
后 i 都会被修改成 i +1，一旦 i 大于 y 终止循环。
x 和 y 可以是正整数（x 和 y 的大小关系不定） 或变量 n。 n 是一个表示数据规模的
变量，在时间复杂度计算中需保留该变量而不能将其视为常数，该数远大于 100。
“E” 表示循环体结束。 循环体结束时， 这个循环体新建的变量也被销毁。
注：本题中为了书写方便，在描述复杂度时，使用大写英文字母“O”表示通常意
义下“Θ” 的概念。
输入
输入第一行一个正整数 t， 表示有 t（t ≤ 10） 个程序需要计算时间复杂度。
每个程序我们只需抽取其中 “F i x y” 和“E” 即可计算时间复杂度。 注意： 循环结构
允许嵌套。
接下来每个程序的第一行包含一个正整数 L 和一个字符串， L 代表程序行数，字符
串表示这个程序的复杂度，“O(1)”表示常数复杂度，“O(n^w)”表示复杂度为
输出
输出共 t 行，对应输入的 t 个程序，每行输出“Yes”或“No” 或者“ERR”（输
出中不包含引号）， 若程序实际复杂度与输入给出的复杂度一致则输出“Yes”，不一致
则输出“No”， 若程序有语法错误（其中语法错误只有: ① F 和 E 不匹配 ②新建的变
量与已经存在但未被销毁的变量重复两种情况）， 则输出“ERR”。
注意：即使在程序不会执行的循环体中出现了语法错误也会编译错误， 要输出
“ERR”。
样例输入
8
2 O(1)
F i 1 1
E
2 O(n^1)
F x 1 n
E
1 O(1)
F x 1 n
4 O(n^2)
F x 5 n
F y 10 n
E
E
4 O(n^2)
F x 9 n
E
F y 2 n
E
4 O(n^1)
F x 9 n
F y n 4
E
E
4 O(1)
F y n 4
F x 9 n
E
E
4 O(n^2)
F x 1 n
F x 1 10
E
E
样例输出
Yes
Yes
ERR
Yes
No
Yes
Yes
ERR
提示
【输入输出样例 1 说明】
第一个程序 i 从 1 到 1 是常数复杂度。
第二个程序 x 从 1 到 n 是 n 的一次方的复杂度。
第三个程序有一个 F 开启循环却没有 E 结束，语法错误。
第四个程序二重循环， n 的平方的复杂度。
第五个程序两个一重循环， n 的一次方的复杂度。
第六个程序第一重循环正常，但第二重循环开始即终止（因为n远大于 100，100大于4）。
第七个程序第一重循环无法进入，故为常数复杂度。
第八个程序第二重循环中的变量 x 与第一重循环中的变量重复， 出现语法错误②，输出
ERR。
【数据规模与约定】
对于 30%的数据：不存在语法错误， 数据保证小明给出的每个程序的前 L/2 行一定
为以 F 开头的语句，第 L/2+1 行至第 L 行一定为以 E 开头的语句， L<=10，若 x、 y 均
为整数， x 一定小于 y，且只有 y 有可能为 n。
对于 50%的数据：不存在语法错误， L<=100， 且若 x、 y 均为整数， x 一定小于 y，
且只有 y 有可能为 n。
对于 70%的数据：不存在语法错误， L<=100。
对于 100%的数据： L<=100。
用栈模拟就好了，注意
#include<bits/stdc++.h>
using namespace std;
struct node
{
int Complex;
int Flag;
char var;
};
int main()
{
int t,n;
cin>>t;
while(t--)
{
int cmp,cur_Com=0,max_Com=0,flag1=0,flag2=0;
bool vis[30];
memset(vis,0,sizeof(vis));
stack <node> st;
string s,c1,c2,c3,c4;
cin>>n>>s; //n行数 s时间复杂度
if(s[2]=='1')
cmp=0;
else
sscanf(s.c_str(),"O(n^%d)",&cmp);
for(int i=1;i<=n;i++)
{
cin>>c1;
if(c1[0]=='F')
{
cin>>c2>>c3>>c4;
//cout<<"c1:"<<c1<<endl;
//cout<<"c2:"<<c2<<endl;
//cout<<"c3:"<<c3<<endl;
//cout<<"c4:"<<c4<<endl;
if(flag1)
continue;
if(vis[c2[0]-'a'])
{
flag1=1;
continue;
}
vis[c2[0]-'a']=1;
st.push((node){cur_Com,flag2,c2[0]});
if(flag2)
flag2=1;
else if(c3[0]=='n'&&c4[0]!='n')
flag2=1;
else if(c3[0]!='n'&&c4[0]!='n')
{
int cc3=atoi(c3.c_str()); //char转int
int cc4=atoi(c4.c_str());
if(cc3>cc4)
flag2=1;
}
else if(c3[0]!='n'&&c4[0]=='n')
{
cur_Com++;
max_Com=max(max_Com,cur_Com);
}
}
else if(c1[0]=='E')
{
if(flag1)
continue;
else if(st.empty())
{
flag1=1;
continue;
}
else
{
node tmp=st.top();
st.pop();
cur_Com=tmp.Complex;
vis[tmp.var-'a']=0;
flag2=tmp.Flag;
}
}
}
if(flag1||!st.empty())
cout<<"ERR"<<endl;
else
{
if(max_Com==cmp)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
}
}
return 0;
}
G.图书管理员
题目描述
图书馆中每本书都有一个图书编码，可以用于快速检索图书， 这个图书编码是一个
正整数。
每位借书的读者手中有一个需求码，这个需求码也是一个正整数。如果一本书的图
书编码恰好以读者的需求码结尾，那么这本书就是这位读者所需要的。
小 D 刚刚当上图书馆的管理员，她知道图书馆里所有书的图书编码，她请你帮她写
一个程序，对于每一位读者，求出他所需要的书中图书编码最小的那本书，如果没有他
需要的书，请输出-1。
输入
输入的第一行，包含两个正整数 n 和 q，以一个空格分开，分别代表图书馆里
书的数量和读者的数量。
接下来的 n 行，每行包含一个正整数，代表图书馆里某本书的图书编码。
接下来的 q 行，每行包含两个正整数，以一个空格分开，第一个正整数代表图书馆
里读者的需求码的长度，第二个正整数代表读者的需求码。
输出
输出有 q 行，每行包含一个整数，如果存在第 i 个读者所需要的书，则在第 i
行输出第 i 个读者所需要的书中图书编码最小的那本书的图书编码，否则输出-1。
样例输入
5 5
2123
1123
23
24
24
2 23
3 123
3 124
2 12
2 12
样例输出
23
1123
-1
-1
-1
提示
【输入输出样例 1 说明】
第一位读者需要的书有 2123、 1123、 23，其中 23 是最小的图书编码。第二位读者需要
的书有 2123、 1123，其中 1123 是最小的图书编码。对于第三位，第四位和第五位读者，没
有书的图书编码以他们的需求码结尾，即没有他们需要的书，输出-1。
【数据规模与约定】
对于 20%的数据， 1 ≤ n ≤ 2。
另有 20%的数据， q = 1。
另有 20%的数据，所有读者的需求码的长度均为 1。
另有 20%的数据，所有的图书编码按从小到大的顺序给出。
对于 100%的数据， 1 ≤ n ≤ 1,000， 1 ≤ q ≤ 1,000，所有的图书编码和需求码均
不超过 10,000,000。
模拟飘过...因为要输出读者所需要的书中图书编码最小的那本书的图书编码，所以排序做个剪枝。图书编码%需求码的长度,得图书编码后几位，如果与需求码相同就符合要求了。
#include<bits/stdc++.h>
using namespace std;
const long long maxn=10000000;
int n,q;
int bn[maxn],lrb[maxn],rb[maxn];
int main()
{
cin>>n>>q;
for(int i=0;i<n;i++)
{
cin>>bn[i];
}
sort(bn,bn+n); //从小到大排序，使得符合最小要求
for(int i=0;i<q;i++)
{
cin>>lrb[i]>>rb[i];
}
int a,b;
for(int i=0;i<q;i++)
{
int flag=0;
for(int j=0;j<n;j++)
{
if(bn[j] % (int)pow(10, lrb[i]) == rb[i])
//图书编码%需求码的长度,得图书编码后几位
//如果与需求码相同
{
flag=bn[j];
break;
}
}
if(flag)
{
cout<<flag<<endl;
}
else
{
cout<<"-1"<<endl;
}
}
}
over...
测试题好像是NOIP省选原题，原谅我做题太少...题解质量也不敢和OI大佬相比。蒟蒻大哭555(╥╯-╰╥)555
134
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
