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

文章目录

  • 前言
  • 一、深度优先搜索
    • 1.定义
    • 2.关键
    • 3.文字理解
    • 4.图片理解
    • 5.例题1
    • 6.例题1代码
    • 7.例题2
    • 8.例题2理解
    • 9.例题2代码
  • 二、广度优先搜索
    • 1.定义
    • 2.关键
    • 3.文字理解
    • 4.例题
    • 5.例题代码
  • 总结


前言

本次撰写的内容是深度优先搜索与广度优先搜索
这两三天将会对前几天学习的东西进行一个总结,之后开始写学生管理系统,如果有空闲时间将会继续写周报。


一、深度优先搜索

1.定义

DFS(Depth-First Search):深度优先搜索属于图算法的一种,其过程简要来说是对每一个可能的分支路径深入到不能再深入为止,而且每个节点只能访问一次。

2.关键

深度优先搜索其实是围绕着一词“回溯”展开,我们若是理解了回溯,那么对理解深度优先有十分大的帮助。

因为DFS是一种关于图的算法,所以我们从图的角度展开理解,回溯对于图来说,就相当于对已经走过的路进行新的尝试。

3.文字理解

首先因为DFS是一种关于图的算法,所以笔者在此用文字对其进行简单的描述,后文会通过图片来进一步理解。

深度优先搜索的步骤分为 1.递归下去 2.回溯上来。顾名思义,深度优先,则是以深度为准则,先一条路走到底,直到达到目标。这里称之为递归下去。

否则既没有达到目标又无路可走了,那么则退回到上一步的状态,走其他路。这便是回溯上来

4.图片理解

在此笔者贴出几张丑陋的图片供读者理解。以下是迷宫中一个人运用DFS走到终点的路径:

1.首先向右走

深度优先搜索(BFS)与广度优先搜索(DFS)_第1张图片
2.其次打叉的地方是障碍物,我们走不通,呢么根据方向顺序我们需要尝试向下走,走通了,那么我们可以向下走
深度优先搜索(BFS)与广度优先搜索(DFS)_第2张图片
3.然后我们继续尝试向右
深度优先搜索(BFS)与广度优先搜索(DFS)_第3张图片
4.最后我们一次类推走到终点
深度优先搜索(BFS)与广度优先搜索(DFS)_第4张图片
但是我们显然还要尝试别的走法,那么我们就需要退回去继续尝试,那么这里就要用到我们回溯的思想了

例如我们回溯到下面这步,我们在没回溯此步之前是向下走的,那么我们按照顺序就需要依次尝试向左与向上了,左边是障碍物,上面是我们已经走过的路,那么四个方向都不能走时,我们就需要继续回溯。

在这里有些小伙伴可能会问了,怎么知道我们已经走过哪些路了呢,那么就需要我们额外设立一个数组进行记录,如果下一步要走的路已经在我们记录的路中,那么我们就不会走这一步,同时,当我们回溯到上一步时,也会将数组中此步的坐标删除。
深度优先搜索(BFS)与广度优先搜索(DFS)_第5张图片

5.例题1

我们常常使用深度优先搜索解决迷宫问题,那么我们就以我上面的图为迷宫的原型,问小人走到终点所需的最短步数。

6.例题1代码

在此代码笔者运用了递归的方法,其实用栈也可以实现,因为栈的本质其实就是递归。学习c++后笔者将会考虑补上栈法的代码

# include 

int n, m, p, q;
int min = 888888;
int a[51][51], book[51][51];

//深度优先搜索就是一步步走到底,那么每一步都要尝试上下左右,
//如果第一次向右可以通过那么就进行到下一步,继续按照上下左右寻找,找到可以走的路就继续无路可走或已在路径中就返回

void dfs(int x, int y, int step)
{
	int next[4][2] = { {0,1},{1,0}, {0,-1}, {-1,0} };//顺序是右,下,左,上。

	int tx, ty, k;
	//判断是否到达指定位置
	if (x == p && y == q)
	{
		//更新最小值
		if (step < min)
			min = step;
		return;//请注意这里的返回很重要
		//走到目的地后返回,然后尝试下一个方向。
		//因为我们需要尝试四个方向,所以要需要回溯。
	}

	//枚举四种写法
	for (k = 0; k < 4; k++)
	{
		//计算下一个点的坐标
		tx = x + next[k][0];
		ty = y + next[k][1];

		//判断是否越界
		if (tx<1 || tx>n || ty<1 || ty>m)
			continue;
		//判断该点是否为障碍物或者已经在路径中,已经在路径中就不用重复尝试了
		if (a[tx][ty] == 0 && book[tx][ty] == 0)//等于0就证明可以尝试这个方向
		{
			book[tx][ty] = 1;
			dfs(tx, ty, step + 1);//使用递归开始尝试下一个点的方向。
			book[tx][ty] = 0;//这里就是深度优先搜索的核心回溯,取消上一个点的标记,就像上一个扑克牌算法取走扑克牌一样
		}
	}
	
	return;
}

int main()
{
	int j, i, startX, startY;
	scanf_s("%d %d", &n, &m);//输入迷宫有多少行多少列
	printf("读入迷宫\n");
	for (i = 1; i <= n; ++i)//读入迷宫
		for (j = 1; j <= m; ++j)
			scanf_s("%d", &a[i][j]);//记得i与j的值就是最小值, 起始位置坐标不能小于i与j
	printf("\n");
	printf("读入起点和终点坐标");
	scanf_s("%d %d %d %d", &startX, &startY, &p, &q);

	//从起点开始搜索
	book[startX][startY] = 1;
	//第一个是起始x,第二个是起始y, 初始步数为0
	dfs(startX, startY, 0);
	//打印最短步数。
	printf("%d", min);
	return 0;

}

输入:
5 4 (迷宫行列)
(迷宫地图,1代表障碍物,0代表可以走)
0 0 1 0
0 0 0 0
0 0 1 0
0 1 0 0
0 0 0 1
1 1 4 3(分别为起点与终点坐标)
输出:
7

7.例题2

深度优先搜索(BFS)与广度优先搜索(DFS)_第6张图片
我们以此道例题为例,不过我们将3个盒子变为9个盒子

8.例题2理解

我们将手中空闲的牌按顺序放入盒子中,当放完后便走回上一个盒子取回原来的牌,然后继续按照顺序放入,手中牌放完后就输出盒子中牌的序列

9.例题2代码

# include 
# include 
//深度优先算法的关键在于回溯
//用递归实现
int a[10], book[10], n;

void dfs(int step)//step表示现在站在第几个盒子面前
{
	int i;
	if (step == n + 1)//当面前没有盒子时,则输出序列
	{
		for (i = 1; i <= n; ++i)
			printf("%d", a[i]);
		printf("\n");

		return;//返回之前一步,就是上一步递归的语句

	}

	//此时站在第step个盒子面前,应该放哪张牌呢?
	//按照1,2,3.....n的顺序一一尝试
	for (i = 1; i <= n; i++)
	{
		//首先判断扑克牌是否还在手上,用book数组标记,0就代表不在手上,1就代表在手上
		if (book[i] == 0)
		{
			a[step] = i;//将扑克牌放入盒子里
			book[i] = 1; //标记此牌已经不在手上了

			//下一步就该移动到下一个盒子了
			dfs(step + 1); //要想实现回溯,可以利用栈的先入后出特性,也可以采用递归的方式(因为递归本身就是基于方法调用栈来实现
			book[i] = 0;//因为关键是回溯,所以需要当牌放完后要将刚才尝试的牌取出。
		}
	}
	return;
}

int main()
{
	scanf_s("%d", &n);
	dfs(1);
	return 0;
}

二、广度优先搜索

1.定义

广度优先搜索较之深度优先搜索之不同在于,深度优先搜索旨在不管有多少条岔路,先一条路走到底,不成功就返回上一个路口然后就选择下一条岔路,而广度优先搜索旨在面临一个路口时,把所有的岔路口都记下来,然后选择其中一个进入,然后将它的分路情况记录下来,然后再返回来进入另外一个岔路,并重复这样的操作,用图形来表示则是这样的

2.关键

广度优先搜索关键在于重放,回放是继续遍历先前已经遍历过的结点 。

3.文字理解

广度优先搜索的方式是使用队列,运用重放的方法进行出对入队的操作从而达到目的。
就是对下一步能走通的位置进行入队,已经重放完毕的位置进行出队。

4.例题

深度优先搜索与广度优先搜索都可用于迷宫问题,那么我们依然用迷宫问题作为例题

5.例题代码

# include 
# include 
struct node
{
	int x;
	int y;
	int step;

};

int main()
{
	int m, n;
	int head, tail;
	int lp, lq;
	int a[51][51] = { 0 };//迷宫内的0和1
	int tx, ty;
	
	scanf_s("%d %d", &n, &m);//输入迷宫有多少行多少列
	printf("读入迷宫\n");
	for (int i = 1; i <= n; ++i)//读入迷宫
		for (int j = 1; j <= m; ++j)
			scanf_s("%d", &a[i][j]);//记得i与j的值就是最小值, 起始位置坐标不能小于i与j
	printf("\n");
	printf("读入起点和终点坐标");
	scanf_s("%d %d",  &lp, &lq);


	struct node q[2501];//设置队列的容量
	int next[4][2] = { {0,1},{-1,0},{0,- 1},{1,0} };
	int book[51][51] = { 0 };//初始化存储数组
	head = tail = 1;
	q[tail].x = 1;//起点横坐标;
	q[tail].y = 1;//起点纵坐标;
	q[tail].step = 0;//步数刚开始没走
	tail++;//队列尾部移动
	book[1][1] = 1;
	int flag = 0;//表示是否到达终点
	
	while (head < tail)//当队列不为空时循环
	{
		for (int i = 0; i < 4; i++)//枚举四个方向
		{
			tx = q[head].x + next[i][0];//计算下一个点的坐标,记得是head
			ty = q[head].y + next[i][1];
			if (tx<1 || tx>n || ty<1 || ty>m)
				continue;//判断越界哩
			if (book[tx][ty] == 0 && a[tx][ty] == 0)//不为障碍物且不为已经走过的路
			{
				book[tx][ty] = 1;
				q[tail].x = tx;
				q[tail].y = ty;
				q[tail].step = q[head].step + 1;//步数是重放的步数+1
				tail++;
			}
			if (tx == lp && ty == lq)//终点坐标
			{
				flag = 1;
				break;
			}
		}
		if (flag == 1)
			break;
		head++;//把已经重放的点去除
	}

	printf("%d", q[tail-1].step);
	return 0;

}

总结

深度优先搜索的关键在于回溯与递归(栈)
广度优先搜索的关键在于重放与队列
这两种方法常用于迷宫问题,其实他们的原理并不难,最重要是我们能够理解算法的步骤并对之加深印象

你可能感兴趣的:(深度优先,宽度优先,算法)