7-1 输出全排列
分数 300
请编写程序输出前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
代码长度限制
16 KB
时间限制
3500 ms
内存限制
64 MB
题解：
第一题可以直接用next_permutation来求解，就算背不会单词也没有关系，vscode会给你答案，怕超时？哈哈当初我也是这么怀疑，但是，其实自己写的算法也不比人家的好到哪去，所以就用人家的吧，前人造轮子我们调库，完美！！
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
int n;
cin >> n;
vector<int> arr(n);
for(int i = 0; i < n; i++)
arr[i] = i+1;
do
{
for(int i = 0; i < n; i++)
{
// if(i)
// cout << ' ';
cout << arr[i];
}
cout << endl;
} while(next_permutation(arr.begin(), arr.end()));
return 0;
}7-2 山
分数 300
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
代码长度限制
16 KB
对于C++
时间限制
1000 ms
内存限制
256 MB
第二题题解：
这题没什么，中规中矩的dfs，因为矩阵是稀疏矩阵，所以用list来存储1的节点的坐标，这样访问起来会方便很多，但是为了调用vis方便和检查下一个节点是否有山峰，把vis数组和地图还是按照常规方法来存储吧。（稀疏矩阵存储和普通矩阵存储结合起来还是不错的）
#include <bits/stdc++.h>
using namespace std;
//大山的题
//存储节点的类
struct Point
{
int x, y;
Point(int a, int b):
x(a), y(b) {}
};
const int MAX = 2002;
int ans = 0; //山的数目的变量
int fx[4] = {-1, 1, 0, 0};
int fy[4] = {0, 0, -1, 1};
int point[MAX][MAX] = {0};
bool vis[MAX][MAX] = {0};
int m, n;
void dfs(int x, int y)
{
for(int i = 0; i < 4; i++)
{
int nextx = x+fx[i], nexty = y+fy[i];
if(nextx >= 0 && nextx < m &&
nexty >= 0 && nexty < n &&
!vis[nextx][nexty] && point[nextx][nexty])
{
vis[nextx][nexty] = true;
dfs(nextx, nexty);
}
}
}
int main()
{
int num;
list<Point> arr;
cin >> m >> n;
for(int i = 0; i < m; i++)
{
for(int j = 0; j < n; j++)
{
cin >> num;
point[i][j] = num;
if(num == 1)
{
arr.push_back(Point(i, j));
}
}
}
for(Point a:arr)
{
if(!vis[a.x][a.y])
{
vis[a.x][a.y] = true;
dfs(a.x, a.y);
ans ++;
}
}
cout << ans << endl;
return 0;
}7-3 跳跃
分数 300
全屏浏览题目
切换布局
作者 Drizzle
单位 山东科技大学
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
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
第三题题解：
还是中规中矩的dfs，但是要注意一点，就是可能会出现循环，为了防止出现循环，还是要使用vis数组的，这样就没事了。这是比较简单的dfs题。
#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
using namespace std;
int dir[2] = {-1, 1};
// int n;
bool flag = false;
//问题：可能会出现无穷递归，需要记录每个节点是否被访问
void travel(vector<int> &arr, vector<int> &vis, int start)
{
vis[start] = 1; //先让节点已经被访问
if(arr[start] == 0)
{
flag = true;
return;
}
else
{
int len = arr.size();
for(int i = 0; i < 2; i++)
{
int next = start + dir[i]*arr[start];
if(next >= 0 && next < len && !vis[next])
{
travel(arr, vis, next);
}
}
}
}
int main()
{
int n, start;
cin >> n;
vector<int> arr(n); //我们的数组
vector<int> vis(n, 0); //记录每个节点是否被访问，不要重复
for(int i = 0; i < n; i++)
{
cin >> arr[i];
}
cin >> start;
travel(arr, vis, start);
if(flag)
cout << "True" << endl;
else
cout << "False" << endl;
return 0;
}7-4 最长光路
分数 300
小明在做丁达尔效应的实验。
他用胶体填满了一个有 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个格子
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
第四题题解：
相对比较难的dfs，让人望而生畏。我也是借鉴了别人的代码。这个题似乎有做小游戏的感觉了。注意下什么情况下才能成环呢？路过起始节点就可以吗？不对不对，不仅要路过其实节点还要方向和第一次来时一样才行。就是说第一次来起点时是往左的，那么这次来起点也是往左才能成环的。这是坑点1，我还踩了个坑，就是这题题目中说的重复走过多个节点要分别计算，二我看错了，看成不能重复计算了。所以又错了。这么说来，这题其实不需要用到vis数组，只要判断起点是不是第一次走过的就行了，用个flag管够，记得循环每次flag复位。别的也没什么可说的，都不难实现的。
#include <iostream>
using namespace std;
//上右下左
int dir_x[4] = {-1, 0, 1, 0};
int dir_y[4] = {0, 1, 0, -1};
char arr[502][502] = {0};
// bool vis[502][502] = {0};
bool flag = true; //用于区分是否第一次路过第一点
int now = 0; //现在的路径
int start_x = 0, start_y = 0; //起始点x和y
int N = 0, M = 0;
//参数是起始的x和起始的y，还有方向
void dfs(int sx, int sy, int d, int sd)
{
//到达时
if(d == sd && sx == start_x && sy == start_y)
{
if(flag)
{
flag = false;
}
else
{
now = -1;
return;
}
}
// if(!vis[sx][sy])
// {
// vis[sx][sy] = true;
// // now++;
// }
now++;
int nx = sx+dir_x[d], ny = sy+dir_y[d]; //下一个点的坐标
if(nx > 0 && nx <= N && ny > 0 && ny <= M)
{
switch(arr[nx][ny])
{
case 'C':
break;
case '.':
dfs(nx, ny, d, sd);
break;
case '/':
if(d == 0)
{
dfs(nx, ny, 1, sd);
}
else if(d == 1)
{
dfs(nx, ny, 0, sd);
}
else if(d == 2)
{
dfs(nx, ny, 3, sd);
}
else
{
dfs(nx, ny, 2, sd);
}
break;
case '\\':
if(d == 0)
{
dfs(nx, ny, 3, sd);
}
else if(d == 1)
{
dfs(nx, ny, 2, sd);
}
else if(d == 2)
{
dfs(nx, ny, 1, sd);
}
else
{
dfs(nx, ny, 0, sd);
}
break;
}
}
else
{
return;
}
}
int main()
{
cin >> N >> M;
//N行M列下标从1开始
for(int i = 1; i <= N; i++)
{
for(int j = 1; j <= M; j++)
{
cin >> arr[i][j];
if(arr[i][j] == 'S')
{
start_x = i;
start_y = j;
}
}
}
cin >> start_x >> start_y; //输入起始点的坐标
int ans = 0;
int maxval = -1;
for(int i = 0; i < 4; i++)
{
flag = true; //记得重新设置
dfs(start_x, start_y, i, i);
if(now == -1)
{
ans = -1;
maxval = i;
break;
}
else
{
if(now > ans)
{
ans = now;
maxval = i;
}
}
//memset
// for(int i = 1; i <= N; i++)
// {
// for(int j = 1; j <= M; j++)
// {
// vis[i][j] = 0;
// }
// }
now = 0; //now需要清零
}
switch(maxval)
{
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)
{
cout << "COOL" << endl;
}
else
{
cout << ans << endl;
}
return 0;
}
813
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
