（一）目录

L1-071 前世档案

L1-072 刮刮彩票

L1-077 大笨钟的心情

L1-078 吉老师的回归

L1-079 天梯赛的善良

L1-080 乘法口诀数列

L1-085 试试手气

L1-086 斯德哥尔摩火车上的题

L1-087 机工士姆斯塔迪奥

L1-088 静静的推荐

 （二）题目 

L1-071 前世档案

     网络世界中时常会遇到这类滑稽的算命小程序，实现原理很简单，随便设计几个问题，根据玩家对每个问题的回答选择一条判断树中的路径（如下图所示），结论就是路径终点对应的那个结点。

现在我们把结论从左到右顺序编号，编号从 1 开始。这里假设回答都是简单的“是”或“否”，又假设回答“是”对应向左的路径，回答“否”对应向右的路径。给定玩家的一系列回答，请你返回其得到的结论的编号。

输入格式：

输入第一行给出两个正整数：N（≤30）为玩家做一次测试要回答的问题数量；M（≤100）为玩家人数。

随后 M 行，每行顺次给出玩家的 N 个回答。这里用 y 代表“是”，用 n 代表“否”。

输出格式：

对每个玩家，在一行中输出其对应的结论的编号。

输入样例：

3 4
yny
nyy
nyn
yyn

输出样例：

3
5
6
2

 分析：如图向右就按权重加一,最后再加1，因为是yyy对应1

代码：

#include <iostream>
#include <cmath>
using namespace std;
int main() {
	int n, m;
	cin >> n >> m;
	string s;
	while(m--){
		int num = 1;
		cin >> s;
		for(int i = 0; i < s.length(); i++){
			if(s[i] == 'n'){
				num += pow(2, n-1-i);
			}
		}
		cout << num << endl;
	}
}

L1-072 刮刮彩票

每次游戏玩家会拿到一张彩票，上面会有 9 个数字，分别为数字 1 到数字 9，数字各不重复，并以 3×3 的“九宫格”形式排布在彩票上。

在游戏开始时能看见一个位置上的数字，其他位置上的数字均不可见。你可以选择三个位置的数字刮开，这样玩家就能看见四个位置上的数字了。最后玩家再从 3 横、3 竖、2 斜共 8 个方向中挑选一个方向，方向上三个数字的和可根据下列表格进行兑奖，获得对应数额的金币。

数字合计	获得金币	数字合计	获得金币
6	10,000	16	72
7	36	17	180
8	720	18	119
9	360	19	36
10	80	20	306
11	252	21	1,080
12	108	22	144
13	72	23	1,800
14	54	24	3,600
15	180

现在请你写出一个模拟程序，模拟玩家的游戏过程。

输入格式:

输入第一部分给出一张合法的彩票，即用 3 行 3 列给出 0 至 9 的数字。0 表示的是这个位置上的数字初始时就能看见了，而不是彩票上的数字为 0。

第二部给出玩家刮开的三个位置，分为三行，每行按格式 x y 给出玩家刮开的位置的行号和列号（题目中定义左上角的位置为第 1 行、第 1 列。）。数据保证玩家不会重复刮开已刮开的数字。

最后一部分给出玩家选择的方向，即一个整数： 1 至 3 表示选择横向的第一行、第二行、第三行，4 至 6 表示纵向的第一列、第二列、第三列，7、8分别表示左上到右下的主对角线和右上到左下的副对角线。

输出格式:

对于每一个刮开的操作，在一行中输出玩家能看到的数字。最后对于选择的方向，在一行中输出玩家获得的金币数量。

输入样例:

1 2 3
4 5 6
7 8 0
1 1
2 2
2 3
7

输出样例:

1
5
6
180

分析：

代码：

 #include<bits/stdc++.h>
using namespace std;
int main()
{
	int a[4][4],num[10],know,known[3],i1,j1;
	
	//0.初始化
	for(int i=0;i<10;i++) num[i]=0;
 		
	for(int i=1;i<=3;i++)
	{
		for(int j=1;j<=3;j++)
		{
			cin>>a[i][j];
			num[a[i][j]]++;	
			if(a[i][j]==0)		
			{
				i1=i;
				j1=j;
			}
		}
	}	
	
	for(int i=1;i<10;i++)
	{
		if(num[i]==0)
		{
			know=i;
			break;
		}
	}
	
	a[i1][j1]=know;
	//1.输入坐标，翻出数字 
	int x,y;
	for(int i=0;i<3;i++)
	{
		cin>>x>>y;		
		known[i]=a[x][y];
		cout<<a[x][y]<<endl;		
	}
	
	//2.三点连线
	int sum=0;
	int d;
	cin>>d;
	
	if(d==1||d==2||d==3)
	{
		for(int i=1;i<=3;i++) sum=sum+a[d][i];		
	}
	
	else if(d==4||d==5||d==6)
	{
		for(int i=1;i<=3;i++) sum=sum+a[i][d-3];
	}
	
	else if(d==7)
	{
		for(int i=1;i<=3;i++) sum=sum+a[i][i];
	}
	
	else
	{
		for(int i=1;i<=3;i++) sum=sum+a[i][4-i];
	}
	
	//3.根据sum得出金币
	int money[25]={0,0,0,0,0,0,10000,36,720,360,80,252,108,72,54,180,72,180,119,36,306,1080,144,1800,3600};
	cout<<money[sum];
	 
	return 0;
}

L1-077 大笨钟的心情

有网友问：未来还会有更多大笨钟题吗？笨钟回复说：看心情……

本题就请你替大笨钟写一个程序，根据心情自动输出回答。

输入格式：

输入在一行中给出 24 个 [0, 100] 区间内的整数，依次代表大笨钟在一天 24 小时中，每个小时的心情指数。

随后若干行，每行给出一个 [0, 23] 之间的整数，代表网友询问笨钟这个问题的时间点。当出现非法的时间点时，表示输入结束，这个非法输入不要处理。题目保证至少有 1 次询问。

输出格式：

对每一次提问，如果当时笨钟的心情指数大于 50，就在一行中输出 心情指数 Yes，否则输出 心情指数 No。

输入样例：

80 75 60 50 20 20 20 20 55 62 66 51 42 33 47 58 67 52 41 20 35 49 50 63
17
7
3
15
-1

输出样例：

52 Yes
20 No
50 No
58 Yes

读题：分析17->52之间的关系，易得

代码：

#include <bits/stdc++.h>
using namespace std;
int n[25], m, cnt;
bool Num[25];
string s, ans;
 
int main() {
	for(int i=0;i<24;i++){
	 	cin >> n[i] ;	
	}
    while(1)
    {
    	cin>>m;
		if(m<0||m>23)
		{
			break;
		}
        else{
              printf("%d %s\n",n[m], n[m]>50?"Yes":"No" );
        continue;
        }
       
	}
 
	return 0;
}

L1-078 吉老师的回归

曾经在天梯赛大杀四方的吉老师决定回归天梯赛赛场啦！

为了简化题目，我们不妨假设天梯赛的每道题目可以用一个不超过 500 的、只包括可打印符号的字符串描述出来，如：Problem A: Print "Hello world!"。

众所周知，吉老师的竞赛水平非常高超，你可以认为他每道题目都会做（事实上也是……）。因此，吉老师会按照顺序看题并做题。但吉老师水平太高了，所以签到题他就懒得做了（浪费时间），具体来说，假如题目的字符串里有 qiandao 或者 easy（区分大小写）的话，吉老师看完题目就会跳过这道题目不做。

现在给定这次天梯赛总共有几道题目以及吉老师已经做完了几道题目，请你告诉大家吉老师现在正在做哪个题，或者吉老师已经把所有他打算做的题目做完了。

提醒：天梯赛有分数升级的规则，如果不做签到题可能导致团队总分不足以升级，一般的选手请千万不要学习吉老师的酷炫行为！

输入格式：

输入第一行是两个正整数 N,M (1≤M≤N≤30)，表示本次天梯赛有 N 道题目，吉老师现在做完了 M 道。

接下来 N 行，每行是一个符合题目描述的字符串，表示天梯赛的题目内容。吉老师会按照给出的顺序看题——第一行就是吉老师看的第一道题，第二行就是第二道，以此类推。

输出格式：

在一行中输出吉老师当前正在做的题目对应的题面（即做完了 M 道题目后，吉老师正在做哪个题）。如果吉老师已经把所有他打算做的题目做完了，输出一行 Wo AK le。

输入样例 1：

5 1
L1-1 is a qiandao problem.
L1-2 is so...easy.
L1-3 is Easy.
L1-4 is qianDao.
Wow, such L1-5, so easy.

输出样例 1：

L1-4 is qianDao.

输入样例 2：

5 4
L1-1 is a-qiandao problem.
L1-2 is so easy.
L1-3 is Easy.
L1-4 is qianDao.
Wow, such L1-5, so!!easy.

输出样例 2：

Wo AK le

分析：

代码：

#include <bits/stdc++.h>
using namespace std;
int n, m, cnt;
string s, ans;
int check(string a) {
	for (int i = 0; i < a.length(); i++)
		if (a.substr(i, 7) == "qiandao" || a.substr(i, 4) == "easy") return 1;
	return 0;
}
int main() {
	cin >> n >> m;
	getchar();
	for (int i = 0; i < n; i++) {
		getline(cin, s);
		if (check(s)) continue;
		else {
			if (cnt == m) ans = s;
			cnt++;
		}
	}
	if (cnt <= m) cout << "Wo AK le";
	else cout << ans;
	return 0;
}

L1-079 天梯赛的善良

      天梯赛是个善良的比赛。善良的命题组希望将题目难度控制在一个范围内，使得每个参赛的学生都有能做出来的题目，并且最厉害的学生也要非常努力才有可能得到高分。

于是命题组首先将编程能力划分成了 106 个等级（太疯狂了，这是假的），然后调查了每个参赛学生的编程能力。现在请你写个程序找出所有参赛学生的最小和最大能力值，给命题组作为出题的参考。

输入格式：

输入在第一行中给出一个正整数 N（≤2×104），即参赛学生的总数。随后一行给出 N 个不超过 106 的正整数，是参赛学生的能力值。

输出格式：

第一行输出所有参赛学生的最小能力值，以及具有这个能力值的学生人数。第二行输出所有参赛学生的最大能力值，以及具有这个能力值的学生人数。同行数字间以 1 个空格分隔，行首尾不得有多余空格。

输入样例：

10
86 75 233 888 666 75 886 888 75 666

输出样例：

75 3
888 2

思路：从第一个元素开始（设置它的人数为1），找最小（相等就人数+1），小于就换（重置人数为1，继续上述过程），找到最后一个元素，最大元素类似。

代码： 

 #include<bits/stdc++.h>
using namespace std;
int main(){
    int n,a[20005],i;
    map<int,int>b;
    cin>>n;
    for(i=0;i<n;i++){cin>>a[i];
                    b[a[i]]++;}
    sort(a,a+n);
    cout<<a[0]<<" "<<b[a[0]]<<endl;
    cout<<a[n-1]<<' '<<b[a[n-1]];
    return 0;
} 
 

L1-080 乘法口诀

本题要求你从任意给定的两个 1 位数字 a1​ 和 a2​ 开始，用乘法口诀生成一个数列 {an​}，规则为从 a1​ 开始顺次进行，每次将当前数字与后面一个数字相乘，将结果贴在数列末尾。如果结果不是 1 位数，则其每一位都应成为数列的一项。

输入格式：

输入在一行中给出 3 个整数，依次为 a1​、a2​ 和 n，满足 0≤a1​,a2​≤9，0<n≤103。

输出格式：

在一行中输出数列的前 n 项。数字间以 1 个空格分隔，行首尾不得有多余空格。

输入样例：

2 3 10

输出样例：

2 3 6 1 8 6 8 4 8 4

样例解释：

数列前 2 项为 2 和 3。从 2 开始，因为 2×3=6，所以第 3 项是 6。因为 3×6=18，所以第 4、5 项分别是 1、8。依次类推…… 最后因为第 6 项有 6×8=48，对应第 10、11 项应该是 4、8。而因为只要求输出前 10 项，所以在输出 4 后结束。

代码：

#include<stdio.h>
int main()
{
	int a1, a2, n, count = 3, num[1005], i, j, sum;
    scanf("%d %d %d", &a1, &a2, &n);
    num[1] = a1, num[2] = a2;
	for (i = 1; i <= n; i++)
	{
		sum = num[i] * num[i + 1];
		if (sum < 10)
		{
			num[count++] = sum;
		}
		else
		{
			num[count++] = sum / 10;
			num[count++] = sum % 10;
		}
		if (count > n)
			break;
	}
	printf("%d", a1);
	for (j = 2; j <= n; j++) 
	{
		printf(" %d", num[j]);
	}
    return 0;
}

L1-085 试试手气

我们知道一个骰子有 6 个面，分别刻了 1 到 6 个点。下面给你 6 个骰子的初始状态，即它们朝上一面的点数，让你一把抓起摇出另一套结果。假设你摇骰子的手段特别精妙，每次摇出的结果都满足以下两个条件：

• 1、每个骰子摇出的点数都跟它之前任何一次出现的点数不同；
• 2、在满足条件 1 的前提下，每次都能让每个骰子得到可能得到的最大点数。

那么你应该可以预知自己第 n 次（1≤n≤5）摇出的结果。

输入格式：

输入第一行给出 6 个骰子的初始点数，即 [1,6] 之间的整数，数字间以空格分隔；第二行给出摇的次数 n（1≤n≤5）。

输出格式：

在一行中顺序列出第 n 次摇出的每个骰子的点数。数字间必须以 1 个空格分隔，行首位不得有多余空格。

输入样例：

3 6 5 4 1 4
3

输出样例：

4 3 3 3 4 3

样例解释：

这 3 次摇出的结果依次为：

6 5 6 6 6 6
5 4 4 5 5 5
4 3 3 3 4 3

思路：

代码：

 //记录
#include<stdio.h>

int main()
{
    int num[7];
    int n;
    
    for(int i = 1; i <= 6; i++){
        scanf("%d",&num[i]);
    }
    scanf("%d",&n);
    
    for(int i = 1; i <= 6; i++)
    {
        int count = 0;
        int t = num[i];
        for(int k = 6; k >=1 ; k--)
        {
            if(t!=k&&k!=num[i]){
                t = k;
                count++;
                if(count==n) {
                    num[i] = t;
                    break;
                }
            }
        }
        
    }
    
    for(int i = 1; i <= 6; i++){
        if(i==1) printf("%d",num[i]);
        else printf(" %d",num[i]);
    }
    
    return 0;
}

L1-086 斯德哥尔摩火车上的题

上图是新浪微博上的一则趣闻，是瑞典斯德哥尔摩火车上的一道题，看上去是段伪代码：

s = ''
a = '1112031584'
for (i = 1; i < length(a); i++) {
  if (a[i] % 2 == a[i-1] % 2) {
    s += max(a[i], a[i-1])
  }
}
goto_url('www.multisoft.se/' + s)

其中字符串的 + 操作是连接两个字符串的意思。所以这道题其实是让大家访问网站 www.multisoft.se/112358（注意：比赛中千万不要访问这个网址！！！）。

当然，能通过上述算法得到 112358 的原始字符串 a 是不唯一的。本题就请你判断，两个给定的原始字符串，能否通过上述算法得到相同的输出？

输入格式：

输入为两行仅由数字组成的非空字符串，长度均不超过 104，以回车结束。

输出格式：

对两个字符串分别采用上述斯德哥尔摩火车上的算法进行处理。如果两个结果是一样的，则在一行中输出那个结果；否则分别输出各自对应的处理结果，每个占一行。题目保证输出结果不为空。

输入样例 1：

1112031584
011102315849

输出样例 1：

112358

输入样例 2：

111203158412334
12341112031584

输出样例 2：

1123583
112358

代码： 

#include<bits/stdc++.h>
using namespace std;
int main()
{
    string s1,s2;
    cin>>s1>>s2;
    string ss1,ss2;
    for(int i=1;i<s1.length();i++)
    {
        if(s1[i]%2==s1[i-1]%2)
        {
            ss1+=max(s1[i],s1[i-1]);
        }
    }
    for(int i=1;i<s2.length();i++)
    {
        if(s2[i]%2==s2[i-1]%2)
        {
            ss2+=max(s2[i],s2[i-1]);
        }
    }
    if(ss1==ss2)
    {
        cout<<ss1;
    }
    else
    {
        cout<<ss1<<endl<<ss2;
    }
}

L1-087 机工士姆斯塔迪奥

MMORPG《最终幻想14》的副本“乐欲之所瓯博讷修道院”里，BOSS 机工士姆斯塔迪奥将会接受玩家的挑战。

你需要处理这个副本其中的一个机制：N×M 大小的地图被拆分为了 N×M 个 1×1 的格子，BOSS 会选择若干行或/及若干列释放技能，玩家不能站在释放技能的方格上，否则就会被击中而失败。

给定 BOSS 所有释放技能的行或列信息，请你计算出最后有多少个格子是安全的。

输入格式:

输入第一行是三个整数 N,M,Q (1≤N×M≤105，0≤Q≤1000)，表示地图为 N 行 M 列大小以及选择的行/列数量。

接下来 Q 行，每行两个数 Ti​,Ci​，其中 Ti​=0 表示 BOSS 选择的是一整行，Ti​=1 表示选择的是一整列，Ci​ 为选择的行号/列号。行和列的编号均从 1 开始。

输出格式:

输出一个数，表示安全格子的数量。

输入样例:

5 5 3
0 2
0 4
1 3

输出样例:

12

思路：先给符合条件的格子标色，再遍历地图，但是才15分。

代码：

#include <bits/stdc++.h>
 
using namespace  std;
const int N = 100010;
int n, m, k;
bool hang[N], lie[N];
 
void solve(){
	while (k -- ){
		int a, b;
		cin >> a >> b;
		if (a == 0){
			if (!hang[b]){
				hang[b] = 1;
				n -- ;
			}
		}else{
			if (!lie[b]){
				lie[b] = 1;
				m --;
			}
		}
	}
	cout << n * m << endl;
}
 
int main(){
	scanf("%d%d%d",&n, &m, &k);
 
	solve();
	return 0;
}

L1-088 静静的推荐

天梯赛结束后，某企业的人力资源部希望组委会能推荐一批优秀的学生，这个整理推荐名单的任务就由静静姐负责。企业接受推荐的流程是这样的：

• 只考虑得分不低于 175 分的学生；
• 一共接受 K 批次的推荐名单；
• 同一批推荐名单上的学生的成绩原则上应严格递增；
• 如果有的学生天梯赛成绩虽然与前一个人相同，但其参加过 PAT 考试，且成绩达到了该企业的面试分数线，则也可以接受。

给定全体参赛学生的成绩和他们的 PAT 考试成绩，请你帮静静姐算一算，她最多能向企业推荐多少学生？

输入格式：

输入第一行给出 3 个正整数：N（≤105）为参赛学生人数，K（≤5×103）为企业接受的推荐批次，S（≤100）为该企业的 PAT 面试分数线。

随后 N 行，每行给出两个分数，依次为一位学生的天梯赛分数（最高分 290）和 PAT 分数（最高分 100）。

输出格式：

在一行中输出静静姐最多能向企业推荐的学生人数。

输入样例：

10 2 90
203 0
169 91
175 88
175 0
175 90
189 0
189 0
189 95
189 89
256 100

输出样例：

8

样例解释：

第一批可以选择 175、189、203、256 这四个分数的学生各一名，此外 175 分 PAT 分数达到 90 分的学生和 189 分 PAT 分数达到 95 分的学生可以额外进入名单。第二批就只剩下 175、189 两个分数的学生各一名可以进入名单了。最终一共 8 人进入推荐名单。

思路：设置标志来区别选了没，前面尽量选没参加过 PAT 考试，且成绩达到了该企业的面试分数线。

代码：

#include <bits/stdc++.h>
using namespace std;
int n,s,k,a[300];//用于记录同一个分数有多少人 
int main(){
	cin>>n>>k>>s;
	int ans=0;
	while(n--){
		int t,p;
		cin>>t>>p;
		if(t>=175)//根据1，刷掉天梯赛成绩小于175的同学学 
		{
			if(p>=s)//根据3，天梯赛>=175&& pat>=s 
			ans++;
			else//根据3，记录天梯赛成绩为t的同学有多少人 
			{
				a[t]++;
			}
		} 
	}
	for(int i=175;i<=290;i++){
		ans+=min(a[i],k);//根据2，求出同一个分数段的同学有多少可以录用 
	}
	cout<<ans;
	return 0;
}