1-1
请编写程序输出前n个正整数的全排列（n<10），并通过9个测试用例（即n从1到9）观察n逐步增大时程序的运行时间。
输入格式:
输入给出正整数n（<10）。
输出格式:
输出1到n的全排列。每种排列占一行，数字间无空格。排列的输出顺序为字典序，即序列a1,a2,⋯,a_n排在序列b1,b2,⋯,b_n之前，如果存在k使得a1=b1,⋯,a_k=b_k 并且 a_k+1<b_k+1。
输入样例：
3
输出样例：
123 132 213 231 312 321
代码长度限制
16 KB
时间限制
3500 ms
内存限制
64 MB
解题思路：dfs
完整代码如下：
#include <bits/stdc++.h>
using namespace std;
int n;
int a[11];
bool vis[11];
void dfs(int x);
int main()
{
cin>>n;
dfs(1);
return 0;
}
void dfs(int x)
{
if(x==n+1)
{
for(int i=1; i<=n; i++)
{
if(i==n) cout<<a[i]<<endl;
else cout<<a[i];
}
}
for(int i=1; i<=n; i++)
{
if(!vis[i])
{
vis[i]=true;
a[x]=i;
dfs(x+1);
vis[i]=false;
}
}
}
1-2
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
Python (python3)
时间限制
5000 ms
内存限制
64 MB
Java (javac)
时间限制
2000 ms
内存限制
256 MB
其他编译器
时间限制
1000 ms
内存限制
256 MB
解题思路：dfs
遍历图中的每一个点，找到山后，用dfs把其邻近的山都走过，并把走过的山都标记，大山数目+1，直到所有山都被走过为止
完整代码如下：
#include <bits/stdc++.h>
using namespace std;
int m,n,cnt=0;
int tu[2005][2005];
bool vis[2005][2005];
int sx[5]={1,-1,0,0};
int sy[5]={0,0,1,-1};
void dfs(int x,int y);
int main()
{
cin>>m>>n;
for(int i=1; i<=m; i++)
{
for(int j=1; j<=n; j++)
{
cin>>tu[i][j];
}
}
for(int i=1; i<=m; i++)
{
for(int j=1 ;j<=n; j++)
{
if(tu[i][j]==1 && !vis[i][j])
{
vis[i][j]=true;
cnt++;
dfs(i,j);
}
}
}
cout<<cnt;
return 0;
}
void dfs(int x,int y)
{
for(int i=0; i<4; i++)
{
int next_x=x+sx[i];
int next_y=y+sy[i];
if(next_x>=1 && next_x<=m && next_y>=1 && next_y<=n && tu[next_x][next_y]==1 && !vis[next_x][next_y])
{
vis[next_x][next_y]=true;
dfs(next_x,next_y);
}
}
}
1-3
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
解题思路：bfs
注意数组的下标是从0开始的
完整代码如下：
#include <bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
int n,m[maxn],start;
bool vis[maxn];
queue <int> q;
int main()
{
cin>>n;
for(int i=0; i<n; i++) cin>>m[i];
cin>>start;
if(start<0 || start>=n){
cout<<"False";
return 0;
}
int flag=0;//标记是否有出口
q.push(start);
vis[start]=true;
while(!q.empty()){
int t=q.front();
q.pop();
if(m[t]==0){
flag=1;
break;
}//找到出口
if(t+m[t]<n && !vis[t+m[t]]){
q.push(t+m[t]);
vis[t+m[t]]=true;
}//向前跳
if(t-m[t]>=0 && !vis[t-m[t]]){
q.push(t-m[t]);
vis[t-m[t]]=true;
}//向后跳
}
if(flag) cout<<"True";
else cout<<"False";
return 0;
}
1-4
小明在做丁达尔效应的实验。 他用胶体填满了一个有 N 行, M 列个格子的透明盒子。同时，为了使实验效果更好，他在盒子的某些格子中装入一些双面镜(用“/”和“\”表示)。 当光线找到双面镜的时候，光路会反射，方向会有90度的转换（如下图所示）。
小明在填充胶体的时候产生了失误，使得有些格子光线无法穿过（我们可以认为这些格子把光线都吸收了），这些格子用大写字母“C”来表示。
现在，小明已经制作好了实验装置，他将激光光源放在第s**x行的第sy个格子上。激光光源可以朝向上下左右四个方向，分别用URDL四个字母表示(“U”-上, “R”-右, “D”-下, “L”-左)。
为了让实验效果更好，小明希望光的光路越酷越好。 对小明来说，最酷的光路就是包含环的光路，这种情况下，光不会射向盒子外面，而是一直在盒子内循环（数据保证光源处的点是光线可以通过，即起点一点是"."）。 如果光源朝各个方向摆设，最终光线都会射向盒子外部，那么小明认为经过格子最多的光路是最酷的。
现在小明想知道光源朝哪个方向放置光路最酷。 如果光路是不包含环的，那么他还想知道光路经过的格子数目是多少。
注意
如果有多个方向是最优解，那么我们按照“U”-上, “R”-右, “D”-下, “L”-左的优先级来选择最终的答案，即如果向左和向右都是最优解，我们选择向右的方案。
同时，温馨提醒，c++中“\”符号可以用'\\'来表示
输入格式:
第一行两个数 N,M(1≤N,M≤500) 表示有N 行 M 列的格子。 接下来 N 行, 每行 M 个字符，表示盒子的具体情况。 “/”和“\”表示装有不同朝向的镜子的格子。“C”表示光线无法通过的格子。“.”表示正常且没有镜子的格子。 最后输入两个数字s**x,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
如果遇到’.',则继续按照原方向走
如果遇到‘/’或‘\’，则按照题意转变方向后走
如果走到起点，则记录此方向能形成闭环
不能则记录此方向走过的格数
完整代码如下：
#include <bits/stdc++.h>
using namespace std;
const int maxn=505;
int n,m,sx,sy;
char tu[maxn][maxn],dir[4]={'U','R','D','L'};
int xx[4]={-1,0,1,0};
int yy[4]={0,1,0,-1}; //U R D L
bool direction[4];
int flag=0,num[4]={1,1,1,1},k=0;
void dfs(int x,int y,int x1,int y1);
int main()
{
cin>>n>>m;
for(int i=1; i<=n; i++){
for(int j=1; j<=m; j++){
cin>>tu[i][j];
}
}
cin>>sx>>sy;
for(int i=0; i<4; i++){
int t1=sx+xx[i];
int t2=sy+yy[i];
if(t1>=1 && t1<=n && t2>=1 && t2<=m){
if(tu[t1][t2]!='C'){
num[k]++;
}
dfs(t1,t2,sx,sy);
if(flag) direction[i]=true; //记录闭环路
flag=0;
k++;
}else{
k++;
}
}
for(int i=0; i<4; i++){
if(direction[i]){
cout<<dir[i]<<endl<<"COOL";
return 0;
}
}
int max=0,f;
for(int i=0; i<4; i++){
if(num[i]>max){
f=i;
max=num[i];
}
}
cout<<dir[f]<<endl<<num[f];
return 0;
}
void dfs(int x,int y,int x1,int y1)
{
if(tu[x][y]=='C'){
num[k]--;
return;
}
int next_x,next_y;
if(tu[x][y]=='.'){
next_x=x+(x-x1);
next_y=y+(y-y1);
}
if(tu[x][y]=='/'){
if(x-x1==-1){
next_x=x;
next_y=y+1;
}
if(x-x1==1){
next_x=x;
next_y=y-1;
}
if(y-y1==-1){
next_x=x+1;
next_y=y;
}
if(y-y1==1){
next_x=x-1;
next_y=y;
}
}
if(tu[x][y]=='\\'){
if(x-x1==-1){
next_x=x;
next_y=y-1;
}
if(x-x1==1){
next_x=x;
next_y=y+1;
}
if(y-y1==-1){
next_x=x-1;
next_y=y;
}
if(y-y1==1){
next_x=x+1;
next_y=y;
}
}
if(next_x==sx && next_y==sy){
flag=1;
return;
}
if(next_x>=1 && next_y>=1 && next_x<=n && next_y<=m){
num[k]++;
dfs(next_x,next_y,x,y);
}
}
1-5
我们称一个数是回文的，当且仅当它正着读和倒着读是相同的。
例如11或11455411是回文的，而10或1919810不是回文的。
现在给定一个数n，你需要求出区间[108,n]中所有的回文数。
输入格式:
一行一个整数n(108≤n<109)
输出格式:
输出一行一个数，表示题目所求区间中回文数的数量。
输入样例:
在这里给出一组输入。例如：
100000001
输出样例:
在这里给出相应的输出。例如：
1
代码长度限制
16 KB
时间限制
500 ms
内存限制
64 MB
解题思路：对于每一个abcdefghi有且只有1个abcdedcba，所以每10000个数中有一个回文数，因此只需要判断最后那10000
完整代码如下：
#include <bits/stdc++.h>
using namespace std;
int a[4],b[4],c[4];
int main()
{
int n,ans=0;
cin>>n;
int x1,x2;
x1=n%10000;//取出最后4个数
x2=n/1e5;//取出前面4个数
int t,s=0;
while(x2>0){
t=x2%10;
s=s*10+t;
x2/=10;
}
int m;
if(s<=x1) m=1;
else m=0;
ans=(n-1e8)/1e4+m;
cout<<ans;
return 0;
}
扫一扫
2245
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
