CCF CSP 认证 2013-12

WALL-SQ

已于 2022-03-14 15:43:39 修改

阅读量598

点赞数 1

分类专栏： CCF认证文章标签：算法

于 2022-02-26 21:05:57 首次发布

本文链接：https://blog.youkuaiyun.com/qq_39304630/article/details/123155690

版权

CCF认证专栏收录该内容

3 篇文章

订阅专栏

T1 问题描述

试题编号：	201312-1
试题名称：	出现次数最多的数
时间限制：	1.0s
内存限制：	256.0MB
问题描述：	问题描述　　给定n个正整数，找出它们中出现次数最多的数。如果这样的数有多个，请输出其中最小的一个。输入格式　　输入的第一行只有一个正整数n(1 ≤ n ≤ 1000)，表示数字的个数。　　输入的第二行有n个整数s1, s2, …, sn (1 ≤ si ≤ 10000, 1 ≤ i ≤ n)。相邻的数用空格分隔。输出格式　　输出这n个次数中出现次数最多的数。如果这样的数有多个，输出其中最小的一个。样例输入 6 10 1 10 20 30 20 样例输出 10

思路1：先排序，排序后相等的数一定会相邻排在一起，此时再统计更新答案，复杂度O(nlgn)

思路2：在遍历过程中直接统计，用Count[i]表示当前已有的i的数量，每次Count数组更新时更新一下出现最多的数的值以及其出现的次数，当数组遍历结束时就可以得到答案，复杂度O(n)

#include<iostream>
using namespace std;

int Count[10010];

int main(){
	int count=0,ans=20000,n,i,r;
	cin>>n;
	for(i=1;i<=n;++i){
		cin>>r; 
		++Count[r];
		if(Count[r]>count||(Count[r]==count&&r<ans)){
			count=Count[r];ans=r;
		}
	}
	cout<<ans;
	return 0;
}

T2 问题描述

试题编号：	201312-2
试题名称：	ISBN号码
时间限制：	1.0s
内存限制：	256.0MB
问题描述：	问题描述　　每一本正式出版的图书都有一个ISBN号码与之对应，ISBN码包括9位数字、1位识别码和3位分隔符，其规定格式如“x-xxx-xxxxx-x”，其中符号“-”是分隔符（键盘上的减号），最后一位是识别码，例如0-670-82162-4就是一个标准的ISBN码。ISBN码的首位数字表示书籍的出版语言，例如0代表英语；第一个分隔符“-”之后的三位数字代表出版社，例如670代表维京出版社；第二个分隔之后的五位数字代表该书在出版社的编号；最后一位为识别码。　　识别码的计算方法如下：　　首位数字乘以1加上次位数字乘以2……以此类推，用所得的结果mod 11，所得的余数即为识别码，如果余数为10，则识别码为大写字母X。例如ISBN号码0-670-82162-4中的识别码4是这样得到的：对067082162这9个数字，从左至右，分别乘以1，2，…，9，再求和，即0×1+6×2+……+2×9=158，然后取158 mod 11的结果4作为识别码。　　编写程序判断输入的ISBN号码中识别码是否正确，如果正确，则仅输出“Right”；如果错误，则输出是正确的ISBN号码。输入格式　　输入只有一行，是一个字符序列，表示一本书的ISBN号码（保证输入符合ISBN号码的格式要求）。输出格式　　输出一行，假如输入的ISBN号码的识别码正确，那么输出“Right”，否则，按照规定的格式，输出正确的ISBN号码（包括分隔符“-”）。样例输入 0-670-82162-4 样例输出 Right 样例输入 0-670-82162-0 样例输出 0-670-82162-4

思路：直接模拟就好。

#include<iostream>
using namespace std;
char str[20];

int main(){
	cin>>str+1;
	int code=0,i,k=1;
	for(i=1;i<=11;++i){
		if(str[i]!='-'){
			code+=k*(str[i]-'0');
			++k;
		}
	}
	code%=11;
	if(code==10){
		if(str[13]=='X')cout<<"Right";
		else {
			str[13]='X';
			cout<<str+1; 
		}
	}
	else{
		if(str[13]=='0'+code)cout<<"Right";
		else {
			str[13]='0'+code;
			cout<<str+1; 
		}
	}
}

T3 问题描述

试题编号：	201312-3
试题名称：	最大的矩形
时间限制：	1.0s
内存限制：	256.0MB
问题描述：	问题描述　　在横轴上放了n个相邻的矩形，每个矩形的宽度是1，而第i（1 ≤ i ≤ n）个矩形的高度是hi。这n个矩形构成了一个直方图。例如，下图中六个矩形的高度就分别是3, 1, 6, 5, 2, 3。　　请找出能放在给定直方图里面积最大的矩形，它的边要与坐标轴平行。对于上面给出的例子，最大矩形如下图所示的阴影部分，面积是10。输入格式　　第一行包含一个整数n，即矩形的数量(1 ≤ n ≤ 1000)。　　第二行包含n 个整数h1, h2, … , hn，相邻的数之间由空格分隔。(1 ≤ hi ≤ 10000)。hi是第i个矩形的高度。输出格式　　输出一行，包含一个整数，即给定直方图内的最大矩形的面积。样例输入 6 3 1 6 5 2 3 样例输出 10

思路：这是一道单调栈的经典应用，单调栈可以应用于快速找到某个数nums[i]左边和右边第一个比它大(小)的数。这题需要排除一些不可能的情况，即最终最大的矩形的面积一定是由每一个竖矩形确定高时得到的最大矩形的集合决定。画图解释一下

以中间的矩形为例，表面上看我们可以尝试枚举一下中间矩形取高度1，然后发现左右矩形都可以取1，此时得到一种可能答案3，但是细想就会发现，这种情况得到的矩形，与左边矩形取其最大值1时得到的是同一个矩形，属于重复考虑，因此我们直接考虑中间矩形取最大值2，右边矩形由于是3，再右边没有了(边界条件处理)，因此中间矩形可以得到的答案是4。

#include<iostream>
#include<stack>
using namespace std;
struct Node{
	int index,height;
};
stack<Node> Stack;

int main(){
	Node temp; 
	int n,i,ans=0,h,L;
	cin>>n;
	for(i=1;i<=n;++i){
		cin>>h;
		while(!Stack.empty()&&Stack.top().height>=h){
			temp=Stack.top();
			Stack.pop();
			L=(Stack.empty()?0:Stack.top().index);
			ans=max(ans,(i-L-1)*temp.height);
		}
		Stack.push(Node{i,h});
	}
	while(!Stack.empty()){
		temp=Stack.top();
		Stack.pop();
		L=(Stack.empty()?0:Stack.top().index);
		ans=max(ans,(n-L)*temp.height);
	}
	cout<<ans;
	return 0;
}

T4 问题描述

试题编号：	201312-4
试题名称：	有趣的数
时间限制：	1.0s
内存限制：	256.0MB
问题描述：	问题描述　　我们把一个数称为有趣的，当且仅当：　　1. 它的数字只包含0, 1, 2, 3，且这四个数字都出现过至少一次。　　2. 所有的0都出现在所有的1之前，而所有的2都出现在所有的3之前。　　3. 最高位数字不为0。　　因此，符合我们定义的最小的有趣的数是2013。除此以外，4位的有趣的数还有两个：2031和2301。　　请计算恰好有n位的有趣的数的个数。由于答案可能非常大，只需要输出答案除以1000000007的余数。输入格式　　输入只有一行，包括恰好一个正整数n (4 ≤ n ≤ 1000)。输出格式　　输出只有一行，包括恰好n 位的整数中有趣的数的个数除以1000000007的余数。样例输入 4 样例输出 3

思路：首先由题目条件我们可以知道

A.所有数的第一位只能是2

B.结尾的数字只能是1或3

题目要求我们对每一个串都要知道前面出现了哪些数，如果出现了1，则后面不再有0，如果出现了3，则后面不再有2，因此我们势必要记录前面有的数的状态。

那么到底应该记录什么状态呢？状态的迁移又该是什么样的呢?

首先如果我们需要知道4个数字的存在状态，易知其中有2^4=16个（二进制0和1表示是否存在），但是其中很多状态是不合法的，对此我们重新梳理一下状态，从题意出发思考状态（一开始的分析已知，第一位一定是2，所以所有状态内必须包含2）：

状态0：只有2的状态

状态1：只有0和2的状态

状态2：只有2和3的状态

状态3：只有0 1 2的状态

状态4：只有0 2 3的状态

状态5：有0 1 2 3的状态

于是我们设置状态dp[i][j][k]，表示了第i位上为j，从第一位到第i位的状态为k时的方案数，转移中没有必要对不合法的状态进行转移（例如j=0,k=0,即当前位为0，状态上却说当前只有2）。

上述分析B告诉我们最终答案就是dp[n][1][5]+dp[n][3][5]（当然不要忘了过程和答案取模）

剩下的工作就是对第i位为j时，讨论从第一位到第i-1位的串的状态以及第i-1位的取值了，依旧要注意不合法的情况。

易错点类似于：若前面i-1位的状态为有0 2 3，那么第i-1位只能取0和3，若取2，为了满足有状态中有3的要求，2的前面会有3，直接与题意不符，属于不合法的状态，细心即可。。。

#include<iostream>
using namespace std;
typedef long long ll;
const ll Mod=1000000007;
ll dp[1010][8];

int main(){
	int n,i;
	cin>>n;
	dp[1][0]=1;
	for(i=2;i<=n;++i){
		dp[i][0]=dp[i-1][0];     
		dp[i][1]=(dp[i-1][1]*2+dp[i-1][0])%Mod;
		dp[i][2]=(dp[i-1][2]+dp[i-1][0])%Mod;
		dp[i][3]=(dp[i-1][3]*2+dp[i-1][1])%Mod;
		dp[i][4]=(dp[i-1][4]*2+dp[i-1][1]+dp[i-1][2])%Mod;
		dp[i][5]=(dp[i-1][5]*2+dp[i-1][3]+dp[i-1][4])%Mod;
	}
	cout<<dp[n][5];
	return 0;
}

T5 问题描述

试题编号：	201312-5
试题名称：	I’m stuck!
时间限制：	1.0s
内存限制：	256.0MB
问题描述：	问题描述　　给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '\|', '.', 'S', 'T'七个字符中的一个，分别表示如下意思：　　'#': 任何时候玩家都不能移动到此方格；　　'+': 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；　　'-': 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非'#'方格移动一格；　　'\|': 当玩家到达这一方格后，下一步可以向上下两个方向相邻的一个非'#'方格移动一格；　　'.': 当玩家到达这一方格后，下一步只能向下移动一格。如果下面相邻的方格为'#'，则玩家不能再移动；　　'S': 玩家的初始位置，地图中只会有一个初始位置。玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；　　'T': 玩家的目标位置，地图中只会有一个目标位置。玩家到达这一方格后，可以选择完成任务，也可以选择不完成任务继续移动。如果继续移动下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格。　　此外，玩家不能移动出地图。　　请找出满足下面两个性质的方格个数：　　1. 玩家可以从初始位置移动到此方格；　　2. 玩家不可以从此方格移动到目标位置。输入格式　　输入的第一行包括两个整数R 和C，分别表示地图的行和列数。(1 ≤ R, C ≤ 50)。　　接下来的R行每行都包含C个字符。它们表示地图的格子。地图上恰好有一个'S'和一个'T'。输出格式　　如果玩家在初始位置就已经不能到达终点了，就输出“I'm stuck!”（不含双引号）。否则的话，输出满足性质的方格的个数。样例输入 5 5 --+-+ ..\|#. ..\|## S-+-T ####. 样例输出 2 样例说明　　如果把满足性质的方格在地图上用'X'标记出来的话，地图如下所示：　　--+-+ 　　..\|#X 　　..\|## 　　S-+-T 　　####X

思路：这题其实是一道比较简单的搜索题，只是需要优化思路。

朴素做法：直接从起点搜索一遍得到起点能到达的点，然后再对这每一个点进行一遍搜索看是否能到终点，直接统计即可。

优化方法：可以从某点到终点，说明在一定规则下也可以从终点到这个点，因此为了避免题中所给出的单向关系，我们直接规定，如果当前点的上邻接点是'.'、'+'、'|','S','T'，就可以从上邻接点到该点，同理规定其余三个方向，将能够到达终点的点标记，最终只要对从起点能到并且不能到终点的点统计即可。若从起点遍历不到终点，直接输出"I'm stuck!"。

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
 
typedef pair<int,int> point;
 
char Map[55][55];
int n,m,sx,sy,tx,ty;
bool Use[55][55],isOK; 
bool StoT[55][55],TtoS[55][55];
queue<point>que;
 
void BFS(int x,int y){
	point p=make_pair(x,y);
	Use[x][y]=true;
	int nx,ny;
	que.push(p);
	while(que.size()){
		p=que.front(),que.pop();
		x=p.first,y=p.second;
		if(x==tx&&y==ty){//可以到达终点
			 isOK=true;
		}
		switch(Map[x][y]){
		case 'S':
		case 'T':
		case '+':nx=x-1,ny=y;
				if(nx>=1&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				nx=x+1,ny=y;
				if(nx<=n&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				nx=x,ny=y-1;
				if(ny>=1&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				nx=x,ny=y+1;
				if(ny<=m&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				break;
		case '-':nx=x,ny=y-1;
				if(ny>=1&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				nx=x,ny=y+1;
				if(ny<=m&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				break;
		case '|':nx=x-1,ny=y;
				if(nx>=1&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				nx=x+1,ny=y;
				if(nx<=n&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				break;
		case '.':nx=x+1,ny=y;
				if(nx<=n&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				break;
		}
	}
}
 
void ReverseBFS(int x,int y){
	point p=make_pair(x,y);
	que.push(p);
	int nx,ny;
	Use[x][y]=true;
	while(que.size()){
		p=que.front(),que.pop();
		x=p.first,y=p.second;
		nx=x-1,ny=y;
		if(nx>=1&&(Map[nx][ny]=='.'||Map[nx][ny]=='|'||Map[nx][ny]=='+'||Map[nx][ny]=='S'||Map[nx][ny]=='T')){//从上面到这个点 
			TtoS[nx][ny]=true;
			if(!Use[nx][ny]){
				que.push(make_pair(nx,ny));
				Use[nx][ny]=true;
			}
		}
		nx=x+1,ny=y;
		if(nx<=n&&(Map[nx][ny]=='|'||Map[nx][ny]=='+'||Map[nx][ny]=='S'||Map[nx][ny]=='T')){//从下面到这个点 
			TtoS[nx][ny]=true;
			if(!Use[nx][ny]){
				que.push(make_pair(nx,ny));
				Use[nx][ny]=true;
			}
		}
		nx=x,ny=y-1;
		if(ny>=1&&(Map[nx][ny]=='-'||Map[nx][ny]=='+'||Map[nx][ny]=='S'||Map[nx][ny]=='T')){//从左边到这个点 
			TtoS[nx][ny]=true;
			if(!Use[nx][ny]){
				que.push(make_pair(nx,ny));
				Use[nx][ny]=true;
			}
		}
		nx=x,ny=y+1;
		if(ny<=m&&(Map[nx][ny]=='-'||Map[nx][ny]=='+'||Map[nx][ny]=='S'||Map[nx][ny]=='T')){//从右边到这个点 
			TtoS[nx][ny]=true;
			if(!Use[nx][ny]){
				que.push(make_pair(nx,ny));
				Use[nx][ny]=true;
			}
		}
	}
}
 
 
 
int main(){
	int i,j,ans=0;
	cin>>n>>m;
	for(i=1;i<=n;++i){
		cin>>Map[i]+1;
		for(j=1;j<=m;++j){
			if(Map[i][j]=='S'){
				sx=i,sy=j;
			}
			if(Map[i][j]=='T'){
				tx=i,ty=j;
			}
		}
	}
	BFS(sx,sy);
	if(!isOK){//到不了终点 
		cout<<"I'm stuck!";
		return 0;
	}
	memset(Use,0,sizeof(Use));
	ReverseBFS(tx,ty);
	for(i=1;i<=n;++i){
		for(j=1;j<=m;++j){
			if(StoT[i][j]&&!TtoS[i][j]){
				++ans;
			}
		}
	}
	cout<<ans;
	return 0;
}