【考试总结】2021.3.13考试总结

今天是2021年3月13日，\(mjl\)告诉我们，今天要考搜索。

我们：什么玩意儿？？？Σ(っ °Д °;)っ

本人最终成绩：\(0+0+70+0+86+10=166\)

反正就是挺无语的

废话不多说，接下来直接进入

题解时间

---

T1 午餐费（lunch.cpp）

原题链接（CQBZOJ）

题目描述

现要对某班学生进行N天培训，该班所有学生都订了N天的午餐，所以我们知道他们每天要花多少钱。现在该班班主任需要决定如何使用班费。由于钱有限，他们不可能每天都吃免费午餐。因此，每天班主任可以选择自己支付或使用班费支付当天午餐费。当然，班主任比较小气，希望尽可能多地花掉班费，但是他太忙了，请你帮他计算他最多能够花多少班费。

输入格式

输入包含多个测试数据（不超过50个）。

每个测试数据有两行。第一行有两个整数，N为培训天数，M为班费总数。

第二行包含N个正整数，其中第i个整数表示该班当天需要支付第午餐的钱。所有这些整数都不超过10000000，整数之间用空格分隔。

输出格式

对于每个测试数据，输出一行整数，表示班主任能够花班费的最大金额

样例输入

3 10
8 4 5

样例输出

9

数据范围与提示

\(1\leq N\leq 30\)

\(0\leq M\leq 10000000\)

---

《论考试不看题不加多组输入考后直接崩掉》

但是其实就是加了估计也是0分，只是从WA变成TLE而已

这就是一道简化版的The Robbery。具体可以参照这篇题解，（考试题目少了一个较为复杂的优化）这里再简单提一下。

基础的搜索很简单，就是在搜索每一天的情况时继续搜索用班费支付和自己支付两种情况。

但是……请看一下数据范围……

这一看就是要优化。

首先是排序，按照从大到小排，因为根据简单的贪心思维，先选大的取到最优解的可能性更大。

然后再求一下后缀和，如果在某个情况时前面已经选了的和后面所有没有选的还小于当前最大值，就直接\(return\)。（最优性剪枝）

最后还要注意一下，因为是多组输入，所以统计后缀和的数组需要清空一下。

代码：

#include<bits/stdc++.h>
using namespace std;
int m,n,a[35],ans=0,hzh[35];
bool cmp(int x,int y){
	if(x<y)return false;
	return true;
}
void dfs(int t,int sum){
	if(sum+hzh[t]<ans||sum>m)return;
	if(t==n+1){
		ans=max(ans,sum);
		return;
	}
	//用班费
	if(sum+a[t]<=m)dfs(t+1,sum+a[t]); 
	//不用班费 
	dfs(t+1,sum);
	return;
}
int main(){
	//freopen("lunch.in","r",stdin);
	//freopen("lunch.out","w",stdout);
	while(scanf("%d %d",&n,&m)!=EOF){
		for(int i=1;i<=n;i++){
			scanf("%d",&a[i]);
		}
		sort(a+1,a+n+1,cmp);
		for(int i=n;i>=1;i--){
			hzh[i]=hzh[i+1]+a[i];
		}
		dfs(1,0);
		printf("%d\n",ans);
		ans=0;
		memset(hzh,0,sizeof(hzh));
	}
	return 0;
} 

---

T2 生日快乐（birthday.cpp）

原题链接（CQBZOJ）

原题链接（洛谷）

题目描述

windy的生日到了，为了庆祝生日，他的朋友们帮他买了一个边长分别为 X 和 Y 的矩形蛋糕。现在包括windy，一共有 N 个人来分这块大蛋糕，要求每个人必须获得相同面积的蛋糕。windy主刀，每一切只能平行于一块蛋糕的一边（任意一边），并且必须把这块蛋糕切成两块。这样，要切成 N 块蛋糕，windy必须切 N-1 次。为了使得每块蛋糕看起来漂亮，我们要求 N块蛋糕的长边与短边的比值的最大值最小。你能帮助windy求出这个比值么？

输入格式

包含三个整数，\(X\ Y\ N\)。

\(1 <= X,Y <= 10000\) ； \(1 <= N <= 10\)

输出格式

包含一个浮点数，保留6位小数。

样例输入

5 5 5

样例输出

1.800000

---

蓝题中的水题

诶你别说这道题还挺应景的毕竟3.13是我一个朋友的生日嘛

虽然如此，但是我还是没把它做出来（汗）

这道题主要难在思路（其实也不难），思路出来了基本上就没多大问题了。

这道题目看起来是个二分，但只要稍微冷静地分析一下就会发现这道题不能用二分（灵魂拷问原因：我该怎么二分？这个答案它有规律吗？我连一个递增序列都搞不出来！就算弄出来了该怎么check？还不是深搜吗？？？），再想一下（其实是因为这是一次搜索测试啦），这道题是可以用DFS解决的，其思路和巧克力棒差不多。

首先我们假设这是一块长为\(x\)宽为\(y\)的蛋糕，需要把它分给\(n\)个人。

我们可以横着切（平行于\(X\)轴）或者竖着切（平行于\(Y\)轴）。那么切哪里呢？

因为我们要把这个蛋糕分给\(n\)个人，所以我们就切这条边可以被\(n\)整除的地方。如图。

最后我们来看一下出口：假如说这个\(n=1\)了，就说明不需要再切了，这个时候我们返回一下长与宽的比值。

（特别注意：最大比例的最小值，不要把\(max\)和\(min\)用反了）

代码：

#include<bits/stdc++.h>
using namespace std;
double bzmax=INT_MAX;
double dfs(double x,double y,int n){
	if(n==1)return max(x,y)*1.0/min(x,y);
	double bzmax=INT_MAX;
	for(int i=1;i<=n/2;i++){//因为切上面和下面都是一样的，所以只用切一半
		bzmax=min(max(dfs(x,i*y/n,i),dfs(x,y-i*y/n,n-i)),bzmax);//x
		bzmax=min(max(dfs(i*x/n,y,i),dfs(x-i*x/n,y,n-i)),bzmax);//y
	}
	return bzmax;
}
int main(){
	//freopen("birthday.in","r",stdin);
	//freopen("birthday.out","w",stdout);
	int x,y,n;
	scanf("%d %d %d",&x,&y,&n);
	printf("%.6lf",dfs(x,y,n));
	return 0;
}

---

T3 碎纸机（paper.cpp）

原题链接（CQBZOJ）

题目描述

你现在负责设计一种新式的碎纸机。一般的碎纸机会把纸切成小片，变得难以阅读。而你设计的新式的碎纸机有以下的特点：

1.每次切割之前，先要给定碎纸机一个目标数，而且在每张被送入碎纸机的纸片上也需要包含一个数。

2.碎纸机切出的每个纸片上都包括一个数。

3.要求切出的每个纸片上的数的和要不大于目标数而且与目标数最接近。

举一个例子，如下图，假设目标数是50，输入纸片上的数是12346。碎纸机会把纸片切成4块，分别包含1，2，34和6。这样这些数的和是43 (= 1 + 2 + 34 + 6)，这是所有的分割方式中，不超过50，而又最接近50的分割方式。又比如，分割成1，23，4和6是不正确的，因为这样的总和是34 (= 1 + 23 + 4 + 6)，比刚才得到的结果43小。分割成12，34和6也是不正确的，因为这时的总和是52 (= 12 + 34 + 6)，超过了50。

还有三个特别的规则：

1.如果目标数和输入纸片上的数相同，那么纸片不进行切割。

2.如果不论怎样切割，分割得到的纸片上数的和都大于目标数，那么打印机显示错误信息。

3.如果有多种不同的切割方式可以得到相同的最优结果。那么打印机显示拒绝服务信息。比如，如果目标数是15，输入纸片上的数是111，那么有两种不同的方式可以得到最优解，分别是切割成1和11或者切割成11和1，在这种情况下，打印机会显示拒绝服务信息。

为了设计这样的一个碎纸机，你需要先写一个简单的程序模拟这个打印机的工作。给定两个数，第一个是目标数，第二个是输入纸片上的数，你需要给出碎纸机对纸片的分割方式。

输入格式

输入包括多组数据，每一组包括一行。每行上包括两个正整数，分别表示目标数和输入纸片上的数。已知输入保证：两个数都不会以0开头，而且两个数至多都只包含6个数字。

输入的最后一行包括两个0，这行表示输入的结束。

输出格式

对每一组输入数据，输出相应的输出。有三种不同的输出结果：

sum part1 part2 ... 
rejected 
error 

第一种结果表示：

每一个partj是切割得到的纸片上的一个数。partj的顺序和输入纸片上原始数中数字出现的次序一致。

sum是切割得到的纸片上的数的和，也就是说：sum = part1 + part2 +...
第一种结果中相邻的两个数之间用一个空格隔开。

如果不论怎样切割，分割得到的纸片上数的和都大于目标数，那么打印“error”。

如果有多种不同的切割方式可以得到相同的最优结果，那么打印“rejected”。

样例输入

50 12346
376 144139
927438 927438
18 3312
9 3142
25 1299
111 33333
103 862150
6 1104
0 0

样例输出

43 1 2 34 6
283 144 139
927438 927438
18 3 3 12
error
21 1 2 9 9
rejected
103 86 2 15 0
rejected

---

题面很长，但是实质就是添加号问题。

不过添加号真的很难awa，我以后会写一篇相关题解，再加上本人没做对，所以这里就不详细讲了，添加号在我第一周改对了之后直到第二周都还停留在考试的70分。

考试70分代码（样例倒数第二个有未知玄学错误）：

//*
#include<bits/stdc++.h>
using namespace std;
int s,tot=0,len,ans=0,js=1;
char paper[8];
int a[8],b[8];
void dfs(int t,int sum,int last){//判断t和t+1之间的部分 last：上一个数 
	if(sum+last>s)return;
	if(t==len+1){
		if(sum>ans){
			tot=1,ans=sum;
			int i=1;
			memset(b,0,sizeof(b));
			while(a[i])b[i]=a[i],i++;
		}
		else if(sum==ans)tot++;
		return;
	}
	//切割
	a[js]=last*10+paper[t]-'0';
	js++;
	dfs(t+1,sum+last*10+paper[t]-'0',0);
	a[js]=0;
	js--;
	//不切割 
	dfs(t+1,sum,last*10+paper[t]-'0');
	return;
}
int main(){
	//freopen("paper.in","r",stdin);
	//freopen("paper.out","w",stdout);
	while(1){
		scanf("%d %s",&s,paper+1);
		len=strlen(paper+1);
		if(!s&&paper[1]=='0')return 0;
		dfs(1,0,0);
		if(tot>=2){
			printf("rejected\n");
		}
		else if(tot){
			printf("%d ",ans);
			int i=1;
			while(b[i]){
				printf("%d ",b[i]);
				i++;
			}
			printf("\n");
		}else printf("error\n");
		tot=0,ans=0,js=1;
		memset(a,0,sizeof(a));
	}
	return 0;
}

---

T4 单词序列（word.cpp）

原题链接（CQBZOJ）

《论一个人考试不记得字符串的操作函数然后直接原地爆炸的详细过程》

其实这道题应该不用这些奇奇怪怪的函数也可以做，但是当时看到这道题貌似有点难，想了一会儿思路没出来就去看别的题了。

其实这道题我们可以每一次都统计一下哪些单词和当前的单词可以转换然后在用新的单词继续搜索。

注意一个优化（最优性剪枝），不然会TLE：

拿一个数组存一下从初始单词到这个单词需要多少步，如果现在我们递归到这个单词时的步数已经大于最优的步数就直接\(return\)。

其实这道题可以用BFS做而且据说还好做一点，但是我考试是这么做的就这么写题解吧。

AC代码如下：

#include<bits/stdc++.h>
using namespace std;
int len,n,Min=INT_MAX;
char a[1005][10],end[10];
bool b[1005];
int dp[1005];//记忆化数组，表示从开头到这个单词至少需要几步 
//判断两个单词是否可以互相转换的check函数 
bool check(int x,int y){
	int sum=0;
	for(int i=1;i<=len;i++){
		if(a[x][i]!=a[y][i])sum++;
	}
	if(sum==1)return true;
	return false; 
}
//dfs函数 t：需要操作的字符串 l：目前操作的步数 bh：需要操作字符串的编号 
void dfs(char t[10],int l,int bh){
	//printf("%s %d %d\n",t,l,bh);
	if(l>=Min||dp[bh]&&l>=dp[bh])return;
	dp[bh]=l;
	if(check(bh,n+1)){//两个字符串只有一个字符不一样 
		Min=min(Min,l+1);
		return;
	}
	if(l==n)return;
	for(int i=1;i<=n;i++){
		if(!b[i]&&check(bh,i)){
			b[i]=1;
			dfs(a[i]+1,l+1,i);
			b[i]=0;
		}
	}
	return;
}
int main(){
	//freopen("word.in","r",stdin);
	//freopen("word.out","w",stdout);
	scanf("%s %s",a[0]+1,end+1);
	len=strlen(end+1);
	n=1;
	while(scanf("%s",a[n]+1)!=EOF)n++;
	strcpy(a[n+1]+1,end+1);
	dfs(a[0]+1,1,0);
	printf("%d",Min);
	return 0;
}

---

T5 炸僵尸（zombie.cpp）

原题链接（CQBZOJ）

题目描述

妈妈得知小星星成功地解决了买玩具难题，奖励他去看电影《生化危机 6》，小星星看着看着就替女主角担心起来了，因为她要对付那么多的僵尸怪物，小星星恨不得扔颗炸弹消除可恶的僵尸们，他脑袋里开始构思出这样的场景：

在一个 N 行 M 列单元格构成的地图中，去放置一个炸弹，这种炸弹威力巨大，以放置点为中心进行行列延伸炸到同行同列的僵尸，但不能穿墙。上图中可以把炸弹放置在第 3 行第 4 列，最多可以炸到 4 个僵尸，如果对地图稍加改动（如下图），在第 5 行第 4 列处加入一个墙体，又如何呢？答案还是最多炸到 4 个僵尸，只不过最佳炸弹放置点发生了变化，应该放到第 6 行第 6 列的位置。

当然炸弹要靠勇敢的小星星去放，他只能在地图中朝上下左右四个方向行进（不能斜对 角移动） ，他不能穿墙，也不能穿越僵尸，要保证他的安全，如下图，告诉你小星星起始位 置是第 2 行第 2 列，那么他的最佳放置炸弹位置应该是第 3 行第 2 列，最多炸到 2 个僵尸。

现在请聪明的你也一起加入到消除僵尸的队伍来。

输入格式

第一行四个用空格隔开的正整数表示 N,M,X,Y，分别表示 N 行 M 列的地图，小星星起 始位置第 X 行，第 Y 列。

接下来 N 行 M 列用来描述地图上每个单元格，‘ G’表示僵尸，‘#’表示墙体，只有‘.’ 表示的单元格才是小星星能够正常行走，能够放置炸弹的单元格。（数据保证四面都是墙体， 也就是第 1 行、第 N 行、第 1 列、第 M 列肯定都是墙体）。

输出格式

一个整数，最多能炸掉的僵尸数量。

样例输入

13 13 4 2
#############
###..GG#GGG.#
###.#G#G#G#G#
#.......#..G#
#G#.###.#G#G#
#GG.GGG.#.GG#
#G#.#G#.#.#.#
##G...G.....#
#G#.#G###.#G#
#...G#GGG.GG#
#G#.#G#G#.#G#
#GG.GGG#G.GG#
#############

样例输出

10

数据范围与提示

100%的数据，保证 \(N,M<2001\)

100%的数据，保证 \(X<N\)

100%的数据，保证 \(Y<M\)

---

考场上打了个广搜+记忆化得了80分，后来讲题的时候\(mjl\)说：

在两堵墙之间，横向或纵向能炸到僵尸的数量相同

然后我就很zz的在函数里面加上了这个优化……

最终从80掉到了75

后来我去问\(mjl\)，他给我看了个AC代码……（fk这玩意儿还是要加在主函数里的？！）

然后我就很顺利地A了这道题……

代码1（考场80分代码）：

#include<bits/stdc++.h>
using namespace std;
char a[2005][2005];
bool b[2005][2005];
int dp[2005][2005];
int m,n,x,y,ans=-1;
int dir[4][2]={{-1,0},{0,-1},{1,0},{0,1}};
struct s{
	int x,y;
}t1,t2;
void bfs(int x,int y){
	queue<s> q;
	t1.x=x,t1.y=y;
	q.push(t1);
	int dx,dy;
	while(!q.empty()){
		t1=q.front();
		q.pop();
		for(int i=0;i<=3;i++){
			dx=t1.x+dir[i][0],dy=t1.y+dir[i][1];
			if(dp[dx][dy])continue;
			if(dx>=1&&dx<=m&&dy>=1&&dy<=n&&!b[dx][dy]&&a[dx][dy]!='#'&&a[dx][dy]!='G'){
				b[dx][dy]=1;
				int sum=0;
				for(int i=dx;i<=m;i++){
					if(a[i][dy]=='G')sum++;
					if(a[i][dy]=='#')break;
				}
				for(int i=dx;i>=1;i--){
					if(a[i][dy]=='G')sum++;
					if(a[i][dy]=='#')break;
				}
				for(int i=dy;i<=n;i++){
					if(a[dx][i]=='G')sum++;
					if(a[dx][i]=='#')break;
				}
				for(int i=dy;i>=1;i--){
					if(a[dx][i]=='G')sum++;
					if(a[dx][i]=='#')break;
				}
				if(sum>ans)ans=sum;
				t2.x=dx,t2.y=dy;
				dp[dx][dy]=sum;
				q.push(t2);
			}
		}
	}
	return;
}
int main(){
	freopen("zombie.in","r",stdin);
	freopen("zombie.out","w",stdout);
	scanf("%d %d %d %d",&m,&n,&x,&y);
	for(int i=1;i<=m;i++){
		scanf("\n");
		for(int j=1;j<=n;j++){
			scanf("%c",&a[i][j]);
		}
	}
	bfs(x,y);
	printf("%d",ans);
	return 0;
}

代码2（AC代码）：

#include<bits/stdc++.h>
using namespace std;
char a[2005][2005];
bool b[2005][2005];
int dp1[2005][2005],dp2[2005][2005],dp3[2005][2005],dp4[2005][2005];
int m,n,x,y,ans=-1;
int dir[4][2]={{-1,0},{0,-1},{1,0},{0,1}};
struct s{
	int x,y;
}t1,t2;
void bfs(int x,int y){
	queue<s> q;
	t1.x=x,t1.y=y;
	q.push(t1);
	int dx,dy;
	while(!q.empty()){
		t1=q.front();
		q.pop();
		for(int i=0;i<=3;i++){
			dx=t1.x+dir[i][0],dy=t1.y+dir[i][1];
			if(dx>=1&&dx<=m&&dy>=1&&dy<=n&&!b[dx][dy]&&a[dx][dy]!='#'&&a[dx][dy]!='G'){
				b[dx][dy]=1;
				if(dp1[dx][dy]+dp2[dx][dy]+dp3[dx][dy]+dp4[dx][dy]>ans)
                	ans=dp1[dx][dy]+dp2[dx][dy]+dp3[dx][dy]+dp4[dx][dy];
				t2.x=dx,t2.y=dy;
				q.push(t2);
			}
		}
	}
	return;
}
int main(){
	//freopen("zombie.in","r",stdin);
	//freopen("zombie.out","w",stdout);
	scanf("%d %d %d %d",&m,&n,&x,&y);
	for(int i=1;i<=m;i++){
		scanf("\n");
		for(int j=1;j<=n;j++){
			scanf("%c",&a[i][j]);
			if(a[i][j]=='G'){
				dp1[i][j]=dp1[i][j-1]+1;
				dp2[i][j]=dp2[i-1][j]+1;
			}else{
				dp1[i][j]=dp1[i][j-1];
				dp2[i][j]=dp2[i-1][j];
			}
			if(a[i][j]=='#'){
				dp1[i][j]=0;
				dp2[i][j]=0;
			}
		}
	}
	for(int i=m;i>=1;i--){
		for(int j=n;j>=1;j--){
			if(a[i][j]=='G'){
				dp3[i][j]=dp3[i][j+1]+1;
				dp4[i][j]=dp4[i+1][j]+1;
			}else{
				dp3[i][j]=dp3[i][j+1];
				dp4[i][j]=dp4[i+1][j];
			}
			if(a[i][j]=='#'){
				dp3[i][j]=0;
				dp4[i][j]=0;
			}
		}
	}
	bfs(x,y);
	printf("%d",ans);
	return 0;
}

---

T6 A计划（plan.cpp）

原题链接（CQBZOJ）

题目描述

可怜的公主在一次次被魔王掳走一次次被骑士们救回来之后，而今，不幸的她再一次面临生命的考验。魔王已经发出消息说将在T时刻吃掉公主，因为他听信谣言说吃公主的肉也能长生不老。年迈的国王正是心急如焚，告招天下勇士来拯救公主。不过公主早已习以为常，她深信智勇的骑士LJ肯定能将她救出。

现据密探所报，公主被关在一个两层的迷宫里，迷宫的入口是S（0，0，0），公主的位置用P表示，时空传输机用#表示，墙用*表示，平地用.表示。骑士们一进入时空传输机就会被转到另一层的相对位置，但如果被转到的位置是墙的话，那骑士们就会被撞死。骑士们在一层中只能前后左右移动，每移动一格花1时刻。层间的移动只能通过时空传输机，且不需要任何时间。

输入格式

输入的第一行C表示共有C个测试数据，每个测试数据的前一行有三个整数N，M，T。 N，M迷宫的大小。T如上所意。接下去的前表示迷宫的第一层的布置情况，后表示迷宫第二层的布置情况。

输出格式
如果骑士们能够在T时刻能找到公主就输出“YES”，否则输出“NO”。

样例输入

1
5 5 14
S*#*.
.#...
.....
****.
...#.

..*.P
#.*..
***..
...*.
*.#..

样例输出

YES

数据范围与提示

\(1 <= N,M <=10\)

---

其实我根本不知道自己考试的代码为什么会错，但是经过了代码的重构与mjl的帮助之后我A了这道题。

首先思路BFS，其他的内容和走迷宫的BFS经典题目差不多，唯一的区别就是传送门，如果走到了传送门就传送到另外一层，并且这两个传送门都会走一遍。需要特别注意的是不要陷入上下两个都是传送门的死循环。

代码：

#include<bits/stdc++.h>
using namespace std;
int m,n,T;
char a[15][15][2];
bool b[15][15][2];
int dir[4][2]={{-1,0},{0,-1},{1,0},{0,1}};
struct s{
	int x,y,z,l;
}t1,t2;
//取相反数：0到1，1到0 
int f(int x){
	if(x)return 0;
	return 1;
}
bool bfs(int x,int y,int z){
	queue<s> q;
	t1.x=x,t1.y=y,t1.z=z,t1.l=0;
	q.push(t1);
	int dx,dy;
	while(!q.empty()){
		t1=q.front();
		q.pop();
		//特判：#和P
		if(a[t1.x][t1.y][t1.z]=='#'){
			if(a[t1.x][t1.y][f(t1.z)]=='P'||a[t1.x][t1.y][f(t1.z)]=='.'){
				t1.z=f(t1.z);
				q.push(t1);
			}
			continue;
		}else if(a[t1.x][t1.y][t1.z]=='P')return true;
		for(int i=0;i<=3;i++){
			dx=t1.x+dir[i][0],dy=t1.y+dir[i][1];
			if(dx>=1&&dx<=m&&dy>=1&&dy<=n&&a[dx][dy][t1.z]!='*'&&!b[dx][dy][t1.z]){
				b[dx][dy][t1.z]=1;
				t2.x=dx,t2.y=dy,t2.z=t1.z,t2.l=t1.l+1;
				if(t2.l>T)continue;
				q.push(t2);
			}
		}
	}
	return false;
}
int main(){
	freopen("plan.in","r",stdin);
	freopen("plan.out","w",stdout);
	int c,x,y,z;
	scanf("%d",&c);
	while(c--){
		memset(b,0,sizeof(b));
		scanf("%d %d %d",&m,&n,&T);
		for(int i=1;i<=m;i++){
			scanf("\n");
			for(int j=1;j<=n;j++){
				scanf("%c",&a[i][j][0]);
				if(a[i][j][0]=='S')x=i,y=j,z=0;
			}
		}
		scanf("\n");
		for(int i=1;i<=m;i++){
			scanf("\n");
			for(int j=1;j<=n;j++){
				scanf("%c",&a[i][j][1]);
				if(a[i][j][1]=='S')x=i,y=j,z=1;
			}
		}
		if(bfs(x,y,z))printf("YES\n");
		else printf("NO\n");
	}
	return 0;
}

---

总结时间

T1没看到多组输入，以为就是道水题，看到题目的背景之后没有任何联想，也没有想到那道让我犹豫了很久的The Robbery，导致一道本来会做的题丢掉100分。

T2本来这么水一道题也没有想到思路，这道题应该就是那种思路很难想，但是一想出来就很简单的那种题吧，得亏我们之前还做过一道类似的题目……

T3出了一个BUG，然后我在那个地方调了很久，其实当时应该先把这个部分分拿到之后就先去看别的题目，因为BUG不好说什么时候调得出来，可是有些题的部分分是很好得的。。。

T4因为不会函数就直接跳过了，其实就相当于我又跳过了一道比较简单的题目，所以事实证明：①函数不会不要虚，有时候手打函数比系统自带的还要快，比如说\(max\)，\(min\)等。

T5的话，还是优化方法没有完全掌握吧……平时刷题不够多。

T6属于那种过完样例就走人行为，因为10分的话确实太少了，甚至还不如直接输出一个“YES”或者“NO”的得分高，应该是很好发现的，另外再分享一下我的提交截图：

其实还有很多是在\(mjl\)的账号上提交的……有20分，30分，45分，50分，75分之类的很多，足以说明这个程序的BUG之多，然鹅我却一个也没发现(。>︿<)_θ

所以经过这次考试，可以发现：

• 考试比赛如果题目比较难，骗分和部分分永远是王道（*＾-＾*）

• 常用函数是一定要背的（而且不要被错），考试用节约时间，但是如果背不到也不要直接放弃题目，只要你手打得出来就继续做（当然如果这道题做不出来就另当别论了！）

• 安排好考试时间，如果一道题有BUG，不管可不可以拿到一部分分，也先不要在这道题死磕（尤其是死磕超过一节课的时间，即40分钟），先去看一下别的题有没有思路了。

• 认真读题。

• 要充分发挥自己的联想能力。要定期复习代码，不要以为A了就万事大吉，这样考试的联想才能发挥作用。

希望这篇博客可以帮助到大家（还有我自己），感谢观看！