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。
输入样例:
3
输出样例:
123
132
213
231
312
321
比较基础的一个深搜,就是一个个的向数组中填入数字,填满之后输出数组再去填下一个数字,用另一个数组来表示下标元素是否被使用即可,代码附上
#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个数字表示地图
输出:输出一个整数表示大山的数目
示例:
输入:
4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1
输出:
3
范围:
对于 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
输出样例:
在这里给出相应的输出。例如:
1
虽然上面的都是搜索但是这道题是个实实在在的数学问题,就这数据范围要是直接暴力的话肯定会超时,观察到数据范围中的数字都是九位数,而且既然要形成回文数,那么根据前五个数字就可以得出后五个数字,我们实际上就是在算前五个数字有多少种情况,那么我们直接数据范围取前五个数字减去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;
}