深度优先搜索(DFS)和广度优先搜索(BFS)

最新推荐文章于 2024-09-28 23:00:16 发布
最新推荐文章于 2024-09-28 23:00:16 发布
阅读量1.7w 收藏 130
点赞数 52
分类专栏： 蓝桥杯 # 搜索 文章标签： 算法 java c++ dfs bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GD_ONE/article/details/104189342
版权

DFS和BFS

基础算法合集：
https://blog.csdn.net/GD_ONE/article/details/104061907

摘要

本文主要介绍 深度优先搜索和广度优先搜索，下文皆称为DFS和BFS。

DFS和BFS是两种搜索树和图的基本策略，见名知其义， 深搜和广搜，一种往深处搜，一种往边上搜。 DFS常用于暴力搜索所有状态，BFS常用于搜索到达某一状态的最短路径。

状态

我们将DFS和BFS搜索的东西称为状态， 状态就是一个具体问题的一个解，而将问题的所有状态关联在一起， 就能得到一个状态图，DFS和BFS就是遍历状态图的两种方式。

下面以几个具体问题来加以解释：

  1. 输出123的全排列

    对于此题，将123数列的三个位置看作三个状态，当3个位置都填满数字时，就是其中一种排列，显然，答案就是所有当搜索完所有位置的所有状态。那么我们就可以使用DFS来找出所有状态。
    部分状态图：

在这里插入图片描述
以上状态图中， 蓝色箭头是DFS的搜索顺序，对以上状态图的解释：对于第一位，有3种状态，1 2 3， 先选1， 然后看第二位， 1已经选过了，只能选2，3，选择2， 然后第三位就只剩下了3， 得到123，然后再将第二位选择为3， 则第三位为2， 得到132.
可以看到，状态图是树形结构。一个状态总能从根节点(起始状态)转移得到。

  1. 用一个3*3的二维矩阵代表一个迷宫，由0，1组成，1代表可以通过，0代表不能通过。要求找出从入口(1,1)到出口(n,n)的最短路径

    对于此题，每个可以从入口到达的点，都是一个状态，那么从一层一层的搜，到达出口时的层数就是最短路径的长度了。

    部分状态图：

在这里插入图片描述
对于以上状态图， X代表当前位置， 1 2 3代表BFS搜索的层数， 当搜索完第 1 层，搜索第 2 层，第 2 层搜索完才会搜索第 3 层。

DFS

我们已经知道DFS是沿着当前路径一直搜索下去，直到无路可走，就会返回，这被称为 回溯
我们可以利用递归的方式来实现这一回溯效果。

public class Main{
	public  static int f(int n){
		if(n == 0){
			return n; 
		}
		
		System.out.print(n+"\n");
		f(n-1);
		System.out.print(n+"\n");
		
		return n;
	}
	public static void main(String[] args) throws IOException {
		f(3);
	}
	
}
输出：
3
2
1
1
2
3

函数执行顺序：

  1. main中调用f()函数
  2. n刚开始等于 3， 先输出3 然后调用f(n-1); // 第一层函数
  3. n等于2， 输出2， 然后调用f(n-1) ； // 第二层函数
  4. n等于1， 输出1， 然后调用f(n-1); //第三层函数
  5. n等于0， 返回到上一次函数， 即第三层函数。然后输出1
  6. 然后再返回到第二层， 输出2
  7. 最后返回第一次， 输出1.
  8. f()函数结束。

这就是回溯的实质了。

看一道例题:
Red and Black

在这里插入图片描述
题目大意就是从起始位置@开始走，只能走在 . (黑砖)上面， 不能走在#(红砖)上面，问从@开始最多可以走几块 .(黑砖)。

将每个可以到达的点当作一个状态，搜索所有的状态，就可以得到答案啦。
怎么搜索呢， 只要我们得到下个点的坐标就可以了， 可以朝四个方向走，
所以，当前坐标 + (0,1) 就是向右走， + (1,0)就是向下走， + (0,-1)就是向左走， +(-1, 0)就是向上走。

然后判断一下个点是否超出边界是红砖还是黑砖，如果是黑砖，就搜索下一点，也就是DFS下一个点。
本题也可BFS。

本题坑点: @点也算一个答案。
具体看代码
C++：

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
int x,y,sum=1;
int n,m; // 行   列
int next[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
char map[20][20];
int book[20][20];

void input(int n,int m){ // 读入数据，并记录@坐标
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			cin>>map[i][j];
			if(map[i][j]=='@')
				x=i,y=j;
		} 
	}
}

void dfs(int x,int y){
	for(int i=0;i<4;i++){
		int gx=x+next[i][0];
		int gy=y+next[i][1];
		if(gx>=0&&gx<m&&gy>=0&&gy<n&&book[gx][gy]!=1&&map[gx][gy]=='.'){
			sum++;
			book[gx][gy]=1; // 标记已经走过。则下次不再走这个点
			dfs(gx,gy);
		}
	}
	return;
}

int main()
{
	while(cin>>n>>m&&n||m)
	{
		memset(map,0,sizeof map);
		memset(book,0,sizeof book);
		input(n,m);
		dfs(x,y);
		cout<<sum<<endl;
		sum=1;
	}
	return 0;
}

JAVA：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;

public class Main{
	static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
	static char[][] map = new char[30][30];
	static int[][] vis = new int[30][30];
	static int[][] ne = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
	static int n, m, res = 0;
	public static void dfs(int x, int y){
		vis[x][y] = 1;
		for(int i = 0; i < 4; i++){ //四个方向
			int nx = x + ne[i][0];
			int ny = y + ne[i][1];
			if(nx < 0 || nx >= m || ny < 0 || ny >= n || map[nx][ny] == '#' || vis[nx][ny] == 1){
				continue;
			}
			res++;
			dfs(nx,ny);
		}
	}
	
	public static void main(String[] args) throws IOException{
		while(true){
			
			String s[] = in.readLine().split(" ");
			n = Integer.parseInt(s[0]);
			m = Integer.parseInt(s[1]);
			if(n==0||m==0) break;
			int x = 0, y = 0;
			res = 0;
			for(int i = 0; i < vis.length; i++)
				Arrays.fill(vis[i], 0);
			for(int i = 0; i < m; i++){
				String s1 = in.readLine();
				if(s1.indexOf('@') != -1){
					x = i;
					y = s1.indexOf('@');
				}
				map[i] = s1.toCharArray();
			}
			dfs(x, y);
			out.write((res+1)+"\n");
			out.flush();
		}
	}
	
}

BFS

BFS要先搜索当前状态可以直接到达的所有状态。因为一次只能处理一个状态，所以我们需要按照先后顺序，先将可以到达的所有状态点全部存起来，因为需要满足先后的顺序，所以正好可以利用队列先进先出的特性来存储。

以下是一般的BFS模板

 public static void bfs(int x, int y){
    	q.add(x, y);  //将起点入队
    	vis[x][y] = 1; // 标记已经走过
    	res[x][y] = 0； // 标记起点的步数
    	while(!q.isEmpty()){ // 当队列不空
    		x = q.peek().x; //取出队头元素
    		y = q.peek().y; 
    		q.poll(); //删除队头元素
    		if(x == n-1 && n == m-1) return; // 到达终点
    		for(int i = 0; i < 4; i++){ // 当前点可以到达的下四个方向
    			int nx = x + dx[i]; // 下个点的坐标
    			int ny = y + dy[i]; 
    			if(nx < 0 || nx >= n || ny < 0 || ny >= m || vis[nx][ny] == 1 ) continue; // 下个点不合法
    			else{
    			    res[nx][ny] = res[x][y] + 1; // 到达下一个点的步数为此父结点的步数加1
    			    q.add(new pair(nx,ny));	//下个点合法，入队存储
    			    vis[nx][ny] = 1; // 标记该点已经走过
    			}
    		}
    	}
    }

用走迷宫来解释， 就是先把一个点可以直接到达的所有点存到一个队列里，
然后从这些点里每次出队一个，进行上述操作，直到所有可到达的点都被搜索过。

例题：
走迷宫

在这里插入图片描述
JAVA代码：

import java.io.*;
import java.util.*;


class pair{
	public int x,y;
	pair(int a, int b){
		x = a;
		y = b;
	}
}

public class Main{
    static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
 
    static final int N = 1000;
    static String[][] arr = new String[N][N];
    static int[][] pren = new int[N][N];
    static int[][] vis = new int[N][N];
    static int[][] res = new int[N][N];
    static int[] dx = {-1, 0, 1, 0};
    static int[] dy = {0, 1, 0, -1};
    static int n, m = 0;
    static Queue<pair> q = new LinkedList<>();
    
    public static int Int(String s){ return Integer.parseInt(s);}
    
    
    public static void read() throws IOException{
    	for(int i = 0; i < n; i++){
    		arr[i] = in.readLine().split(" ");
    	}
    }
    public static void bfs(int x, int y)throws Exception{
    	q.add(new pair(x, y));
    	vis[x][y] = 1;
    	res[x][y] = 0;
    	while(!q.isEmpty()){
    		x = q.peek().x;
    		y = q.peek().y;
    		q.poll();
    		for(int i = 0; i < 4; i++){
    			int nx = x + dx[i];
    			int ny = y + dy[i];
    			if(nx < 0 || nx >= n || ny < 0 || ny >= m || vis[nx][ny] == 1 || arr[nx][ny].compareTo("1") == 0) continue;
    			else{
    			    res[nx][ny] = res[x][y] + 1;
    			    q.add(new pair(nx,ny));	
    			    vis[nx][ny] = 1;
    				if(nx == n-1 && ny == m-1) return;
    			}
    		}
    	}
    }
    public static void main(String[] args) throws Exception{
    	String s[] = in.readLine().split(" ");
    	n = Int(s[0]);
    	m = Int(s[1]);
    	read();
    	bfs(0,0);
    	out.write(res[n-1][m-1]+"\n");
    	out.flush();
    }
}

刷题题目集：
POJ 1321 棋盘问题
POJ 2251 Dungeon Master
POJ 3278 Catch That Cow
POJ 3279 Fliptile
POJ 1426 Find The Multiple
POJ 3126 Prime Path
POJ 3087 Shuffle’m Up
POJ 3414 Pots
FZU 2150 Fire Game
UVA 11624 Fire!
POJ 3984 迷宫问题
HDU 1241 Oil Deposits
HDU 1495 非常可乐
HDU 2612 Find a way
题目链接

题目集题解：https://blog.csdn.net/GD_ONE/article/details/100833175

开始刷题吧！

Androids_lost_Sheep
关注
专栏目录
JavaScript中的深度优先遍历(DFS)和广度优先遍历(BFS)
01-08
在JavaScript中，深度优先遍历（DFS，Depth-First Search）和广度优先遍历（BFS，Breadth-First Search）是两种常见的图或树的遍历算法，广泛应用于数据结构和算法中，例如在游戏编程、图论问题解决、网页爬虫等领域...
深度优先搜索（DFS）（算法笔记）
Arabot_的博客
03-22 9658
深度优先搜索是一种枚举所有完整路径以遍历所有情况的搜索方法，总是以“深度”作为前进的关键词。实现方式是有很多，最常见的是递归。深度优先搜索属于搜索问题的一种，当问题可以被描述为“路径搜索”时，就可以采用搜素问题的所有解的方式来进行解决，所以DFS本质还是暴力。深度搜索具有两个关键词，即“岔道口”和“死胡同”，这两个词来源于迷宫问题，这也是搜索问题最原始的表现。当碰到岔道口时，总是以“深度”作为前进的关键词，不碰到死胡同就不回头，因此被称为“深搜”。
蓝桥杯——深搜DFS（看完绝对入门DFS）
m0_47963315的博客
03-15 5698
一文详解DFS，看完绝对入门（附练习题和详解）
【图计算算法‌】深度优先搜索（DFS）算法
最新发布
大雨淅淅的博客
09-28 1777
深度优先搜索算法（Depth-First Search，简称DFS）是一种用于遍历或搜索树或图的算法。该算法沿着树的深度遍历树的节点，尽可能深地搜索树的分支。当节点v的所在边都已被探寻过，搜索将回溯到发现节点v的那条边的起始节点，这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为新的源节点并重复以上过程，直到所有节点都被访问为止。
bfs与dfs的用途与区别
瑶の博客
05-18 7483
1.BFS是用来搜索最短径路的解是比较合适的，比如求最少步数的解，最少交换次数的解，因为BFS搜索过程中遇到的解一定是离根最近的，所以遇到一个解，一定就是最优解，此时搜索算法可以终止。这个时候不适宜使用DFS，因为DFS搜索到的解不一定是离根最近的，只有全局搜索完毕，才能从所有解中找出离根的最近的解。（当然这个DFS的不足，可以使用迭代加深搜索ID-DFS去弥补） 2.空间优劣上，DFS是有优势
DFS与BFS优先搜索算法
qq_65672569的博客
11-10 585
DFS（深度优先搜索）是一种图遍历算法，它从一个起始点开始，一直往下走直到不能再走为止，然后返回到前一个节点，继续探索它的其他分支，直到找到目标节点为止。这种算法通常用于解决“遍历”问题，比如在树中查找所有的叶子节点。要理解DFS，也还可以想象自己在迷宫中寻找所有可行的路径1.首先，你会从起点开始，顺着一条路一直走，直到你走到一个死胡同2.再返回到前一个节点，继续探索其他分支在探索过程中，你可以使用栈来存储已经访问过的节点，以便后续回溯。在DFS中，你可以使用递归或栈来实现深度优先搜索。
深度优先搜索(DFS) 总结(算法+剪枝+优化总结)
热门推荐
HeartFireY的博客
11-10 7万+
深度优先搜索(DFS) 总结(算法+剪枝+优化总结) 本文中会引用部分实例、文献资料来自不同的作者之手，由于资料整理比较困难，转载地址不在文中列举。如有侵权请联系我更换或删除！对于提供题解思路的各位大佬和作者：非常感谢！ 一、前导 定义上的深度优先搜索的思路与树的先序遍历非常相似，是针对图的搜索而提出的一种算法，下面是算法导论上的解释： 在深度优先搜索中，对于最新发现的顶点，如果它还有以此为顶点而未探测到的边，就沿此边继续探测下去，当顶点v的所有边都已被探寻过后，搜索将回溯到发现顶点v有起始点的那些边
DFS+BFS深度+广度优先遍历.cpp
01-17
DFS+BFS深度+广度优先遍历.cpp
算法面试通关40讲完整课件 27-31 深度优先DFS+广度优先BFS
07-06
深度优先搜索（Depth-First Search, DFS）与广度优先搜索（Breadth-First Search, BFS）是图论和算法领域中两种重要的遍历策略，常用于解决各种问题，如搜索路径、判断连通性、拓扑排序等。在面试中，熟练掌握这两种...
python深度优先搜索和广度优先搜索
09-20
Python中的深度优先搜索（DFS, Depth First Search）和广度优先搜索（BFS, Breadth First Search）是图论和数据结构中常见的两种遍历算法，用于遍历或搜索树或图。这两种算法在解决诸如查找路径、检测环路、找出连通...
C#，深度优先搜索（DFS）、广度优先搜索（BFS）算法的源代码与数据可视化
03-18
深度优先搜索（亦称深度优先遍历，Deep First Search，简称DFS），广度优先搜索（亦称广度优先遍历，Breadth First Search，简称BFS）都是很基础的算法，也是大家很熟悉的。算法，又叫宽度优先遍历，或横向优先遍历...
DFS——深度优先搜索
m0_74421524的博客
01-20 3051
深度优先搜索，是一种常用的图遍历算法，用于在图或树数据结构中遍历所有节点。
DFS-深度优先搜索(深搜)
Gaoithe的博客
05-04 1768
先摘一段官话：深度优先搜索（Depth First Search）是搜索的手段之一。它是从某个状态开始，不断的转移状态直到无法转移，然后退回到前一步的状态，继续转移到其他的状态，如此不断的重复，直至找到最终的解。 其大致的过程如下： （1）访问搜索到的未被访问的邻接点； （2）将此顶点标记为已访问节点； （3）搜索该顶点的未被访问的邻接点，若该邻接点存在，则从此 邻接点开始进行同样的访问和...
深搜（DFS）
Huberyxiao的博客
03-21 8826
深度优先搜索——不撞南墙不回头 深搜是作为一种遍历或搜索图和树的算法。 思想：不撞南墙不回头！ 首先选取一个未访问的点作为源节点。从源节点选取一条路一直往下走，沿着当前顶点的边，访问这条路线，直到走不下去为止。这时返回上一顶点，继续试探访问此顶点的其余子顶点，直到当前顶点的子顶点都被访问过，那么，返回上一顶点，继续重复。从而实现遍历。 来个简单的例子模拟DFS的过程： （首先，我们默认优先选择...
广度优先搜索bfs记录节点层数，以二叉树为例
我的博客
06-25 1106
方法一：记录每一层节点的个数 def bfs(root): queue = [root] while queue: n = len(queue) for i in range(n): node = queue.pop(0) if node.left: queue.append(node.left) if node.right: queue.append(node.right) 方法二：记录每个节点的层数 queue = [(root, 0)] while
基础-深度优先搜索（DFS）
Ice_teapoy的博客
02-19 2147
1 深度优先搜索（DFS） 1.1 定义 先说什么是搜索。搜索算法是利用计算机的高性能来有目的的穷举一个问题解空间的部分或所有的可能情况，从而求出问题的解的一种方法。在忽略效率的情况下，没有什么是搜索解决不了的（？ 深度优先搜索（DFS）是基于递归的搜索。 想象你在走迷宫： 1、 这个方向有路可走，我没走过 2、 往这个方向前进 3、 是死胡同（到达了已经走过的地方），往回走，回到上一个路口 4、 重复第一步，直到找着出口 通过这种方式，只要地点的数量是有限的，你就一定可以在有限的时间找到迷宫的出口（或者确
深度优先搜索（DFS）
信息学奥赛学案
09-22 1990
一、关于DFS的一些小概念 DFS可谓是“不撞南墙，不回头”。就像走迷宫一样，选择一条路一直走下去，当撞南墙了，才返回分叉口去试下一条路。 有两个概念需要提前明晰一下： 1、状态：状态一般是指客观现场信息的描述，通常用T表示。一般要注意是指当前状态，用T0表示初始状态，Tn表示终止状态。 2、产生式系统。状态依据产生式规则，转移至另一个状态。它主要体现状态的表示，新状态产生的规则，状态转移三大功能。 重点理解 1、DFS实际上是利用递归进行的暴力搜索，因此，写DFS之前我们要弄清楚枚举对象，这点很关键，枚举
深搜dfs广搜bfs
qq_73221795的博客
11-21 262
dfsbfs
请分析深度优先搜索DFS和广度优先搜索BFS的优缺点。
05-28
深度优先搜索（DFS）和广度优先搜索（BFS）都是常见的图遍历算法，它们各自有优缺点，适用于不同的场景。 DFS 的优点： 1. 实现简单，只需要一个栈来保存遍历路径 2. 对于深度比较小的图，DFS 搜索速度较快 3. 在搜索到目标节点时，DFS 可能会比 BFS 更快找到一条较短的路径 DFS 的缺点： 1. 对于深度较大的图，DFS 可能会出现堆栈溢出的问题 2. DFS 可能陷入局部最优解而无法找到最优解 3. DFS 可能会搜索到无限制的路径上，导致无法结束搜索 BFS 的优点： 1. 对于求最短路径问题，BFS 可以保证第一次搜索到目标节点时，所经过的路径就是最短路径 2. 对于搜索较为稠密的图，BFS 的效率比 DFS 高 3. BFS 可以搜索到所有的路径，而不仅仅是一条路径 BFS 的缺点： 1. 实现比 DFS 复杂，需要使用队列来保存遍历路径 2. 对于深度较大的图，BFS 的空间复杂度较高，需要保存大量节点信息 3. 在搜索到目标节点时，BFS 可能不如 DFS 快速找到一条较短的路径 因此，选择 DFS 还是 BFS，要根据实际问题的特点来决定。如果需要搜索最短路径，或者图较为稠密，可以选择 BFS。如果图深度较小，或者只需要找到一条路径，可以选择 DFS。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值