CCF-CSP 2014年3月 题解

201403-1 相反数

问题描述

试题名称： 相反数
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　有 N 个非零且各不相同的整数。请你编一个程序求出它们中有多少对相反数(a 和 -a 为一对相反数)。
输入格式
　　第一行包含一个正整数 N。(1 ≤ N ≤ 500)。
　　第二行为 N 个用单个空格隔开的非零整数,每个数的绝对值不超过1000,保证这些整数各不相同。
输出格式
　　只输出一个整数,即这 N 个数中包含多少对相反数。
样例输入
5
1 2 3 -1 -2
样例输出
2

解题思路

题目给出数据范围，数字的大小不超过1000，可以设置一个大小为1001的数组A，当输入数值 m 的时候，将A[m的绝对值]的值加上 m ，每次进行该操作时检查A[m的绝对值]是否为0，为0则添加一对相反数。

代码

#include

using namespace std;
int A[1001];
int N;
int cnt; //相反数对数

int main() {
	cin >> N;
	for (int i = 0; i < N; i++) {
		int tmp, Tmp;
		cin >> tmp;
		Tmp = abs(tmp);
		A[Tmp] += tmp;
		if (A[Tmp] == 0) cnt++;
	}
	cout << cnt << endl;

	return 0;
}

201403-2 窗口

问题描述

试题编号： 201403-2
试题名称： 窗口
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　在某图形操作系统中,有 N 个窗口,每个窗口都是一个两边与坐标轴分别平行的矩形区域。窗口的边界上的点也属于该窗口。窗口之间有层次的区别,在多于一个窗口重叠的区域里,只会显示位于顶层的窗口里的内容。
　　当你点击屏幕上一个点的时候,你就选择了处于被点击位置的最顶层窗口,并且这个窗口就会被移到所有窗口的最顶层,而剩余的窗口的层次顺序不变。如果你点击的位置不属于任何窗口,则系统会忽略你这次点击。
　　现在我们希望你写一个程序模拟点击窗口的过程。
输入格式
　　输入的第一行有两个正整数,即 N 和 M。(1 ≤ N ≤ 10,1 ≤ M ≤ 10)
　　接下来 N 行按照从最下层到最顶层的顺序给出 N 个窗口的位置。 每行包含四个非负整数 x1, y1, x2, y2,表示该窗口的一对顶点坐标分别为 (x1, y1) 和 (x2, y2)。保证 x1 < x2,y1 2。
　　接下来 M 行每行包含两个非负整数 x, y,表示一次鼠标点击的坐标。
　　题目中涉及到的所有点和矩形的顶点的 x, y 坐标分别不超过 2559 和　　1439。
输出格式
　　输出包括 M 行,每一行表示一次鼠标点击的结果。如果该次鼠标点击选择了一个窗口,则输出这个窗口的编号(窗口按照输入中的顺序从 1 编号到 N);如果没有,则输出"IGNORED"(不含双引号)。
样例输入
3 4
0 0 4 4
1 1 5 5
2 2 6 6
1 1
0 0
4 4
0 5
样例输出
2
1
1
IGNORED
样例说明
　　第一次点击的位置同时属于第 1 和第 2 个窗口,但是由于第 2 个窗口在上面,它被选择并且被置于顶层。
　　第二次点击的位置只属于第 1 个窗口,因此该次点击选择了此窗口并将其置于顶层。现在的三个窗口的层次关系与初始状态恰好相反了。
　　第三次点击的位置同时属于三个窗口的范围,但是由于现在第 1 个窗口处于顶层,它被选择。
　　最后点击的 (0, 5) 不属于任何窗口。

解题思路

用一个数组从顶层到底层存储各个窗口的编号
用另一个结构体数组存储各个编号窗口的范围
每次对排序数组顺序扫描 扫描得到的第一个满足条件的窗口编号即输出 且在数组首部添加该编号 并将该处删除 使用vector容器实现简单 使用insert 和 erase

代码

#include
using namespace std;

struct Area {
	int x1, y1;    //窗口顶点
	int x2, y2;		//窗口顶点
}Win_Area[15];

vector<int> V;

/*判断(x,y)是否在窗口 no 内*/
bool Judge_In(int x, int y, int no) {   //输入点击坐标 以及窗口编号
	if (x <= Win_Area[no].x2 && x >= Win_Area[no].x1 && y <= Win_Area[no].y2 && y >= Win_Area[no].y1) {  //在该窗口范围内
		return true;
	}
	else return false;
}

int main() {
	int N, M;
	cin >> N >> M;
	for (int i = 1; i <= N; i++) {
		cin >> Win_Area[i].x1 >> Win_Area[i].y1 >> Win_Area[i].x2 >> Win_Area[i].y2;
		V.push_back(N - i + 1);   //按从顶层到底层存储
	}
	for (int i = 0; i < M; i++) {
		int x, y;
		cin >> x >> y;
		for (auto it = V.begin(); it != V.end(); it++) {
			if (Judge_In(x, y, *it)==true) {  //本次鼠标点击的窗口就是 *it 号窗口
				cout << *it << endl;
				int store = *it;
				V.erase(it);
				V.insert(V.begin(), store);
				x = -1;  //作为flag
				break;  //找到最顶层的即可退出
			}
		}
		if (x != -1) cout << "IGNORED" << endl;
	}

	return 0;
}

201403-3 命令行选项

题目描述

试题编号： 201403-3
试题名称： 命令行选项
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　请你写一个命令行分析程序,用以分析给定的命令行里包含哪些选项。每个命令行由若干个字符串组成,它们之间恰好由一个空格分隔。这些字符串中的第一个为该命令行工具的名字,由小写字母组成,你的程序不用对它进行处理。在工具名字之后可能会包含若干选项,然后可能会包含一 些不是选项的参数。
　　选项有两类:带参数的选项和不带参数的选项。一个合法的无参数选项的形式是一个减号后面跟单个小写字母,如"-a" 或"-b"。而带参数选项则由两个由空格分隔的字符串构成,前者的格式要求与无参数选项相同,后者则是该选项的参数,是由小写字母,数字和减号组成的非空字符串。
　　该命令行工具的作者提供给你一个格式字符串以指定他的命令行工具需要接受哪些选项。这个字符串由若干小写字母和冒号组成,其中的每个小写字母表示一个该程序接受的选项。如果该小写字母后面紧跟了一个冒号,它就表示一个带参数的选项,否则则为不带参数的选项。例如, “abⓂ️” 表示该程序接受三种选项,即"-a"(不带参数),"-b"(带参数), 以及"-m"(带参数)。
　　命令行工具的作者准备了若干条命令行用以测试你的程序。对于每个命令行,你的工具应当一直向后分析。当你的工具遇到某个字符串既不是合法的选项,又不是某个合法选项的参数时,分析就停止。命令行剩余的未分析部分不构成该命令的选项,因此你的程序应当忽略它们。
输入格式
　　输入的第一行是一个格式字符串,它至少包含一个字符,且长度不超过 52。格式字符串只包含小写字母和冒号,保证每个小写字母至多出现一次,不会有两个相邻的冒号,也不会以冒号开头。
　　输入的第二行是一个正整数 N(1 ≤ N ≤ 20),表示你需要处理的命令行的个数。
　　接下来有 N 行,每行是一个待处理的命令行,它包括不超过 256 个字符。该命令行一定是若干个由单个空格分隔的字符串构成,每个字符串里只包含小写字母,数字和减号。
输出格式
　　输出有 N 行。其中第 i 行以"Case i:" 开始,然后应当有恰好一个空格,然后应当按照字母升序输出该命令行中用到的所有选项的名称,对于带参数的选项,在输出它的名称之后还要输出它的参数。如果一个选项在命令行中出现了多次,只输出一次。如果一个带参数的选项在命令行中出 现了多次,只输出最后一次出现时所带的参数。
样例输入
albw:x
4
ls -a -l -a documents -b
ls
ls -w 10 -x -w 15
ls -a -b -c -d -e -l
样例输出
Case 1: -a -l
Case 2:
Case 3: -w 15 -x
Case 4: -a -b

解题思路

根据题意顺序扫描做判断即可

代码

#include
using namespace std;
int options[150];  // options[i]=1 表示不带参选项   2表示带参选项
int used[150];  //标记哪些选项被使用了
string output[150];  //表示选项的参数

string tmp;

int main() {
	cin >> tmp;
	for (int i = 0; i < tmp.size(); i++) {
		if (tmp[i] == ':') options[tmp[i - 1]] = 2;
		else {
			options[tmp[i]] = 1;
		}
	}
	int N;
	cin >> N;
	getchar();
	for (int i = 1; i <= N; i++) {
		memset(used, 0, sizeof(used));
		tmp.clear();
		getline(cin, tmp);
		stringstream stream(tmp);
		string command;  //指令
		string parameter;  //指令参数
		stream >> command;
		while(stream>>parameter){
			if (parameter[0] == '-') {  //表示是选项
				char Option = parameter[1];
				if (options[Option] == 0) {  //不是该指令的选项
					break;  //直接结束改行指令
				}
				else if (options[Option] == 1) {  //表示不带参选项
					output[Option] = '\b';
					used[Option] = 1;
				}
				else if (options[Option] == 2) {  //等于2  表示带参
					if (stream >> parameter) {   //应该带参数
						output[Option] = parameter;
						used[Option] = 1;
					}
					else break;  //没有参数也错
				}
			}
			else {
				break;
			}
		}
		cout << "Case " << i << ":";
		for (char j = 'a'; j <= 'z'; j++) {
			if (used[j]) {
				cout << " -" << j << ' ' << output[j];
			}
		}
		cout << endl;
	}

	return 0;
}

201403-4 无线网络

试题编号： 201403-4

试题名称： 无线网络
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　目前在一个很大的平面房间里有 n 个无线路由器,每个无线路由器都固定在某个点上。任何两个无线路由器只要距离不超过 r 就能互相建立网络连接。
　　除此以外,另有 m 个可以摆放无线路由器的位置。你可以在这些位置中选择至多 k 个增设新的路由器。
　　你的目标是使得第 1 个路由器和第 2 个路由器之间的网络连接经过尽量少的中转路由器。请问在最优方案下中转路由器的最少个数是多少?
输入格式
　　第一行包含四个正整数 n,m,k,r。(2 ≤ n ≤ 100,1 ≤ k ≤ m ≤ 100, 1 ≤ r ≤ 108)。
　　接下来 n 行,每行包含两个整数 xi 和 yi,表示一个已经放置好的无线 路由器在 (xi, yi) 点处。输入数据保证第 1 和第 2 个路由器在仅有这 n 个路由器的情况下已经可以互相连接(经过一系列的中转路由器)。
　　接下来 m 行,每行包含两个整数 xi 和 yi,表示 (xi, yi) 点处可以增设 一个路由器。
　　输入中所有的坐标的绝对值不超过 108,保证输入中的坐标各不相同。
输出格式
　　输出只有一个数,即在指定的位置中增设 k 个路由器后,从第 1 个路 由器到第 2 个路由器最少经过的中转路由器的个数。
样例输入
5 3 1 3
0 0
5 5
0 3
0 5
3 5
3 3
4 4
3 0
样例输出
2

解题思路

使用最短路径的相关算法即可
使用bfs算法，设计过程的要点：

• 对各个路由器设置编号 1-n是给定的路由器 n+1 - n+m是选择的m个路由器
• 使用bfs算法未到达2号路由器之前：
• 如果使用的可选路由器数小于 k ，那么可以从 1 - n+m 中选取路由器继续bfs算法
• 如果使用的可选路由器数大于 k ，那么只能从 1 - n 中选取

代码

#include
using namespace std;
#define ll long long
ll n, m, k, r;

//让满足在r范围内的边长都是1 最后的路径长即使经过的路由器数-1
vector<int> Grap[205];  //无向边 每个边添加两次
int vis[205], dis[205];
int K[205];  //K[i]表示从1号路由器到达i号路由器所使用的添加路由器数目
struct Node {
	ll x, y;
}V[205];

/*使用广度优先算法来求最短路径*/
void bfs(int source) {
	queue<int> q;
	vis[source] = 1;
	dis[source] = 0;
	q.push(source);
	while (!q.empty()) {
		int u = q.front();
		q.pop();
		if (u == 2) { //表示第一次达到2号路由器 说明已经找到最短路径
			cout << dis[2] - 1 << endl;
			return;
		}
		int Limit = n + m;
		if (K[u] == k) Limit = n;
		for (int i = 0; i < Grap[u].size(); i++) {
			int v = Grap[u][i];
			if (v <= Limit && !vis[v]) {
				K[v] = K[u] + (v > n);
				dis[v] = dis[u] + 1;
				vis[v] = 1;
				q.push(v);
			}
		}
	}

}

/*使用深度优先进行搜素 时间复杂度太高  30分*/
int Min = 0x3fffffff;
int cnt;  //记录使用了多少个添加的路由器
void dfs(int cur, int dis) {  //当前节点和目标节点
	if (dis > Min) return;
	if (cur == 2) {
		if (Min > dis && cnt <= k) Min = dis;
		return;
	}
	else{
		for (int i = 0; i < Grap[cur].size(); i++) {
			int v = Grap[cur][i];
			if (!vis[v]) {
				vis[v] = 1;
				if (v > n) cnt++;
				dfs(v, dis + 1);  //路径加一
				vis[v] = 0;  //回溯
				cnt--;
			}
		}

	}

}

/*使用Djk不考虑k  可以70分*/
void Djk(int source) {
	priority_queue<int> q;
	memset(dis, 0x3f, sizeof(dis));
	dis[source] = 0;
	memset(vis, 0, sizeof(vis));
	q.push(source);
	while (!q.empty()) {
		int temp = q.top(); q.pop();  //选取
		if (vis[temp]) continue;  //如果这个点被当过中转 那么跳过这个点
		vis[temp] = 1;
		for (int i = 0; i < Grap[temp].size(); i++) {
			int v = Grap[temp][i];
			if (!vis[v] && dis[v] > dis[temp] + 1) {
				dis[v] = dis[temp] + 1;
				q.push(v);
			}
		}

	}
}

int main() {
	cin >> n >> m >> k >> r;
	ll R = (ll)(r * r);
	for (int i = 1; i <= n + m; i++) {
		cin >> V[i].x >> V[i].y;
	}
	
	//把可以连通的每个边添加到Grap中 可以优化
	for (int i = 1; i <= n + m; i++) {
		for (int j = 1;  j<= n + m; j++) {
			if (i != j) {
				ll square_dis = (ll)((V[i].x - V[j].x) * (V[i].x - V[j].x) + (V[i].y - V[j].y) * (V[i].y - V[j].y));
				if (square_dis <= R) Grap[i].push_back(j);
			}
		}
	}
	//dfs(1, 0);
	//Djk(1);
	//cout << dis[2]-1 << endl;
	bfs(1);

	return 0;
}