蓝桥杯练习—深度优先搜索

最新推荐文章于 2024-09-11 20:03:34 发布
最新推荐文章于 2024-09-11 20:03:34 发布
阅读量323 收藏
点赞数 9
文章标签： 蓝桥杯 深度优先 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74361062/article/details/137172425
版权

1、迷宫搜索实践1

 #define _CRT_SECURE_NO_WARNINGS 1 
#include<iostream>
#include<string>
using namespace std;

int n, m;
string maze[110];
bool vis[110][110];
bool in(int x, int y)
{
	return 0 <= x && x < n && 0 <= y && y < m;
}
bool dfs(int x, int y)
{
	if (maze[x][y] == 'T')
	{
		return true;//若访问到终点 直接返回
	}
	vis[x][y] = 1;//将访问过的位置标记为1
	maze[x][y] = 'm';//将走过的路径标记为m
	int tx = x - 1, ty = y;//对于数组来说 向上走一步
	if (in(tx, ty) && maze[tx][ty] != '*' && !vis[tx][ty])
	{
		//若在地图中 并且 不是墙的位置 并且 没有被访问过
		if (dfs(tx, ty))
		{
			return true;//若能搜出来就返回 true
		}
	}
	tx = x, ty = y - 1;//向左走一步
	if (in(tx, ty) && maze[tx][ty] != '*' && !vis[tx][ty])
	{
		if (dfs(tx, ty))
		{
			return true;
		}
	}
	tx = x + 1, ty = y;//向下走
	if (in(tx, ty) && maze[tx][ty] != '*' && !vis[tx][ty])
	{
		if (dfs(tx, ty))
		{
			return true;
		}
	}
	tx = x, ty = y + 1;//向右走
	if (in(tx, ty) && maze[tx][ty] != '*' && !vis[tx][ty])
	{
		if (dfs(tx, ty))
		{
			return true;
		}
	}
	vis[x][y] = 0;//若找不到 恢复标记
	maze[x][y] = '.';
	return false;
}

int main()
{
	//输入迷宫地图
	cin >> n >> m;
	for (int i = 0; i < n; i++)
	{
		cin >> maze[i];
	}
	int x, y;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (maze[i][j] == 'S')//先找到起始点 S
			{
				x = i, y = j;
			}
		}
	}
	if (dfs(x, y))
	{
		for (int i = 0; i < n; i++)
		{
			cout << maze[i] << endl;
		}
	}
	else
	{
		cout << "No" << endl;
	}
	return 0;
}

2、迷宫搜索实践2（减少代码量）

 #define _CRT_SECURE_NO_WARNINGS 1 
#include<iostream>
#include<string>
using namespace std;

int n, m;
string maze[110];
bool vis[110][110];
int dir[4][2] = { {-1,0},{0,-1},{1,0},{0,1} };//上 左 下 右

bool in(int x, int y)
{
	return 0 <= x && x < n && 0 <= y && y < m;
}

bool dfs(int x, int y)
{
	if (maze[x][y] == 'T')
	{
		return true;
	}
	vis[x][y] = 1;
	maze[x][y] = 'm';
	for (int i = 0; i < 4; i++)
	{
		int tx = x + dir[i][0];
		int ty = y + dir[i][1];
		if (in(tx, ty) && maze[tx][ty] != '*' && !vis[tx][ty])
		{
			if (dfs(tx, ty))
			{
				return true;
			}
		}
	}
	vis[x][y] = 0;
	maze[x][y] = '.';
	return false;
}

int main()
{
	cin >> n >> m;
	for (int i = 0; i < n; i++)
	{
		cin >> maze[i];
	}
	int x, y;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (maze[i][j] == 'S')
			{
				x = i, y = j;
			}
		}
	}
	if (dfs(x, y))
	{
		for (int i = 0; i < n; i++)
		{
			cout << maze[i] << endl;
		}
	}
	else
	{
		cout << "No" << endl;
	}
	return 0;
}

3、中国象棋

 #define _CRT_SECURE_NO_WARNINGS 1 
#include<cstdio>

char s[10][10];
int dir[8][2] = { {2,1},{1,2},{-1,2},{-2,1},{-2,-1},{-1,-2},{1,-2},{2,-1} };
bool vis[10][10];
bool f;
bool in(int x, int y)
{
	return 0 <= x && x < 10 && 0 <= y && y < 9;
}
void dfs(int x,int y)
{
	vis[x][y] = true;//标记走过的位置
	if (f)
	{
		return;//如果找到了一条路就可以不用再找了，直接return
	}
	if (s[x][y] == 'T')
	{
		f = true;
		return;
	}
	for (int i = 0; i < 8; i++)
	{
		int tx = x + dir[i][0];
		int ty = y + dir[i][1];
		if (in(tx, ty) && s[tx][ty] != '#' && !vis[tx][ty])
		{
			dfs(tx, ty);
		}
	}
}

int main()
{
	int x, y;
	for (int i = 0; i < 10; i++)
	{
		scanf("%s", s[i]);
	}
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 9; j++)
		{
			if (s[i][j] == 'S')
			{
				x = i;
				y = j;
			}
		}
	}
	dfs(x, y);
	if (f)
	{
		printf("Yes\n");
	}
	else
	{
		printf("No\n");
	}
	return 0;
}

4、迷宫最短路径

 #define _CRT_SECURE_NO_WARNINGS 1 
#include<iostream>
#include<string>
using namespace std;

int n, m;
string maze[110];
bool vis[110][110];
int dir[4][2] = { {-1,0},{0,-1},{1,0},{0,1} };
int ans = 1000000000;
bool in(int x, int y)
{
	return 0 <= x && x < n && 0 <= y && y < m;
}

void dfs(int x, int y, int step)
{
	if (maze[x][y] == 'T')
	{
		if (step < ans)
		{
			ans = step;
		}
		return;
	}
	vis[x][y] = 1;
	for (int i = 0; i < 4; i++)
	{
		int tx = x + dir[i][0];
		int ty = y + dir[i][1];
		if (in(tx, ty) && maze[tx][ty] != '*' && !vis[tx][ty])
		{
			dfs(tx, ty, step + 1);
		}
	}
	vis[x][y] = 0;
}

int main()
{
	cin >> n >> m;
	for (int i = 0; i < n; i++)
	{
		cin >> maze[i];
	}
	int x, y;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (maze[i][j] == 'S')
			{
				x = i;
				y = j;
			}
		}
	}
	dfs(x, y, 0);
	cout << ans << endl;
	return 0;
}

5、踏青

 #define _CRT_SECURE_NO_WARNINGS 1 
#include<cstdio>

char mp[105][105];
bool vis[105][105];
int n, m;
void dfs(int x, int y)
{
	if (x < 0 || x >= n || y < 0 || y >= m || vis[x][y] || mp[x][y] == '.')
	{
		return;
	}
	vis[x][y] = true;
	dfs(x - 1, y);//上
	dfs(x + 1, y);//下
	dfs(x, y - 1);//左
	dfs(x, y + 1);//右
}

int main()
{
	int cnt = 0;
	scanf("%d%d", &n, &m);
	for (int i = 0; i < n; i++)
	{
		scanf("%s", mp[i]);
	}
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (!vis[i][j] && mp[i][j] == '#')
			{
				dfs(i, j);
				cnt++;//草丛数量
			}
		}
	}
	printf("%d\n", cnt);
	return 0;
}

6、迷宫解方案数

 #define _CRT_SECURE_NO_WARNINGS 1 
#include<cstdio>

int n, m, x, y, ans;
char mp[15][15];
bool vis[15][15];
void dfs(int x, int y)
{
	if (x < 0 || x >= n || y < 0 || y >= m || vis[x][y] || mp[x][y] == '#')
	{
		return;
	}
	if (mp[x][y] == 'e')
	{
		ans++;
		return;
	}
	vis[x][y] = true;
	dfs(x - 1, y);//上
	dfs(x + 1, y);//下
	dfs(x, y - 1);//左
	dfs(x, y + 1);//右
	vis[x][y] = false;
}

int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 0; i < n; i++)
	{
		scanf("%s", mp[i]);
	}
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (mp[i][j] == 'S')
			{
				x = i;
				y = j;
			}
		}
	}
	dfs(x, y);
	printf("%d\n", ans);
	return 0;
}

7、最大的蛋糕块

 #define _CRT_SECURE_NO_WARNINGS 1 
#include<cstdio>

int n, m, cnt, ans;
char mp[1005][1005];
bool vis[1005][1005];

void dfs(int x, int y)
{
	if (x < 0 || x >= n || y < 0 || y >= m || vis[x][y] || mp[x][y] == '.')
	{
		return;
	}
	vis[x][y] = true;
	cnt++;
	dfs(x - 1, y);
	dfs(x + 1, y);
	dfs(x, y - 1);
	dfs(x, y + 1);
}

int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 0; i < n; i++)
	{
		scanf("%s", mp[i]);
	}
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (!vis[i][j] && mp[i][j] == '#')
			{
				cnt = 0;
				dfs(i, j);
				if (cnt > ans)
				{
					ans = cnt;
				}
			}
		}
	}
	printf("%d\n", ans);
	return 0;
}

8、家谱

 #define _CRT_SECURE_NO_WARNINGS 1 
#include<cstdio>
#include<vector>
using namespace std;

vector<int> son[100005];
bool f[100005];//寻根
int ans[100005];

int dfs(int u)
{
	int ret = 0;
	for (int i = 0; i < son[u].size(); i++)
	{
		ret += dfs(son[u][i]);
	}
	ans[u] = ret;
	return ret + 1;
}

int main()
{
	int n, x, y, u;
	scanf("%d", &n);
	for (int i = 0; i < n - 1; i++)
	{
		scanf("%d%d", &x, &y);
		son[x].push_back(y);
		f[y] = true;//将儿子标记，有指向的不为根
	}
	for (int i = 1; i <= n; i++)
	{
		if (!f[i])//若未被标记过
		{
			u = i;//找到起始位置
			break;
		}
	}
	dfs(u);
	for (int i = 1; i <= n; i++)
	{
		printf("%d\n", ans[i]);
	}
	return 0;
}

9、马的覆盖点

 #define _CRT_SECURE_NO_WARNINGS 1 
#include<cstdio>

char s[105][105];
int n, m;
int dir[8][2] = { {2,1},{1,2},{-1,2},{-2,1},{-2,-1},{-1,-2},{1,-2},{2,-1} };

void dfs(int x, int y, int step)
{
	if (step > 3)
	{
		return;
	}
	if (x < 0 || x >= n || y < 0 || y >= m)
	{
		return;
	}
	s[x][y] = '#';
	for (int i = 0; i < 8; i++)
	{
		dfs(x + dir[i][0], y + dir[i][1], step + 1);
	}
}

int main()
{
	int x, y;
	scanf("%d%d%d%d", &n, &m, &x, &y);
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			s[i][j] = '.';
		}
	}
	dfs(x - 1, y - 1, 0);
	for (int i = 0; i < n; i++)
	{
		printf("%s\n", s[i]);
	}
	return 0;
}

10、王子救公主

 #define _CRT_SECURE_NO_WARNINGS 1 
#include<cstdio>

char mp[105][105];
bool vis[105][105][2];
int n, m;

void dfs(int x, int y, int d)
{
	if (x < 0 || x >= n || y < 0 || y >= m || vis[x][y][d] || mp[x][y] == '#')
	{
		return;
	}
	vis[x][y][d] = true;
	dfs(x - (2 - d), y, d);
	dfs(x + (2 - d), y, d);
	dfs(x, y - (2 - d), d);
	dfs(x, y + (2 - d), d);
}

int main()
{
	int x, y;
	bool ans;
	scanf("%d%d", &n, &m);
	for (int i = 0; i < n; i++)
	{
		scanf("%s", mp[i]);
	}
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (mp[i][j] == 'w')
			{
				x = i;
				y = j;
			}
		}
	}
	dfs(x, y, 0);
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (mp[i][j] == 'g')
			{
				x = i;
				y = j;
			}
		}
	}
	dfs(x, y, 1);
	ans = false;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (vis[i][j][0] && vis[i][j][1])
			{
				ans = true;
			}
		}
	}
	if (ans)
	{
		printf("yes\n");
	}
	else
	{
		printf("no\n");
	}
	return 0;
}

11、开公司

 #define _CRT_SECURE_NO_WARNINGS 1 
#include<cstdio>;

int task[15][15];
bool used[15];
int ans;
int n;

void dfs(int x,int t)
{
	if (x == n)
	{
		if (t < ans)
		{
			ans = t;
		}
		return;
	}
	for (int i = 0; i < n; i++)
	{
		if (!used[i])
		{
			used[i] = true;
			dfs(x + 1, t + task[x][i]);
			used[i] = false;
		}
	}
}

int main()
{
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			scanf("%d", &task[i][j]);
		}
	}
	ans = 20000;
	dfs(0,0);
	printf("%d\n", ans);
	return 0;
}

泰泰的碳尼
关注
蓝桥杯深度搜索（全排列问题）
m0_37520426的博客
07-10 606
A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。下图就是一种排法（如有对齐问题，参看p1.png）。      A     9 6    4   8   3 7 5 2这样的排法可能会有很多。如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？请你计算并提交该数字。注意：需要提交的是一个整数，不要提交任何多余内容。package lanq...
【算法】蓝桥杯dfs深度优先搜索之排列组合总结
midnight_time的博客
03-21 3699
  上一篇文章 → 《【算法】蓝桥杯dfs深度优先搜索之凑算式总结》   为了重申感谢之意，再次声明下文的大部分灵感均来自于【CSDN】梅森上校《JAVA版本：DFS算法题解两个例子（走迷宫和求排列组合数）》   强烈大家去上面那篇文章看看，写的很好。   下面我会列出蓝桥杯第六届B组省赛第7题、第七届第5题、第八届第4题，共3道题。   因为他们都是：排列组合。 【第一道题】   这道题可以强...
蓝桥杯之深搜
weixin_66294723的博客
03-31 697
首先理解用图深搜利用深搜遍历整个图结点。
深度优先搜索(DFS)-蓝桥杯
ran的博客
02-17 864
递归的过程中做了重复工作，例如fb(3)计算了2次，其实只算1次就够了，为避免递归时重复计算，可以在子问题得到解决时，就保存结果，再次需要这个结果时，直接返回保存的结果就行了，不继续递归下去。，是把大问题逐步缩小，直到变成最小的同类问题的过程，而最后的小问题的解是已知的,一般是给定的初始条件。到达最小问题后，再“回溯”，把小问题的解逐个带回给更大的问题，最终最大问题也得到了解决。在递归的过程中，由于大问题和小问题的解决方法完全一样，那么大问题的代码和小问题的代码可以写成一样。搜索是“通用”的方法。
蓝桥杯——深搜DFS（看完绝对入门DFS）
m0_47963315的博客
03-15 5640
一文详解DFS，看完绝对入门（附练习题和详解）
蓝桥杯深度优先搜索
01-23
整合了几道蓝桥杯近几年的算法题，希望对大家熟悉了解这个算法有帮助
蓝桥杯练习题目和结果代码.zip
03-04
可能需要用到深度优先搜索或广度优先搜索等算法。 9. **随机点名器.java**：这个程序可能会使用Java的随机数生成功能来实现一个随机选择名字的功能。需要掌握Java的Random类或者ThreadLocalRandom类。 10. **十六...
蓝桥杯练习题
06-06
- 搜索算法：深度优先搜索（DFS）、广度优先搜索（BFS）。 - 动态规划：背包问题、最长公共子序列、最短路径问题等。 - 回溯法：八皇后问题、棋盘覆盖问题等。 - 分治策略：快速选择、大数乘法、归并排序等。 4...
C语言省事国赛蓝桥杯练习.zip
11-09
常见的算法如排序（冒泡、选择、插入、快速等）、搜索（线性、二分、深度优先、广度优先等）以及动态规划等，都需要通过C语言实现。 4. 优化技巧：在比赛中，程序的运行时间和空间效率是决定胜负的重要因素。了解...
蓝桥杯 方格填数 深度搜索
SYITwin的博客
03-23 414
方格填数如下的10个格子   +--+--+--+   |  |  |  |+--+--+--+--+|  |  |  |  |+--+--+--+--+|  |  |  |+--+--+--+（如果显示有问题，也可以参看【图1.jpg】）填入0~9的数字。要求：连续的两个数字不能相邻。（左右、上下、对角都算相邻）一共有多少种可能的填数方案？请填写表示方案数目的整数。注意：你提交的应该是一个整数，...
蓝桥杯算法提高-3000米排名预测
欢迎来到bestcoder_judge的异次元博客
08-03 2214
问题描述： 　　3000米长跑时，围观党们兴高采烈地预测着最后的排名。因为他们来自不同的班，对所有运动员不一定都了解，于是他们分别对自己了解的一些运动员的实力作出了评估，即对部分运动员做了相对排名的预测，并且告诉了可怜留守的班长。因为无聊，于是他们就组团去打Dota去了。比赛结束后他们向班长询问最后的排名，但班长不记得了，只记得他们中哪些人的预测是正确的，哪些人的预测是错误的。他们想知道比赛的排名
[dfs(深度优先搜索)]简单类题目 2016年蓝桥杯省赛题第三题——凑算式
Xiao布_unknown的博客
03-21 5753
题目： 凑算式 A + B/C + DEF/GHI = 10 （如果显示有问题，可以参见【图1.jpg】） 这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。 比如： 6+8/3+952/714 就是一种解法， 5+3/1+972/486 是另一种解法。 这个算式一共有多少种解法？ 注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。
深度优先搜索（DFS）第七届蓝桥杯国赛 机器人塔
qq_34884263的博客
05-15 412
机器人塔 X星球的机器人表演拉拉队有两种服装，A和B。 他们这次表演的是搭机器人塔。 类似： A B B A B A A A B B B B B A B A B A B B A 队内的组塔规则是： A 只能站在 AA 或 BB 的肩上。 B 只能站在 AB 或 BA 的肩上。 你的任务是帮助拉拉队计算一下，在给定A与B的人数时，可以组成多少种花样的塔。 输入一行两个整数...
蓝桥杯 ADV-188 算法提高 排列数（java） 深度优先搜索 DFS
Tim的嵌入式之旅
12-12 1576
算法提高 排列数   时间限制：1.0s   内存限制：256.0MB      问题描述 　　0、1、2三个数字的全排列有六种，按照字母序排列如下： 　　012、021、102、120、201、210 　　输入一个数n 　　求0~9十个数的全排列中的第n个（第1个为0123456789）。 输入格式 　　一行，包含一个整数n 输出格式
【算法】蓝桥杯dfs深度优先搜索之凑算式总结
midnight_time的博客
06-04 1万+
本文 → 《【算法】蓝桥杯dfs深度优先搜索之凑算式总结》 相关文章 →《【算法】蓝桥杯dfs深度优先搜索之排列组合总结》 →《【算法】蓝桥杯dfs深度优先搜索之图连通总结》 前言 曾几何时这个词现在用正适合不过了。 曾几何时我还是对dfs算法一脸懵x的状态，虽说大二的时候学过数据结构，但是那一学...
蓝桥杯 历届试题 危险系数 深度搜索java代码实现
ethonyLight的博客
05-15 714
题目如下：这个题说实话博主我折腾了两个晚上，因为图论知识的缺乏，后来在中国大学mooc上的浙大的数据结构课程上看了一点，想到了解法，一开始我走向了用求割点的方法，但是我没有做出来，因为学到的割点算法求的是整个网络中的割点，本题求的是两个精确点的割点，不好解决，那么我们换一个思路，设置一个数组，保存每个节点在所有路径方案上出现的次数，先通过深度遍历的方式遍历从起点到终点的所有路径，找的时候给所有能够...
蓝桥杯及其搜索算法总结
热门推荐
数学---算法---编程
04-03 1万+
蓝桥杯，考暴力和搜索，这是众所周知的事情，近几年的题目非常非常的多。         搜索的基本理论：                    1、回溯法：当把问题分成若干个步骤并递归求解时，如果当前步骤没有合法选择，则函数将返回上一级递归调用，这种现象就称回溯。                    2、路径寻找问题：路径寻找问题可以归结为隐式图的遍历，它的任务是找到一条从初始状态到终止状态
蓝桥杯1.确定字符串是否包含唯一字符
最新发布
DANGAOGAO的博客
09-11 370
插播一句，博主转学python了，来写写算法题，若掌握好会考虑捐300块。
蓝桥杯18小白第5题
qq_73671385的博客
09-11 260
思维，struct sint x,y,z;}q[n];cin>>a;i<=a*2;i++)i<=a*2;i++)int w=0;i<=a*2;i++)if(i%2==1)w+=q[i].x;elsew-=q[i].y;
蓝桥杯C++/C语言算法竞赛笔记与解析
在递归实现中，可以使用`dfs`（深度优先搜索）来实现回溯。 这份资料对于准备蓝桥杯竞赛的选手来说是一份宝贵的资源，它不仅包含了实际的编程练习，还提供了算法理解和优化的思路。通过结合视频讲解，学习者可以更...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值