双周赛第二次

最新推荐文章于 2024-05-20 18:16:07 发布

想做梦的泽熙

最新推荐文章于 2024-05-20 18:16:07 发布

阅读量154

点赞数

分类专栏： c++算法文章标签：深度优先算法图论

本文链接：https://blog.csdn.net/m0_74625021/article/details/128292558

版权

c++算法专栏收录该内容

19 篇文章 0 订阅

订阅专栏

T1：输出全排列

题目：

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

思路：

依次放数字，n个数字，当放到第n+1层，说明前面n个空已经填满了，打印输出一次

#include<bits/stdc++.h>
using namespace std;
int n,a[100005],vis[100005];
void pr()
{
    for(int i=1;i<=n;i++)cout<<a[i];
    cout<<endl;
}
void dfs(int x)
{
    if(x>n){
        pr();
        return;
    }
    for(int i=1;i<=n;i++){
        if(vis[i]==0){
            a[x]=i;
            vis[i]=1;
            dfs(x+1);
            vis[i]=0;
        }
    }
}
int main()
{
    cin>>n;
    dfs(1);
    return 0;
}

T2：山

题目：

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

要求:

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

思路：

就是寻找联通块的数量，dfs不回溯即可

#include<bits/stdc++.h>
using namespace std;
int n,m,ans;
int maze[2005][2005],vis[2005][2005];
int nxt[][2]={{1,0},{-1,0},{0,1},{0,-1}};
void dfs(int x,int y){
    for(int i=0;i<=3;i++){
        int nx=x+nxt[i][0],ny=y+nxt[i][1];
        if(nx>=1&&nx<=n&&ny>=1&&ny<=m&&vis[nx][ny]==0&&maze[nx][ny]==1){
            vis[nx][ny]=1;
            dfs(nx,ny);//不回溯
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)cin>>maze[i][j];
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(!vis[i][j]&&maze[i][j]==1){
                vis[i][j]=1;
                dfs(i,j);
                ans++;
            }//找到一个联通块
        }
    }
    cout<<ans;
    return 0;
}

T3：跳跃

题目：

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

要求:

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

`思路：`

用dfs分别从上下两个方向搜即可，注意一个大坑：下标从0开始！！！

#include<bits/stdc++.h>
using namespace std;
int n,dot[100005],start,flag;
int vis[100005];
bool check(int x)
{
    if(x>=0&&x<n)return 1;
    else return 0;
}
void dfs(int x)
{
    if(dot[x]==0){
        cout<<"True";
        flag=1;
        exit(0);//找到了安全退出
    }
    int nx1=x+dot[x],nx2=x-dot[x];//分别朝上下搜索
    if(check(nx1)&&vis[nx1]==0){
        vis[nx1]=1;
        dfs(nx1);
        vis[nx1]=0;
    }
    if(check(nx2)&&vis[nx2]==0){
        vis[nx2]=1;
        dfs(nx2);
        vis[nx2]=0;
    }
}
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)cin>>dot[i];
    cin>>start;
    dfs(start);
    if(!flag)cout<<"False";
    return 0;
}

T5：回文数文回

题目：

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

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

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

输入格式:

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

输出格式:

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

思路：

要解决的问题：

首先设计9位的回文数，只需要设计5个数然后翻转就行了，就相当于手上有10个数字0-9，你要去填5个空，其中第一个空不能填0
然后对于每个回文数字需要设计一个sum函数，求得用这5位数字得的回文数的值

#include<bits/stdc++.h>
using namespace std;
int n,ans,a[10];
int vis[10];
void pr()
{
    for(int i=1;i<=9;i++)cout<<a[i];
    cout<<endl;
}
int sum(){//求回文数的值
    int s=0;
    for(int i=1;i<=5;i++){
        s=s*10+a[i];
    }
    for(int i=4;i>=1;i--){
    	s=s*10+a[i];
	}
    return s;
}
void dfs(int x)//填5个空
{
    if(x==6){
        int s=sum();
        if(s<=n){
        	//cout<<s<<endl;
        	ans++;
		}
        return;
    }
    if(x==1&&vis[x]==0){
        for(int i=1;i<=9;i++){
            a[x]=i;
            vis[x]=1;
            dfs(x+1);
            vis[x]=0;
        }
    }
    else if(vis[x]==0) 
        for(int i=0;i<=9;i++){
            a[x]=i;
            vis[x]==1;
            dfs(x+1);
            vis[x]=0;
        }
}
int main()
{
    cin>>n;
    dfs(1);
    cout<<ans<<endl;
    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

思路：

首先在常规dfs(x,y)的基础，要引入一个方向参数d，代表他一直朝这个方向前进
其次对于反转的问题，要对方向做一个规定d=0，代表向上，d=1，代表向右，d=2，代表向下，d=3代表向左（这样规定就可以保证输出时候，存在两个最优解，优先输出右

判断循环：若某一个点走过了1000+次说明进入了死循环，即一个环


#include<bits/stdc++.h>
using namespace std;
int n,m,sx,sy;
char maze[1005][1005];
int dx[4]={-1,0,1,0};
int dy[4]={0,1,0,-1};//上右下左 
char D[4]={'U','R','D','L'};//输出方向
int mark,f_Max,Max,cool,vis[1005][1005];
int cnt;//步数
void dfs(int x,int y,int d)//坐标和方向
{
	if(vis[x][y]>100)
	{
		cool=1;
		return;
	}
	if(x>n||y>m||x<=0||y<=0||maze[x][y]=='C')
	{
		if(cnt>Max)//判定当前总格子数是否超过最大值
		{
			Max=cnt;
			f_Max=mark;
		}
		mark++;
		return;
	}
	
	else
	{
		if(maze[x][y]=='\\')
		{
			if(d==0) d=3;
			else if(d==3) d=0;
			else if(d==1) d=2;
			else if(d==2) d=1;
		}
		if(maze[x][y]=='/')
		{
			if(d==0) d=1;
			else if(d==3) d=2;
			else if(d==2) d=3;
			else if(d==1) d=0;
		}
	}
	cnt++;
	vis[x][y]++;
	int nx=x+dx[d];
	int ny=y+dy[d];
	dfs(nx,ny,d);
} 
int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			cin>>maze[i][j];
		}
	}
	cin>>sx>>sy;
	for(int i=0;i<4;i++)
	{
		cnt=0;
		memset(vis,0,sizeof(vis));
		dfs(sx,sy,i);
		if(cool) 
		{
			f_Max=i;
			break;
		}
		
	}
	cout<<D[f_Max]<<endl;
	if(cool) cout<<"COOL";
	else cout<<Max;
	return 0;
}