2020年HZNU天梯训练赛 Round 6

2020年HZNU天梯训练赛 Round 6

时间：2020.7.21 18 169

完成情况：

1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
√	√	√	√	√	√	√	√	√		√	※
											✘

√ 当场做出来 ※做了一半来 ✘补题补出来

7-1 寻找250 (10分)

对方不想和你说话，并向你扔了一串数…… 而你必须从这一串数字中找到“250”这个高大上的感人数字。

输入格式：

输入在一行中给出不知道多少个绝对值不超过1000的整数，其中保证至少存在一个“250”。

输出格式：

在一行中输出第一次出现的“250”是对方扔过来的第几个数字（计数从1开始）。题目保证输出的数字在整型范围内。

输入样例：

888 666 123 -233 250 13 250 -222

输出样例：

5

不知道个数的输入，用while读入，用i计数

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int x,i=1;
	while(cin>>x)
	{
		if(x==250){cout<<i;break;}
		else i++;
	}
	return 0;
}

7-2 日期格式化 (5分)

世界上不同国家有不同的写日期的习惯。比如美国人习惯写成“月-日-年”，而中国人习惯写成“年-月-日”。下面请你写个程序，自动把读入的美国格式的日期改写成中国习惯的日期。

输入格式：

输入在一行中按照“mm-dd-yyyy”的格式给出月、日、年。题目保证给出的日期是1900年元旦至今合法的日期。

输出格式：

在一行中按照“yyyy-mm-dd”的格式给出年、月、日。

输入样例：

03-15-2017

输出样例：

2017-03-15

给定位数和用0填充的输出——%0xd（x为需要的位数）

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int y,m,d;
	scanf("%d-%d-%d",&m,&d,&y);
	printf("%04d-%02d-%02d",y,m,d);
	return 0;
}

7-3 阅览室 (20分)

天梯图书阅览室请你编写一个简单的图书借阅统计程序。当读者借书时，管理员输入书号并按下S键，程序开始计时；当读者还书时，管理员输入书号并按下E键，程序结束计时。书号为不超过1000的正整数。当管理员将0作为书号输入时，表示一天工作结束，你的程序应输出当天的读者借书次数和平均阅读时间。

注意：由于线路偶尔会有故障，可能出现不完整的纪录，即只有S没有E，或者只有E没有S的纪录，系统应能自动忽略这种无效纪录。另外，题目保证书号是书的唯一标识，同一本书在任何时间区间内只可能被一位读者借阅。

输入格式：

输入在第一行给出一个正整数N（≤10），随后给出N天的纪录。每天的纪录由若干次借阅操作组成，每次操作占一行，格式为：

书号（[1, 1000]内的整数） 键值（S或E） 发生时间（hh:mm，其中hh是[0,23]内的整数，mm是[0, 59]内整数）

每一天的纪录保证按时间递增的顺序给出。

输出格式：

对每天的纪录，在一行中输出当天的读者借书次数和平均阅读时间（以分钟为单位的精确到个位的整数时间）。

输入样例：

3
1 S 08:10
2 S 08:35
1 E 10:00
2 E 13:16
0 S 17:00
0 S 17:00
3 E 08:10
1 S 08:20
2 S 09:00
1 E 09:20
0 E 17:00

输出样例：

2 196
0 0
1 60

时间的统计，h和m的巧妙转化（h*60+m）进行计算，想了好久差点要用分类讨论。

输出折腾了好久 因为要以分钟为单位的精确到个位的整数时间，即四舍五入。

想起了之前的四舍五入法——double+0.5再向下取整。

以及sum为0的时候不能作为除数。

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int n,x,h,m,cnt,ans;
	double sum;
	int time[1005],flag[1005];//flag数组记录编号为i的书有没有被借阅
	char c;
	cin>>n;
	for(int i=0;i<n;i++)
	{
		memset(time,0,sizeof(time));
		memset(flag,0,sizeof(flag));
		sum=0.0;cnt=0;ans=0;
		while(~scanf("%d %c %d:%d",&x,&c,&h,&m)&&x)
		{
			//if(x==0)break;
			if(c=='S') {time[x]=h*60+m,flag[x]=1;} 
			else if(c=='E') 
			{
                if(flag[x]==1)
				{
                    flag[x]=0;
                    sum+=h*60+m-time[x];
                    time[x]=0;cnt++;
                }
            }
		}
		if(cnt!=0) cout<<cnt<<" "<<(int)(sum/cnt+0.5)<<endl;
		else cout<<cnt<<" "<<sum<<endl;
	}
	return 0;
}

7-4 稳赢 (15分)

大家应该都会玩“锤子剪刀布”的游戏：两人同时给出手势，胜负规则如图所示：

现要求你编写一个稳赢不输的程序，根据对方的出招，给出对应的赢招。但是！为了不让对方输得太惨，你需要每隔K次就让一个平局。

输入格式：

输入首先在第一行给出正整数K（≤10），即平局间隔的次数。随后每行给出对方的一次出招：ChuiZi代表“锤子”、JianDao代表“剪刀”、Bu代表“布”。End代表输入结束，这一行不要作为出招处理。

输出格式：

对每一个输入的出招，按要求输出稳赢或平局的招式。每招占一行。

输入样例：

2
ChuiZi
JianDao
Bu
JianDao
Bu
ChuiZi
ChuiZi
End

输出样例：

Bu
ChuiZi
Bu
ChuiZi
JianDao
ChuiZi
Bu

string能够直接用（s=="End"）这样的句子判断，更加方便

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int k,cnt=0;
    string s;
    cin>>k;
    while(cin>>s)
    {
        if(s=="End")break;
        cnt++;
        if(cnt%k==1&&cnt!=1){cout<<s<<endl;cnt=0;}
        else
        {
            if(s=="Bu")cout<<"JianDao"<<endl;
            if(s=="ChuiZi")cout<<"Bu"<<endl;
            if(s=="JianDao")cout<<"ChuiZi"<<endl;
        }
    }
    return 0;
}

7-5 宇宙无敌大招呼 (5分)

据说所有程序员学习的第一个程序都是在屏幕上输出一句“Hello World”，跟这个世界打个招呼。作为天梯赛中的程序员，你写的程序得高级一点，要能跟任意指定的星球打招呼。

输入格式：

输入在第一行给出一个星球的名字S，是一个由不超过7个英文字母组成的单词，以回车结束。

输出格式：

在一行中输出Hello S，跟输入的S星球打个招呼。

输入样例：

Mars

输出样例：

Hello Mars

#include<bits/stdc++.h>
using namespace std;
int main()
{
	char s[7];
	cin>>s;
	cout<<"Hello "<<s;
	return 0;
}

7-6 整除光棍 (20分)

这里所谓的“光棍”，并不是指单身汪啦~ 说的是全部由1组成的数字，比如1、11、111、1111等。传说任何一个光棍都能被一个不以5结尾的奇数整除。比如，111111就可以被13整除。 现在，你的程序要读入一个整数x，这个整数一定是奇数并且不以5结尾。然后，经过计算，输出两个数字：第一个数字s，表示x乘以s是一个光棍，第二个数字n是这个光棍的位数。这样的解当然不是唯一的,题目要求你输出最小的解。

提示：一个显然的办法是逐渐增加光棍的位数，直到可以整除x为止。但难点在于，s可能是个非常大的数 —— 比如，程序输入31，那么就输出3584229390681和15，因为31乘以3584229390681的结果是111111111111111，一共15个1。

输入格式：

输入在一行中给出一个不以5结尾的正奇数x（<1000）。

输出格式：

在一行中输出相应的最小的s和n，其间以1个空格分隔。

输入样例：

31

输出样例：

3584229390681 15

#include<bits/stdc++.h>
using namespace std;
int main()
{
	char s[1100];
	int x,n=0,len=0,temp=0,t1=0,t2,flag=0;
	cin>>x;
	while(1)
	{
		n++;
		temp=t1*10+1;
		t1=temp%x;t2=temp/x;
		if(t2!=0||flag!=0){flag=1;s[len++]=t2+'0';}	
		if(t1==0){s[len++]='\0';cout<<s<<" "<<n;break;}
	}
	return 0;
}

7-7 装睡 (10分)

你永远叫不醒一个装睡的人 —— 但是通过分析一个人的呼吸频率和脉搏，你可以发现谁在装睡！医生告诉我们，正常人睡眠时的呼吸频率是每分钟15-20次，脉搏是每分钟50-70次。下面给定一系列人的呼吸频率与脉搏，请你找出他们中间有可能在装睡的人，即至少一项指标不在正常范围内的人。

输入格式：

输入在第一行给出一个正整数N（≤10）。随后N行，每行给出一个人的名字（仅由英文字母组成的、长度不超过3个字符的串）、其呼吸频率和脉搏（均为不超过100的正整数）。

输出格式：

按照输入顺序检查每个人，如果其至少一项指标不在正常范围内，则输出其名字，每个名字占一行。

输入样例：

4
Amy 15 70
Tom 14 60
Joe 18 50
Zoe 21 71

输出样例：

Tom
Zoe

#include<bits/stdc++.h>
using namespace std;

int main()
{
	int n,x,y;
	char s[3];
	cin>>n;
	while(n--)
	{
		cin>>s>>x>>y;
		if(x<15||x>20||y<50||y>70)cout<<s<<endl;
	}
	return 0;
}

7-8 矩阵A乘以B (15分)

给定两个矩阵A和B，要求你计算它们的乘积矩阵A**B。需要注意的是，只有规模匹配的矩阵才可以相乘。即若A有R**a行、C**a列，B有R**b行、C**b列，则只有C**a与R**b相等时，两个矩阵才能相乘。

输入格式：

输入先后给出两个矩阵A和B。对于每个矩阵，首先在一行中给出其行数R和列数C，随后R行，每行给出C个整数，以1个空格分隔，且行首尾没有多余的空格。输入保证两个矩阵的R和C都是正数，并且所有整数的绝对值不超过100。

输出格式：

若输入的两个矩阵的规模是匹配的，则按照输入的格式输出乘积矩阵A**B，否则输出Error: Ca != Rb，其中Ca是A的列数，Rb是B的行数。

输入样例1：

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

输出样例1：

2 4
20 22 24 16
53 58 63 28

输入样例2：

3 2
38 26
43 -5
0 17
3 2
-11 57
99 68
81 72

输出样例2：

Error: 2 != 3

看清题目！看清题目！看清题目！

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int ra,ca,rb,cb;
    cin>>ra>>ca;
    int a[ra][ca];
	for(int i=0;i<ra;i++)
		for(int j=0;j<ca;j++)
			cin>>a[i][j];
	cin>>rb>>cb;
    int b[rb][cb],c[ra][cb],x;
    //memset(c,0,sizeof(c));
	for(int i=0;i<rb;i++)
		for(int j=0;j<cb;j++)
			cin>>b[i][j];
	if(ca!=rb){cout<<"Error: "<<ca<<" != "<<rb;}
	else
	{
		cout<<ra<<" "<<cb<<endl;//没看清题目 少写了这一步 错了好多遍😢
		for(int i=0;i<ra;i++)
		{
			for(int j=0;j<cb;j++)
			{
				x=0;
				for(int k=0;k<ca;k++)
					//c[i][j]+=a[i][k]*b[k][j];
					x+=a[i][k]*b[k][j];
				if(j<cb-1) cout<<x<<" ";
				else cout<<x<<endl;;
			}
		}
	}
	/*for(int i=0;i<ra;i++)
	{
		for(int j=0;j<cb;j++)
		{
			cout<<c[i][j];
			if(j!=cb-1)cout<<" ";		
		}
		cout<<endl;
	}*/
    return 0;
}

7-9 点赞狂魔 (25分)

微博上有个“点赞”功能，你可以为你喜欢的博文点个赞表示支持。每篇博文都有一些刻画其特性的标签，而你点赞的博文的类型，也间接刻画了你的特性。然而有这么一种人，他们会通过给自己看到的一切内容点赞来狂刷存在感，这种人就被称为“点赞狂魔”。他们点赞的标签非常分散，无法体现出明显的特性。本题就要求你写个程序，通过统计每个人点赞的不同标签的数量，找出前3名点赞狂魔。

输入格式：

输入在第一行给出一个正整数N（≤100），是待统计的用户数。随后N行，每行列出一位用户的点赞标签。格式为“Name K F1⋯F**K”，其中Name是不超过8个英文小写字母的非空用户名，1≤K≤1000，F**i（i=1,⋯,K）是特性标签的编号，我们将所有特性标签从 1 到 107 编号。数字间以空格分隔。

输出格式：

统计每个人点赞的不同标签的数量，找出数量最大的前3名，在一行中顺序输出他们的用户名,其间以1个空格分隔,且行末不得有多余空格。如果有并列，则输出标签出现次数平均值最小的那个，题目保证这样的用户没有并列。若不足3人，则用-补齐缺失，例如mike jenny -就表示只有2人。

输入样例：

5
bob 11 101 102 103 104 105 106 107 108 108 107 107
peter 8 1 2 3 4 3 2 5 1
chris 12 1 2 3 4 5 6 7 8 9 1 2 3
john 10 8 7 6 5 4 3 2 1 7 5
jack 9 6 7 8 9 10 11 12 13 14

输出样例：

jack chris john

这里用到很简便很巧妙的排序方法，用一个comp概括所有判断条件

#include<bits/stdc++.h>
using namespace std;
struct node{char name[10];int k;set<int> z;}id[105];

bool comp(struct node a,struct node b)
{
    if(a.z.size()!=b.z.size()) return a.z.size()>b.z.size();
    else return 1.0*a.z.size()/a.k>1.0*b.z.size()/b.k;
}

int main()
{
    int n,x;
    cin>>n;
    for(int i=0;i<n;i++)
    {
    	cin>>id[i].name>>id[i].k;
    	for(int j=0;j<id[i].k;j++)
    	{cin>>x;id[i].z.insert(x);}
	}
	sort(id,id+n,comp);
	for(int i=0;i<3;i++)
	{
		if(i>=n){cout<<"-";if(i<2) cout<<" ";}//n>=1;
		else{cout<<id[i].name;if(i<2) cout<<" ";}	
	}
    return 0;
}

7-10 重排链表 (25分)

给定一个单链表 L1→L2→⋯→L**n−1→L**n，请编写程序将链表重新排列为 L**n→L1→L**n−1→L2→⋯。例如：给定L为1→2→3→4→5→6，则输出应该为6→1→5→2→4→3。

输入格式：

每个输入包含1个测试用例。每个测试用例第1行给出第1个结点的地址和结点总个数，即正整数N (≤105)。结点的地址是5位非负整数，NULL地址用−1表示。

接下来有N行，每行格式为：

Address Data Next

其中Address是结点地址；Data是该结点保存的数据，为不超过105的正整数；Next是下一结点的地址。题目保证给出的链表上至少有两个结点。

输出格式：

对每个测试用例，顺序输出重排后的结果链表，其上每个结点占一行，格式与输入相同。

输入样例：

00100 6
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

输出样例：

68237 6 00100
00100 1 99999
99999 5 12309
12309 2 00000
00000 4 33218
33218 3 -1

7-11 图着色问题 (25分)

图着色问题是一个著名的NP完全问题。给定无向图G=(V,E)，问可否用K种颜色为V中的每一个顶点分配一种颜色，使得不会有两个相邻顶点具有同一种颜色？

但本题并不是要你解决这个着色问题，而是对给定的一种颜色分配，请你判断这是否是图着色问题的一个解。

输入格式：

输入在第一行给出3个整数V（0<V≤500）、E（≥0）和K（0<K≤V），分别是无向图的顶点数、边数、以及颜色数。顶点和颜色都从1到V编号。随后E行，每行给出一条边的两个端点的编号。在图的信息给出之后，给出了一个正整数N（≤20），是待检查的颜色分配方案的个数。随后N行，每行顺次给出V个顶点的颜色（第i个数字表示第i个顶点的颜色），数字间以空格分隔。题目保证给定的无向图是合法的（即不存在自回路和重边）。

输出格式：

对每种颜色分配方案，如果是图着色问题的一个解则输出Yes，否则输出No，每句占一行。

输入样例：

6 8 3
2 1
1 3
4 6
2 5
2 4
5 4
5 6
3 6
4
1 2 3 3 1 2
4 5 6 6 4 5
1 2 3 4 5 6
2 3 4 2 3 4

输出样例：

Yes
Yes
No
No

无向图染色问题（ NP完全问题 ）

NP类问题将问题分为求解和验证两个阶段，问题的求解是非确定性的，无法在多项式时间内得到答案，而问题的验证却是确定的，能够在多项式时间里确定结果。

NP中的一类比较特殊的问题，这类问题中每个问题的复杂度与整个类的复杂度有关联性，假如其中任意一个问题在多项式时间内可解的，则这一类问题都是多项式时间可解。这些问题被称为NP完全问题。

#include<bits/stdc++.h>
using namespace std;
int a[505],v,e,k,flag;
vector<int> G[505];
//本题在题目中明确顶点数与颜色数不会大于500，但是并没有给出边数的上限； 
int main() 
{
	int x,y,t;
	cin>>v>>e>>k;
	for(int i=1;i<=e;i++) 
	{
		cin>>x>>y;
		G[x].push_back(y);
		G[y].push_back(x);
	}
	cin>>t;
	while(t--) 
	{
		map<int,int> m;
		//memset(m,0,sizeof(m));
		for(int i=1; i<=v; i++) {cin>>a[i];m[a[i]]=1;}
		if(m.size()!=k) cout<<"No"<<endl;
		else 
		{
			flag=1;
			for(int i=1;i<=v;i++) 
				for(int j=0;j<G[i].size();j++) 
					if(a[i]==a[G[i][j]]) flag=0;
			if(flag) cout<<"Yes"<<endl;
			else cout<<"No"<<endl;
		}
	}
	return  0;
}

区间图着色问题（贪心算法的解法）

问题描述：假设要用很多个教室对一组活动进行调度。我们希望使用尽可能少的教室来调度所有活动。请给出一个算法，来确定哪一个活动使用哪一间教室。这个问题也被称为区间图着色问题，即相容的活动着同色，不相容的着不同颜色，使得所用颜色数最少。

解法思想：

其实我们知道，对于单个教室我们可以用贪心算法进行求解，但是对于这个区间图的问题，我们采用的方法是多次的贪心。其实你想想看，你无非就是要使那些活动

全部被安排完吧，当然这样安排的方法很多，如何使得安排后的教室最小呢？？？？

这明显也是个贪心的问题。聪明的人很快地想到，是不是可以多次的贪心呢？也就是说我对这些活动作一个标记，开始全部标记为”未安排“，第一次的时候就采用贪心算

法尽可能地用一间教室安排尽可能多的活动进去，然后将安排过的活动标记为”己安排“。然后对剩下的活动再进行用同样的贪心算法进行安排。

7-12 部落 (25分)

在一个社区里，每个人都有自己的小圈子，还可能同时属于很多不同的朋友圈。我们认为朋友的朋友都算在一个部落里，于是要请你统计一下，在一个给定社区中，到底有多少个互不相交的部落？并且检查任意两个人是否属于同一个部落。

输入格式：

输入在第一行给出一个正整数N（≤104），是已知小圈子的个数。随后N行，每行按下列格式给出一个小圈子里的人：

K P[1] P[2] ⋯ P[K]

其中K是小圈子里的人数，P[i]（i=1,⋯,K）是小圈子里每个人的编号。这里所有人的编号从1开始连续编号，最大编号不会超过104。

之后一行给出一个非负整数Q（≤104），是查询次数。随后Q行，每行给出一对被查询的人的编号。

输出格式：

首先在一行中输出这个社区的总人数、以及互不相交的部落的个数。随后对每一次查询，如果他们属于同一个部落，则在一行中输出Y，否则输出N。

输入样例：

4
3 10 1 2
2 3 4
4 1 5 7 8
3 9 6 4
2
10 5
3 7

输出样例：

10 2
Y
N

考试的时候有两个测试点超时（19/25），debug了很久还没找出来

19分代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
int pre[maxn];
/*//并查集板子 
int find(int x)
{
   //while(x!=pre[x])  //如果该结点的父结点不是它自身
　　　　//x=pre[x];  //那么就继续找它的父结点的父结点
　 return x==pre[x]?x:find(pre[x]);
}
//查找函数：用于查找结点的父结点。
void Union(int x,int y)
{
　　int fx=find(x);  //找到x的根结点
　　int fy=find(y);  //找到y的根结点
　　if(fx!=fy)  //如果x和y的根结点不相同（x和y不属于同一个联通分支）
　　　　pre[fx]=fy; //就把x的根结点的父结点改为y的根结点
}//合并函数 
*/
int Find(int x)
{
	return x==pre[x]?x:Find(pre[x]);
}
void Union(int x,int y)
{
	int fx=Find(x);  
	int fy=Find(y); 
	if(fx!=fy)  
		pre[fx]=fy;
}
void init()
{
	for(int i=0;i<=maxn;i++)pre[i]=i;
}
int main()
{
	int n,m,k,t,mxnn=-1,a[maxn],num=0;
    init();
    cin>>t;
    while(t--)
    {
        cin>>k;
		memset(a,0,sizeof(a)); 
        for(int i=0;i<k;i++)
        {
            cin>>a[i];
            if(a[i]>mxnn) mxnn=a[i];
        }
        for(int i=1;i<k;i++) Union(a[i-1],a[i]);
    }
    for(int i=1;i<=mxnn;i++)
        if(Find(pre[i])==i)num++;
    cout<<mxnn<<" "<<num<<endl;
    cin>>t;
    while(t--)
    {
        cin>>n>>m;
        if(Find(pre[n])==Find(pre[m])) cout<<"Y"<<endl;
        else cout<<"N"<<endl;
	}
	return 0;
}

7-13 森森快递 (30分)

森森开了一家快递公司，叫森森快递。因为公司刚刚开张，所以业务路线很简单，可以认为是一条直线上的N个城市，这些城市从左到右依次从0到(N−1)编号。由于道路限制，第i号城市（i=0,⋯,N−2）与第(i+1)号城市中间往返的运输货物重量在同一时刻不能超过C**i公斤。

公司开张后很快接到了Q张订单，其中j张订单描述了某些指定的货物要从S**j号城市运输到T**j号城市。这里我们简单地假设所有货物都有无限货源，森森会不定时地挑选其中一部分货物进行运输。安全起见，这些货物不会在中途卸货。

为了让公司整体效益更佳，森森想知道如何安排订单的运输，能使得运输的货物重量最大且符合道路的限制？要注意的是，发货时间有可能是任何时刻，所以我们安排订单的时候，必须保证共用同一条道路的所有货车的总重量不超载。例如我们安排1号城市到4号城市以及2号城市到4号城市两张订单的运输，则这两张订单的运输同时受2-3以及3-4两条道路的限制，因为两张订单的货物可能会同时在这些道路上运输。

输入格式：

输入在第一行给出两个正整数N和Q（2≤N≤105, 1≤Q≤105），表示总共的城市数以及订单数量。

第二行给出(N−1)个数，顺次表示相邻两城市间的道路允许的最大运货重量C**i（i=0,⋯,N−2）。题目保证每个C**i是不超过231的非负整数。

接下来Q行，每行给出一张订单的起始及终止运输城市编号。题目保证所有编号合法，并且不存在起点和终点重合的情况。

输出格式：

在一行中输出可运输货物的最大重量。

输入样例：

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

输出样例：

7

样例提示：我们选择执行最后两张订单，即把5公斤货从城市4运到城市2，并且把2公斤货从城市4运到城市5，就可以得到最大运输量7公斤。

https://blog.csdn.net/iroy33/article/details/88894362

7-14 森森美图 (30分)

森森最近想让自己的朋友圈熠熠生辉，所以他决定自己写个美化照片的软件，并起名为森森美图。众所周知，在合照中美化自己的面部而不美化合照者的面部是让自己占据朋友圈高点的绝好方法，因此森森美图里当然得有这个功能。 这个功能的第一步是将自己的面部选中。森森首先计算出了一个图像中所有像素点与周围点的相似程度的分数，分数越低表示某个像素点越“像”一个轮廓边缘上的点。 森森认为，任意连续像素点的得分之和越低，表示它们组成的曲线和轮廓边缘的重合程度越高。为了选择出一个完整的面部，森森决定让用户选择面部上的两个像素点A和B，则连接这两个点的直线就将图像分为两部分，然后在这两部分中分别寻找一条从A到B且与轮廓重合程度最高的曲线，就可以拼出用户的面部了。 然而森森计算出来得分矩阵后，突然发现自己不知道怎么找到这两条曲线了，你能帮森森当上朋友圈的小王子吗？

为了解题方便，我们做出以下补充说明：

• 图像的左上角是坐标原点(0,0)，我们假设所有像素按矩阵格式排列，其坐标均为非负整数（即横轴向右为正，纵轴向下为正）。
• 忽略正好位于连接A和B的直线（注意不是线段）上的像素点，即不认为这部分像素点在任何一个划分部分上，因此曲线也不能经过这部分像素点。
• 曲线是八连通的（即任一像素点可与其周围的8个像素连通），但为了计算准确，某像素连接对角相邻的斜向像素时，得分额外增加两个像素分数和的√2倍减一。例如样例中，经过坐标为(3,1)和(4,2)的两个像素点的曲线，其得分应该是这两个像素点的分数和(2+2)，再加上额外的(2+2)乘以(√2−1)，即约为5.66。

输入格式：

输入在第一行给出两个正整数N和M（5≤N,M≤100），表示像素得分矩阵的行数和列数。

接下来N行，每行M个不大于1000的非负整数，即为像素点的分值。

最后一行给出用户选择的起始和结束像素点的坐标(Xstar**t,Ystar**t)和(Xen**d,Yen**d)。4个整数用空格分隔。

输出格式：

在一行中输出划分图片后找到的轮廓曲线的得分和，保留小数点后两位。注意起点和终点的得分不要重复计算。

输入样例：

6 6
9 0 1 9 9 9
9 9 1 2 2 9
9 9 2 0 2 9
9 9 1 1 2 9
9 9 3 3 1 1
9 9 9 9 9 9
2 1 5 4

输出样例：

27.04

https://blog.csdn.net/Solitarily/article/details/79473754

https://blog.csdn.net/qq_40822492/article/details/86709114

7-15 二叉搜索树的结构 (30分)

二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。（摘自百度百科）

给定一系列互不相等的整数，将它们顺次插入一棵初始为空的二叉搜索树，然后对结果树的结构进行描述。你需要能判断给定的描述是否正确。例如将{ 2 4 1 3 0 }插入后，得到一棵二叉搜索树，则陈述句如“2是树的根”、“1和4是兄弟结点”、“3和0在同一层上”（指自顶向下的深度相同）、“2是4的双亲结点”、“3是4的左孩子”都是正确的；而“4是2的左孩子”、“1和3是兄弟结点”都是不正确的。

输入格式：

输入在第一行给出一个正整数N（≤100），随后一行给出N个互不相同的整数，数字间以空格分隔，要求将之顺次插入一棵初始为空的二叉搜索树。之后给出一个正整数M（≤100），随后M行，每行给出一句待判断的陈述句。陈述句有以下6种：

• A is the root，即"A是树的根"；
• A and B are siblings，即"A和B是兄弟结点"；
• A is the parent of B，即"A是B的双亲结点"；
• A is the left child of B，即"A是B的左孩子"；
• A is the right child of B，即"A是B的右孩子"；
• A and B are on the same level，即"A和B在同一层上"。

题目保证所有给定的整数都在整型范围内。

输出格式：

对每句陈述，如果正确则输出Yes，否则输出No，每句占一行。

输入样例：

5
2 4 1 3 0
8
2 is the root
1 and 4 are siblings
3 and 0 are on the same level
2 is the parent of 4
3 is the left child of 4
1 is the right child of 2
4 and 0 are on the same level
100 is the right child of 3

输出样例：

Yes
Yes
Yes
Yes
Yes
No
No
No