1、输出全排列
请编写程序输出前n个正整数的全排列（n<10），并通过9个测试用例（即n从1到9）观察n逐步增大时程序的运行时间。
输入格式:
输入给出正整数n（<10）。
输出格式:
输出1到n的全排列。每种排列占一行，数字间无空格。排列的输出顺序为字典序，即序列a1 ,a2 ,⋯,an排在序列b 1 ,b 2 ,⋯,b n 之前，如果存在k使得a1=b1 ,⋯,a k=b k并且 a k+1 <b k+1 。
输入样例：
3
输出样例：
123
132
213
231
312
321
思路：
很经典的dfs例题，废话不多说，直接看代码。
#include<iostream>
using namespace std;
int a[10]={0},top=1,n;//用数组a和top来模拟堆栈
bool vis[10]={0}; //用于记录数i（i<=n）是否被用过
void dfs()
{
if(top==n+1) //dfs出口:当栈a中数字个数足够时
{
for(int i=1;i<top;i++)
{
cout<<a[i]; //把栈内的数字都输出
}
cout<<endl;
return;
}
for(int i=1;i<=n;i++)
{
if(vis[i]==0) //判断是否用过数字i
{
vis[i]=1;
a[top]=i;
top++;
dfs();
vis[i]=0;
top--;
}
}
}
int main()
{
cin>>n;
dfs();
}
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
思路：
本题同样是dfs。可以选择遍历地图内所有的点：如果遇到某个点是1，则记录这个1所在的位置走过，并且把这个点周围的所有的1都进行记录。简单的dfs思想。
#include<iostream>
using namespace std;
int a[2005][2005]; //储存地图
int vis[2005][2005]={0}; //记录某点是否走过
int m,n,js=0; //js记录大山数
int sx[4]={-1,0,1,0};
int sy[4]={0,1,0,-1}; //上右下左，四个方向
void dfs(int x,int y)
{
for(int i=0;i<4;i++)
{
int nx=x+sx[i];
int ny=y+sy[i];
if(nx>0&&nx<=m&&ny>0&&ny<=n&&a[nx][ny]==1&&vis[nx][ny]==0)
{ //判断下一个点是否未走过并且是小山
vis[nx][ny]=1; //标记该小山已走过
dfs(nx,ny); //继续从(nx,ny)开始往四周搜索
}
}
}
int main()
{
cin>>m>>n;
for(int i=1;i<=m;i++)
for(int j=1;j<=n;j++)
cin>>a[i][j]; //储存地图
for(int i=1;i<=m;i++)
for(int j=1;j<=n;j++)
if(a[i][j]==1&&vis[i][j]==0) //判断该点是否为山并且未走过
{
dfs(i,j);
js++;
}
cout<<js;
return 0;
}
3、跳跃
Drizzle 被困到一条充满数字的方块路中，假设这条路由一个非负的整数数组m组成，Drizzle 最开始的位置在下标 start 处，当他位于下标i位置时可以向前或者向后跳跃m[i]步数，已知元素值为0处的位置是出口，且只能通过出口出去，不可能数组越界，请你通过编程计算出Drizzle能否逃出这里。
要求:
输入：第一行输入数组m的长度n 第二行输入数组元素，空格分割开 第三行输入起始下标start
输出：True或False
示例:
输入：
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
思路
这题也是dfs，直接上代码。
#include<iostream>
using namespace std;
int m[50005];
int vis[50005]={0}; //判断是否走过
int n,st,flag=0;
void dfs(int x)
{
if(m[x]==0)
{
flag=1; //标记在走过所有点前可以经过0的情况
return;
}
int f=x-m[x]; //往左走或往右走
int b=x+m[x];
if(f<n&&f>=0&&vis[f]==0)
{
vis[f]=1;
dfs(f);
vis[f]=0;
}
if(b<n&&b>=0&&vis[b]==0)
{
vis[b]=1;
dfs(b);
vis[b]=0;
}
}
int main()
{
cin>>n;
for(int i=0;i<n;i++)
{
cin>>m[i];
}
cin>>st;
dfs(st);
if(flag==1)cout<<"True";
else cout<<"False";
return 0;
}
4、最长光路
小明在做丁达尔效应的实验。
他用胶体填满了一个有 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个格子
#include<iostream>
#include<cstring>
using namespace std;
int n,m;
char mp[666][666];
int vis[666][666]={0};
int ans=0,flag=0;
void reflect(int x,int y,int fx)
{
do
{
if(fx==1)
{x--;}
else if(fx==2)
{y++;}
else if(fx==3)
{x++;}
else if(fx==4)
{y--;}
if(mp[x][y]=='\\'||mp[x][y]=='/')
{vis[x][y]++;}
ans++;
}while(mp[x][y]=='.'&&x>0&&y>0&&x<=n&&y<=m);
if(mp[x][y]=='C')
{return ;}
if(vis[x][y]>=6)
{
flag=1;
return ;
}
if(x<1||x>n||y<1||y>m)
{
flag=0;
return ;
}
if(fx==1)
{
if(mp[x][y]=='\\')
{
reflect(x,y,4);
}
else if(mp[x][y]=='/')
{
reflect(x,y,2);
}
}
else if(fx==2)
{
if(mp[x][y]=='\\')
{
reflect(x,y,3);
}
else if(mp[x][y]=='/')
{
reflect(x,y,1);
}
}
else if(fx==3)
{
if(mp[x][y]=='\\')
{
reflect(x,y,2);
}
else if(mp[x][y]=='/')
{
reflect(x,y,4);
}
}
else if(fx==4)
{
if(mp[x][y]=='\\')
{
reflect(x,y,1);
}
else if(mp[x][y]=='/')
{
reflect(x,y,3);
}
}
}
int main()
{
memset(mp,'.',sizeof(mp));
cin>>n>>m;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cin>>mp[i][j];
}
}
int sx,sy;
cin>>sx>>sy;
int dr[4]={1,2,3,4};
int anss=0,ansss=0;
for(int i=0;i<4;i++)
{
reflect(sx,sy,dr[i]);
if(ans>anss)
{
ansss=i;
}
if(flag==1)
{ansss=i;break;}
anss=max(ans,anss);
memset(vis,0,sizeof(vis));
ans=0;
}
ansss++;
if(ansss==1)
{cout<<"U"<<endl;}
if(ansss==2)
{cout<<"R"<<endl;}
if(ansss==3)
{cout<<"D"<<endl;}
if(ansss==4)
{cout<<"L"<<endl;}
if(flag==0)
{
cout<<anss;
}
else if(flag==1)
{
cout<<"COOL";
}
}
5、回文数文回
我们称一个数是回文的，当且仅当它正着读和倒着读是相同的。
例如11或11455411是回文的，而10或1919810不是回文的。
现在给定一个数n，你需要求出区间[10 8 ,n]中所有的回文数。
输入格式:
一行一个整数n(108≤n<109 )
输出格式:
输出一行一个数，表示题目所求区间中回文数的数量。
输入样例:
100000001
输出样例:
1
思路：
可以注意到 范围内的数可能很多，但是回文数的数量很少（不超过910101010个）。
因此考虑从构造回文数的角度去入手，思考我们怎样创造一个回文数。
要构造一个有九位数的回文数，我们只需随意指定其前5位数字，然后将前4位的数字倒转过来作为最后4位数字即可。例如前五位数字分别为 ，那么 必定是一个回文数。因此只需枚举前五位数字的取值，即可获得所有是回文数的九位数，注意首位的取值不能为0。这样的数字最多只有 种，其中值不超过 的即为答案。
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
long long n;
int ans=0;
cin>>n;
long long m=n/100000;
for(int i=1000;i<=m;i++)
{
int num=i,j=3;
long long sum=0;
do
{
sum+=(num%10)*pow(10,j);
j--;
num/=10;
} while (num!=0);
sum+=(i*100000);
for(int k=0;k<=9;k++)
{
if(sum+(k*pow(10,4))<=n)
{ans++;}
}
}
cout<<ans;
}
221
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
