6、7搜索算法dfs

已于 2022-02-11 22:58:46 修改
阅读量2.4k 收藏 28
点赞数 3
分类专栏： 麦克算法 文章标签： 深度优先 算法 c++ dfs
于 2022-02-03 23:18:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Aa_Lyang/article/details/122772642
版权

文章目录

DFS算法思想–不撞南墙不回头

在这里插入图片描述

DFS经典问题

不带重复数字的全排列

输入n，再输入n个不重复数字，输出这n个数字的所有全排列组合。

#include<bits/stdc++.h>
using namespace std;

int n; //输入数字的个数  
int num[1010]; //存放输入的数字
int a[1010]; //存放全排列 
int b[1010]; //标记数组

void dfs(int t) {
	//递归出口
	if (t == n) {
		for (int i = 0; i < n; i++) {
			cout << a[i] << " ";
		}
		cout << endl; 
		return;
	}
	
	//递归条件
	for (int i = 0; i < n; i++) {
		if (!b[i]) {
			a[t] = num[i];
			b[i] = 1;
			dfs(t + 1);
			b[i] = 0;
		}
	} 
}

int main()
{
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> num[i];
	}
	sort(num, num + n); //为了全排列输出美观，这里我们将输入数字进行排序 
	dfs(0);
	return 0;
}

带重复数字的全排列

输入n，再输入n个可能会重复的数字，输出这n个数字的所有全排列组合。
思路：dfs+剪枝，保证树的每一层只使用特定数字一次。

#include<bits/stdc++.h>
using namespace std;

int n; //输入数字的个数  
int num[1010]; //存放输入的数字
int a[1010]; //存放全排列 
int b[1010]; //标记数组

void dfs(int t) {
	//递归出口
	if (t == n) {
		for (int i = 0; i < n; i++) {
			cout << a[i] << " ";
		}
		cout << endl;
		return;
	}
	
	//递归条件
	for (int i = 0; i < n; i++) {
		if (!b[i]) {
			if (i > 0 && num[i] == num[i - 1] && b[i - 1] == 1) continue; //剪枝判断 
			a[t] = num[i];
			b[i] = 1;
			dfs(t + 1);
			b[i] = 0;
		}
	}
}

int main()
{
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> num[i];
	}
	sort(num, num + n); //为了全排列输出美观，这里我们将输入数字进行排序
	dfs(0);
	return 0;
}

走迷宫

输入n,m,表示迷宫有n行m列
输入起点startx,starty,终点endx,endy
输入n行m列的迷宫，1表示空地，2表示障碍物
输出从起点到终点的最短步数

#include<bits/stdc++.h>
using namespace std;

int n, m; //n行m列 
int startx, starty, endx, endy; //起点，终点
int a[1010][1010]; //存放迷宫地图 
int b[1010][1010]; //标记数组
int d[4][2] = {{-1, 0},{1, 0},{0, -1},{0, 1}}; //上下左右 
int ans = 999999; //记录最少步数 

void dfs(int x, int y, int t) { //t表示走过多少步
	//递归出口 
	if (x == endx && y == endy) {
		ans = min(ans, t);
		return;
	}
	
	//递归条件
	for (int i = 0; i <= 3; i++) {
		int nextx = x + d[i][0];
		int nexty = y + d[i][1];
		if (!b[nextx][nexty] && a[nextx][nexty] == 1) {
			b[nextx][nexty] = 1;
			dfs(nextx, nexty, t + 1);
			b[nextx][nexty] = 0;
		}
	} 
}

int main()
{
	cin >> n >> m;
	cin >> startx >> starty >> endx >> endy;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			cin >> a[i][j]; //1代表空地，2代表障碍物 
		}
	}
	b[startx][starty] = 1; //起点肯定已经被走过了
	dfs(startx, starty, 0);
	cout << ans << endl; 
	return 0; 
}

队列做法???/???

方格取数

P7074 [CSP-J2020] 方格取数

dfs做法

#include<bits/stdc++.h>
using namespace std;

int n, m;
int a[1010][1010]; //存放输入数字 
int b[1010][1010]; //标记数组
int d[3][2] = {{-1, 0},{1, 0},{0, 1}}; //上下右 
long long ans = -0xfffffff; //最大和 

void dfs(int x, int y, long long t) { //t表示从起点走到(x,y)为止所算出的和 
	//递归出口 
	if (x < 1 || y < 1 || x > n || y > m) { //跑到地图外面了 
		return;
	}
	if (x == n && y == m) { //到终点了 
		ans = max(ans, t);
		return;
	}
	
	//递归条件
	for (int i = 0; i < 3; i++) {
		int nextx = x + d[i][0];
		int nexty = y + d[i][1];
		if (!b[nextx][nexty]) {
			b[nextx][nexty] = 1;
			dfs(nextx, nexty, t + a[nextx][nexty]);
			b[nextx][nexty] = 0;
		}
	} 
}

int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			cin >> a[i][j];
		}
	}
	b[1][1] = 1; //左上角肯定走过了
	dfs(1, 1, a[1][1]);
	cout << ans << endl;
	return 0; 
}

dfs做法是不能AC这道题的，只能拿25分，因为dfs复杂度太高，要想AC这道题应该用dp去做。

dp做法

待更…

素数环问题

从1到20这20个数摆成一个环，要求相邻的两个数的和是一个素数。
输出所有的这种素数环。

#include<bits/stdc++.h>
using namespace std;

int a[25]; //存放素数环 
int b[25]; //记录数组 

bool isPrime(int num) {
	if (num == 1) return false;
	if (num == 2) return true;
	for (int i = 2; i * i <= num; i++) {
		if (num % i == 0) return false; 
	} 
	return true;
} 

void dfs(int t) { //t表示已经填了t个数字了 
	//递归出口 
	if (t == 20) { //到目前为止已经选了20个数字了 
		if (isPrime(a[1] + a[20])) {
			for (int i = 0; i < 20; i++) cout << a[i] << " ";
			cout << endl;
		}
		return;
	} 
	
	//递归条件
	for (int i = 1; i <= 20; i++) {
		if (!b[i] && isPrime(i + a[t - 1])) {
			a[t] = i;
			b[i] = 1;
			dfs(t + 1);
			b[i] = 0;
		}
	} 
}

int main()
{
	dfs(0);
	return 0;
}

数独

在这里插入图片描述
同一行不能有重复数字、同一列不能有重复数字、3×3格子内不能有重复数字。
请把已给的未填满的九宫格填满。

#include<bits/stdc++.h>
using namespace std;

int a[15][15]; //九宫格 

bool check(int x, int y, int num) {
	//检查同一行、同一列
	for (int i = 1; i <= 9; i++) {
		if (a[x][i] == num) return false;
		if (a[i][y] == num) return false;
	} 
	
	//检查小九宫格
	for (int i = (x - 1) / 3 * 3 + 1; i <= ((x - 1) / 3 + 1) * 3; i++) {
		for (int j = (y - 1) / 3 * 3 + 1; j <= ((y - 1) / 3 + 1) * 3; j++) {
			//这里i和j的范围比较麻烦，要稍微算一下 
			if (a[i][j] == num) return false;
		}
	} 
	return true;
}

void dfs(int x, int y) {
	//递归出口
	if (x == 10) {
		cout << endl;
		for (int i = 1; i <= 9; i++) {
			for (int j = 1; j <= 9; j++) {
				cout << a[i][j] << " ";
			}
			cout << endl;
		}
		return;
	}
	
	//递归条件
	if (a[x][y] == 0) { //如果是空地 
		//cout << "???" << endl;
		//那就考虑填哪个数字
		for (int i = 1; i <= 9; i++) {
			if (check(x, y, i)) {
				a[x][y] = i;
				dfs(x + y / 9, y % 9 + 1); //按照从上到下、从左到右的顺序遍历九宫格 
				a[x][y] = 0;
			}
		} 
	} 
	else { //如果不是空地 
		dfs(x + y / 9, y % 9 + 1);
	}
}

int main()
{
	//构造初始九宫格
	for (int i = 1; i <= 9; i++) {
		for (int j = 1; j <= 9; j++) {
			cin >> a[i][j];
		}
	}
	//填充九宫格
	dfs(1, 1);
	return 0; 
}

样例输入输出：
在这里插入图片描述

n皇后

输入n，然后你现在有一个n×n的方格，n个皇后要放在这些方格中，且她们两两不在一行、不在一列、不在一条对角线上。
输出有多少种放法。

#include<bits/stdc++.h>
using namespace std;

int n;
int ans;
int a[100]; //第i行的皇后在第a[i]列 

bool check(int t, int col) { //判断第t行、第col列能不能放皇后 
	for (int i = 1; i <= t; i++) { //遍历前t行 
		if (a[i] == col) return false; //检查同列 
		if (t - col == i - a[i]) return false; //检查正对角线
		if (t + col == i + a[i]) return false; //检查负对角线 
	}
	return true;
}

void dfs(int t) { //t表示前 t - 1 行的皇后位置已经确定了，即将确定第 t 行的皇后位置
	//递归出口
	if (t == n + 1) {
		ans++;
		return;
	} 
	
	//递归条件
	for (int col = 1; col <= n; col++) {
		if (check(t, col)) {//如果第t行、第col列可以放皇后 
			a[t] = col;
			dfs(t + 1);
			a[t] = 0; 
		}
	} 
}

int main()
{
	cin >> n;
	dfs(1);
	cout << ans << endl;
	return 0;
}

马走日

在这里插入图片描述马在某点可以走的八个方向：
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;

int t;
int n, m, x, y;
int ans; //方案总数 
int a[10][10]; //棋盘，值为0代表没有走过，值为1代表已经走过了 
int d[8][2] = {{-1, -2}, {-2, -1}, {-2, 1}, {-1, 2}, {1, 2}, {2, 1}, {2, -1}, {1, -2}}; //方向数组

void dfs(int x, int y, int t) { //t代表即将会走第t步 
	//递归出口
	if (t == n * m) { //所有点都走过了 
		ans++;
		return; 
	} 
	
	//递归条件
	for (int i = 0; i < 8; i++) {
		int nextx = x + d[i][0];
		int nexty = y + d[i][1];
		if (nextx >= 0 && nexty >= 0 && nextx <= n - 1 && nexty <= m - 1 && !a[nextx][nexty]) {
			//在棋盘内并且没有走过
			 a[nextx][nexty] = 1;
			 dfs(nextx, nexty, t + 1);
			 a[nextx][nexty] = 0;
		}
	} 
} 

int main()
{
	cin >> t;
	for (int i = 0; i < t; i++) {
		//初始化工作 
		ans = 0;
		memset(a, 0, sizeof(a));
		
		//输入 
		cin >> n >> m >> x >> y;
		
		//深搜并输出 
		a[x][y] = 1; //这里一定要记得写 
		dfs(x, y, 1);
		cout << ans << endl;
	}
	return 0;
}

算岛屿面积（染色问题）

小S得到一张不完整的钓鱼岛航拍地图。
钓鱼岛由一个主岛和一些附属岛屿组成，小S决定去钓鱼岛探险。下面这个10*10的二维矩阵就是钓鱼岛的航拍地图。图中数字表示海拔，0表示海洋，1-9表示陆地。小S的飞机将会降落在(x, y)处，现在需要计算出小S降落所在岛屿的面积(即有多少个格子)。注意此处我们把与小S降落点上下左右相连接的陆地均视为同一岛屿。
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;

int n, m, x, y;
int a[100][100]; //地图
int b[100][100]; //标记数组 
int d[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; //上下左右 
int ans; //面积

void dfs(int x, int y) {
	for (int i = 0; i < 4; i++) {
		int nextx = x + d[i][0];
		int nexty = y + d[i][1];
		if (nextx > 0 && nexty > 0 && nextx <=n && nexty <= m && !b[nextx][nexty] && a[nextx][nexty]) {
			//在地图内、没走过、是陆地
			ans++;
			b[nextx][nexty] = 1;
			dfs(nextx, nexty);
			//这里不需要写标记数组的还原 
		}
	}
} 

int main()
{
	cin >> n >> m >> x >> y; 
	b[x][y] = 1; //初始点肯定走过了 
	ans = a[x][y]; //初始点的面积得算上 
	dfs(x, y);
	cout << ans << endl;
	return 0;
}

dfs模板

在这里插入图片描述

总结

在这里插入图片描述

_Lyang_
关注
  • 3
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
附近地点搜索算法的几种实现方式
ZOUXUE7的博客
06-19 1270
      基于LBS的应用在眼下已是如火如荼，地理位置功能都相应的被添加在各大应用中，基本上算是作为了行业的标杆。最近开发的一个应用也是涉及到对用户发表帖子的当前位置下的附近帖子的搜索，类似的搜索功能其实也不是什么新鲜事，但是貌似都没有公布其实现，所以当时也是非常的茫然。      想法一：      最容易想到的肯定就是给定范围然后直接全库搜索，但是一旦数据量过大，性能肯定下降得非常快，所...
C/C++实现二值图像连同区域搜索
junjun2009130434的博客
08-20 1662
背景说明 自身项目需要通过C语言实现二值图像轮廓及连通区域（外区域）搜索，后期整理网上资料，发现大部分是通过OpenCV，matlab等接口函数实现，但也有通过堆栈方法实现，不过代码量较多，后面综合评估，决定动手重新设计该算法；经过短期的调试，现整理出实现算法和代码如下； 算法思想 （1）依次遍历图像的每个像素（本算法以列优先搜索），若BinaryDiff[row][col]为1，则...
基本搜索算法
qq_42523037的博客
10-28 1553
基本搜索算法 1、 递归与迭代 递归程序设计是编程语言设计中的一种重要的设计方法，它使许多问题简单化，易于求解。递归的特点：函数或过程直接的或间接的调用它们自己本身。 所谓迭代，就是在程序中用同一个变量存放每一次推算出的值，每一次循环都执行同一语句，给同一变量赋以新值，即用一个新值代替旧值。 2、 深度优先搜索与广度优先搜索 深度搜索与广度搜索的控制结构和产生系统很相似，唯一的区别在于对扩展结...
算法练习（八）区域搜索
qq_44648936的博客
02-27 343
广度优先搜索
算法-区域和检索
老头儿ii的博客
08-21 482
题目一：数组不可变 代码 class NumArray { private int[] arr; public NumArray(int[] nums) { arr = new int[nums.length + 1]; for(int i = 0; i < nums.length; i++) { arr[...
6-2算法DFS1
08-03
在题目中，给出的"6-2算法DFS1"是针对图的深度优先遍历的一种迭代实现。 首先，我们需要理解图的基本概念。在图中，每个节点（或顶点）可以与其他一个或多个节点相连，这些连接被称为边。图可以是无向的，即边没有...
python深度优先搜索算法DFS
最新发布
05-22
深度优先搜索（DFS）是一种用于遍历或搜索树或图的算法。在这种算法中，我们会沿着一个分支走到底，直到该路径上的最后一个节点被访问，然后回溯并沿着另一条路径走到底，这个过程会一直重复，直到所有的节点都被...
DFS.rar_dfs算法习题
09-20
DFS，全称深度优先搜索（Depth-First Search），是一种经典的图论或树遍历算法，广泛应用于解决计算机科学中的各种问题，例如寻找图中的环、判断连通性、求最短路径等。在这个"DFS.rar_dfs算法习题"压缩包中，包含的...
DFS.rar_dfs算法代码
09-20
深度优先搜索（DFS，Depth-First Search）是一种用于遍历或搜索树或图的算法。在图论中，DFS主要用于确定两个节点之间是否存在路径。它从根节点开始，沿着某一条边向下探索，直到到达叶节点或者遇到一个未曾访问过的...
基于python的深度优先搜索算法DFS设计与实现
05-01
深度优先搜索（Depth-First Search, DFS）是一种用于遍历或搜索树或图的算法，其基本思想是尽可能深地探索树的分支。在Python中实现DFS，我们可以利用递归或者栈来达到目的。本篇文章将详细介绍如何在Python中设计和...
定向闭环区域搜索算法
09-09
为arx2010程序，定向闭环区域搜索算法，识别最小区域
基于局部限定搜索区域的特征匹配算法
10-16
提出一种局部限定搜索区域的特征匹配算法，将空间约束与局部描述符结合起来。该算法在ASIFT算法基础之上，针对在特征匹配阶段直接去除一对多、多对一的特征点的缺陷做出了改进。由于这些被去掉的特征点中有很多是可以得到正确匹配的，导致获得到的匹配点对少了很多，通过在已经匹配的点对的周围限定区域内寻找出新的未曾匹配的点对，最终达到提升正确匹配数量的目标。经实验验证，所提出的局部限定搜索区域的特征匹配算法相比于ASIFT算法能大量增加特征匹配点的数量。
群体区域搜索算法
01-14
<p>借鉴自然界群居生物的搜索行为模式, 提出一种群体区域搜索算法. 该算法在优化过程中逐步收缩个体搜</br> 索半径并进行适度随机调整, 引入巡游追随机制, 以一种简单而自然的方式有效地实现了算法广域探索能力与局部</br> 开发能力之间的平衡. 算法结构简单、易实现, 易与其他算法相结合. 通过6 个典型测试函数的实验结果表明, 该算法</br> 全局优化能力强、收敛精度高、稳定性好、总体性能优, 适用于复杂函数优化问题的处理.</p>
【Python搜索算法】广度优先搜索（BFS）算法原理详解与应用，示例+代码
qq_35831906的博客
10-16 7008
广度优先搜索（Breadth-First Search，BFS）是一种图遍历算法，用于系统地遍历或搜索图（或树）中的所有节点。BFS的核心思想是从起始节点开始，首先访问其所有相邻节点，然后逐层向外扩展，逐一访问相邻节点的相邻节点，以此类推。这意味着BFS会优先探索距离起始节点最近的节点，然后再逐渐扩展到距离更远的节点。BFS通常用于查找最短路径、解决迷宫问题、检测图是否连通以及广泛的图问题。BFS算法的步骤如下：初始化：选择一个起始节点，将其标记为已访问，并将其放入队列中（作为起始节点）。
C++实现查找连通域
整理ing
11-13 1585
C++实现查找连通域
图像检索新方向，阿里提出区域检索算法｜CVPR 2020
我爱计算机视觉
03-15 1748
点击我爱计算机视觉标星，更快获取CVML新技术本文转载自机器之心。机器之心发布机器之心编辑部近日，计算机视觉顶会 CVPR 2020 接收论文结果公布，从 6656 篇有效投稿中录取了 ...
记录一个百度地图的矩形区域搜索算法
热门推荐
捉虫大仙里
07-01 1万+
矩形区域其实就是x、y左右每次加一定数值，矩形有四个坐标。 例如深圳地区的矩形区域是：22.449954,22.866712,113.757547,114.640617 然后每次从22.449954增加0.01一直到22.866712 113.757547增加0.01一直到114.640617， 两个循环组合出来的集合的所有坐标都遍历一遍。 List<string> ur...
栅格地图中自由区域之Bresenham算法及个人搜索算法对比
weixin_41518014的博客
07-01 1193
栅格地图中的区域可以分为三种Occupied被占用（有障碍）， Free自由区域（无障碍）， Unknown Space未知区域。 栅格地图的 假设图1，中黄色代表机器人，显眼的绿色代表激光雷达，红色线代表一条激光线束，黑色栅格A代表被激光雷达击中的障碍物。 1.Occupied被占用，可以理解为是障碍物上的点，高于地面，对机器人运动过程有影响的一些栅格，具体是计算后概率大的那些栅格。图1中为黑色栅格A； 2.Free自由区域（无障碍）为图中灰色的栅格，此区域内激光雷达线直接穿过，本文主要是算这.
区域生长算法_RRT 搜索算法及仿真测试
weixin_39634884的博客
11-21 586
RRT exploration原理：基本框架RRT exploration是基于RRT路径规划算法实现的搜索算法。之所以使用RRT算法是因为RRT对于未知区域有着强烈的倾向，在RRT exploration中，RRT主要用于生成边界点，这样对于探索边界点是很有好处的。所谓的边界点就是已经探索过的和未知的区域的交界点，在这里做一个定义:对于所有的区域，如果是探索过的，没有障碍物的区域记为0，有障碍物...
搜索算法入门：BFS与DFS深度解析
"本文主要介绍了搜索算法的基础概念，特别是两种常用搜索策略——深度优先搜索（DFS）和宽度优先搜索（BFS），并结合迷宫问题进行了深入解析。这两种搜索方法在编程解题和实际问题中都有广泛应用。" 深度优先搜索...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值