NEUQ-ACM预备队第二次双周赛题解

最新推荐文章于 2024-06-05 15:16:22 发布

little_letter635

最新推荐文章于 2024-06-05 15:16:22 发布

阅读量121

点赞数

文章标签：算法数据结构

本文链接：https://blog.csdn.net/little_letter/article/details/128351981

版权

T1.输出全排列

请编写程序输出前n个正整数的全排列（n<10），并通过9个测试用例（即n从1到9）观察n逐步增大时程序的运行时间。

输入格式:

输入给出正整数n（<10）。

输出格式:

输出1到n的全排列。每种排列占一行，数字间无空格。排列的输出顺序为字典序，即序列a1,a2,⋯,an排在序列b1,b2,⋯,bn之前，如果存在k使得a1=b1,⋯,ak=bk 并且 ak+1<bk+1。

输入样例：

输出样例：

比较基础的一个深搜，就是一个个的向数组中填入数字，填满之后输出数组再去填下一个数字，用另一个数组来表示下标元素是否被使用即可，代码附上

#include<iostream>
using namespace std;
int used[15]={0};
int arr[15]={0};
void DFS(int n,int t){
    if(t == n){
        for(int i = 0;i < n;i++){
            cout << arr[i];
        }
        cout << endl;
        return ;
    }
    
    for(int j = 1;j <= n;j++){
        if(!used[j]){
            arr[t] = j;
            used[j] = 1;
            DFS(n,t+1);
            used[j] = 0;
        }
    }
}


int main(){
    int n;
    cin >> n;
    DFS(n,0);
    return 0;
}

T2.山

Drizzle 前往山地统计大山的数目，现在收到这片区域的地图，地图中用0（平地）和1（山峰）绘制而成，请你帮忙计算其中的大山数目
山总是被平地四面包围着，每一座山只能在水平或垂直方向上连接相邻的山峰而形成。一座山峰四面被平地包围，这个山峰也算一个大山
另外，你可以假设地图的四面都被平地包围着。

要求:

输入：第一行输入M,N分别表示地图的行列，接下来M行每行输入N个数字表示地图
输出：输出一个整数表示大山的数目

示例:

输入：

输出：

范围:

对于 5% 的数据：M，N ≤ 10
对于 100% 的数据：M，N ≤ 2000

询问大山的数目，我们可以直接遍历这个地图，碰到山（即1）就对这个点进行搜索，然后把符合条件的山都置为0，即把这个大山从地图上标示成0，进行几次搜索就是有几座大山，例如样例地图

1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1

第一次搜索后变为

0 0 0 0 0
0 0 0 0 0
0 0 1 0 0
0 0 0 1 1

第二次搜索后变为

0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 1 1

第三次搜索后变为

0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

遍历结束，三次遍历，三座大山，代码附上

#include<iostream>
using namespace std;
int ans = 0,n,m;
int map[2005][2005] = {0};
void DFS(int i,int j){
    map[i][j] = -1;
    if(map[i-1][j]==1){DFS(i-1,j);}
    if(map[i+1][j]==1){DFS(i+1,j);}
    if(map[i][j-1]==1){DFS(i,j-1);}
    if(map[i][j+1]==1){DFS(i,j+1);}
}

int main(){
    cin >> n >> m;
    for(int i = 1;i <= n;i++){
        for(int j = 1;j <= m;j++){
            cin >> map[i][j];
        }
    }
    for(int i = 1;i <= n;i++){
        for(int j = 1;j <= m;j++){
            if(map[i][j]==1){
                ans++;
                DFS(i,j);
            }
        }
    }
    
    cout << ans;
}

T3.跳跃

Drizzle 被困到一条充满数字的方块路中，假设这条路由一个非负的整数数组m组成，Drizzle 最开始的位置在下标 start 处，当他位于下标i位置时可以向前或者向后跳跃m[i]步数，已知元素值为0处的位置是出口，且只能通过出口出去，不可能数组越界，请你通过编程计算出Drizzle能否逃出这里。

要求:

输入：第一行输入数组m的长度n 第二行输入数组元素，空格分割开第三行输入起始下标start

示例:

输入：

7
4 2 3 0 3 1 2
5

输出：

True

范围:

1 <= m.length <= 5 * 10^4
0 <= m[i] < m.length
0 <= start < m.length

也是一道深搜题目，我们站好后只需要向前跳和向后跳就OK，如果能碰到出口就输出True，碰不到就输出False，注意start是从零开始，不要擅自认为是从一开始了（悲），就当是注意审题了，代码附上

#include<iostream>
using namespace std;
int n,start;
int m[50005] = {0};
int used[50005] = {0};

bool DFS(int s){
    if(m[s]==0){
        return 1;
    }
    if(used[s+m[s]] == 0&&s+m[s]<n){
        used[s+m[s]] = 1;
        if(DFS(s+m[s]))return 1;
        used[s+m[s]] = 0;
    }
    if(used[s-m[s]] == 0&&s-m[s]>=0){
        used[s-m[s]] = 1;
        if(DFS(s-m[s]))return 1;
        used[s-m[s]] = 0;
    }
    return 0;
}

int main(){
    cin >> n;
    for(int i = 0;i < n;i++){
        cin >> m[i];
    }
    cin >> start;
    used[start] = 1;
    if(DFS(start))cout << "True";
    else cout << "False";
    return 0;
}

T4.最长光路

小明在做丁达尔效应的实验。
他用胶体填满了一个有 N 行, M 列个格子的透明盒子。同时，为了使实验效果更好，他在盒子的某些格子中装入一些双面镜(用“/”和“\”表示)。
当光线找到双面镜的时候，光路会反射，方向会有90度的转换（如下图所示）。

小明在填充胶体的时候产生了失误，使得有些格子光线无法穿过（我们可以认为这些格子把光线都吸收了），这些格子用大写字母“C”来表示。

现在，小明已经制作好了实验装置，他将激光光源放在第sx行的第sy个格子上。激光光源可以朝向上下左右四个方向，分别用URDL四个字母表示(“U”-上, “R”-右, “D”-下, “L”-左)。

为了让实验效果更好，小明希望光的光路越酷越好。
对小明来说，最酷的光路就是包含环的光路，这种情况下，光不会射向盒子外面，而是一直在盒子内循环（数据保证光源处的点是光线可以通过，即起点一点是"."）。
如果光源朝各个方向摆设，最终光线都会射向盒子外部，那么小明认为经过格子最多的光路是最酷的。

现在小明想知道光源朝哪个方向放置光路最酷。
如果光路是不包含环的，那么他还想知道光路经过的格子数目是多少（如果光多次进入同一格子，独立计算，不认为只经过一个格子）。

注意

如果有多个方向是最优解，那么我们按照“U”-上, “R”-右, “D”-下, “L”-左的优先级来选择最终的答案，即如果向左和向右都是最优解，我们选择向右的方案。

同时，温馨提醒，c++中“\”符号可以用'\\'来表示

输入格式:

第一行两个数 N,M(1≤N,M≤500) 表示有N 行 M 列的格子。
接下来 N 行, 每行 M 个字符，表示盒子的具体情况。 “/”和“\”表示装有不同朝向的镜子的格子。“C”表示光线无法通过的格子。“.”表示正常且没有镜子的格子。
最后输入两个数字sx,sy表示光源所在的点。

输出格式:

第一行输出一个大写字母，表示最酷的光路应该超哪个方向摆放。
第二行输出光路经过的格子数。如果光路中包含环，则换成输出字符串“COOL”。

输入样例1:

5 5
../.\
.....
.C...
...C.
\.../
3 3

输出样例1:

U
17

输入样例2：

5 7
/.....\
../..\.
\...../
/.....\
\.\.../
3 3

输出样例2

R
COOL

样例解释

S为起点
../.\
.....
.CS..
...C.
\.../

'U' 方向
*.***
*.*.*
*C*.*
*..C*
*****
17个格子


'R'方向
../.\
.....
.C***
...C.
\.../
3个格子


'D'方向
../.\
.....
.C*..
..*C.
\.*./
3个格子


'L'方向
../.\
.....
.C*..
...C.
\.../
1个格子

一个非常硬核的模拟题呢，首先要读懂题意，' \ ' 和 ' / ' 是两个双面镜，C是个黑体，会吸收射进来的光线，然后就是模拟光线在盒子里的反射了，一步步按照光线的反射规律在盒子里模拟一下，注意光线两次通过同一个地方也是要算经过两个格子的，同时这不能作为光线形成回路的标志，光线形成回路应该让它不仅走过，而且方向还和当前方向相同才可以，所以还需要一个vis数组来存储光线是否走过当前格子和当时是以什么方向走过的，最后根据答案选出符合题意的方向即可，代码附上

#include <iostream>
#include <cstring>
using namespace std;

int n, m, sx, sy, dir = 0;

int d[2][4] = {{-1, 0, 1, 0}, {0, 1, 0, -1}};
char map[505][505];
char vis[505][505];
int ans[2][4];
int an;
bool s;

void dfs(int x, int y) {
	if (x > 0 && x <= n && y > 0 && y <= m) {
		an++;
		if (vis[x][y]) {
			if (vis[x][y] == dir + 1) {
				s = true;
				return;
			}
		} else
			vis[x][y] = dir + 1;
		if (map[x][y] == '\\') {
			switch (dir) {
				case 0:
					dir = 3;
					break;
				case 1:
					dir = 2;
					break;
				case 2:
					dir = 1;
					break;
				case 3:
					dir = 0;
					break;
			}
		} else if (map[x][y] == '/') {
			switch (dir) {
				case 0:
					dir = 1;
					break;
				case 1:
					dir = 0;
					break;
				case 2:
					dir = 3;
					break;
				case 3:
					dir = 2;
					break;
			}
		}
		int nx = x + d[0][dir];
		int ny = y + d[1][dir];
		if (map[nx][ny] == 'C') {
			return;
		}
//		cout << nx << ' ' << ny << endl;
		dfs(nx, ny);
	} else {
		return;
	}
}

int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		cin >> &map[i][1];
	}
	cin >> sx >> sy;
	for (int i = 0; i < 4; i++) {
		dir = i;
		an = 0;
		s = 0;
		dfs(sx, sy);
		ans[0][i] = an;
		ans[1][i] = s;
		memset(vis, 0, sizeof(vis));
	}
//	for (int i = 0; i < 4; i++) {
//		cout << ans[0][i] << ' ' << ans[1][i] << endl;
//	}
	int di = 0;
	for (int i = 0; i < 4; i++) {
		if (ans[1][i] > ans[1][di])
			di = i;
		else if (ans[1][i] < ans[1][di])
			continue;
		else if (ans[0][i] > ans[0][di])
			di = i;
	}
	switch (di) {
		case 0:
			cout << 'U' << endl;
			break;
		case 1:
			cout << 'R' << endl;
			break;
		case 2:
			cout << 'D' << endl;
			break;
		case 3:
			cout << 'L' << endl;
			break;
	}
	if (ans[1][di])
		cout << "COOL" << endl;
	else
		cout << ans[0][di] << endl;
	return 0;
}

T5.回文数文回

我们称一个数是回文的，当且仅当它正着读和倒着读是相同的。

例如11或11455411是回文的，而10或1919810不是回文的。

现在给定一个数n，你需要求出区间[108,n]中所有的回文数。

输入格式:

一行一个整数n(108≤n<109)

输出格式:

输出一行一个数，表示题目所求区间中回文数的数量。

输入样例:

在这里给出一组输入。例如：

100000001

输出样例:

在这里给出相应的输出。例如：

虽然上面的都是搜索但是这道题是个实实在在的数学问题，就这数据范围要是直接暴力的话肯定会超时，观察到数据范围中的数字都是九位数，而且既然要形成回文数，那么根据前五个数字就可以得出后五个数字，我们实际上就是在算前五个数字有多少种情况，那么我们直接数据范围取前五个数字减去10000，就得到了前五个数字比他小的所有回文数情况，最后还有自己这个特殊情况判断一下加上，输出答案即可，代码如下

#include<iostream>
using namespace std;

bool ishuiwen(int n){
    int m = n/10000*10000;
    m += n/100000000;
    m += n/10000000%10*10;
    m += n/1000000%10*100;
    m += n/100000%10*1000;

    return n>=m;
}

int main(){
    int n;
    cin >> n;
    int ans = n/10000-10000 + ishuiwen(n);
    cout << ans << endl;
    return 0;
}