BFS/DFS

裂缘冰释

已于 2023-11-07 13:47:34 修改

阅读量1k

点赞数

分类专栏： # 算法基础文章标签： c++ 算法数据结构

于 2022-03-24 12:32:54 首次发布

本文链接：https://blog.csdn.net/qq992338041/article/details/123707975

版权

算法基础专栏收录该内容

17 篇文章 1 订阅

订阅专栏

本文探讨了DFS（深度优先搜索）和BFS（广度优先搜索）在数据结构中的关键概念、应用场景及时间复杂度比较。通过实例代码解析了DFS的回溯和剪枝，以及BFS在最短路径问题中的优势。同时介绍了全排列和皇后问题的不同解决方案，展示了它们的时间复杂度。

摘要由CSDN通过智能技术生成

DFS/BFS

	数据结构	空间
DFS	stack	O(h)	不具有最短性
BFS	queue	O(2^h)	最短路的概念

例如搜这个点，DFS要搜的步数比BFS多

DFS有两个重要概念：回溯、剪枝

DFS

#include <iostream>
const int N = 10;
using namespace std;

int n;
int path[N];
bool st[N];

void dfs(int u)
{
	if(u == n)
	{
		for(int i = 0; i < n; i++) printf("%d", path[i]);
		puts("");
        return;
	}
	for(int i = 1; i <= n; i++)
        if(!st[i])
        {
            path[u] = i;
            st[i] = true;
            dfs(u + 1);
            st[i] = false;
        }
}
int main()
{
	scanf("%d", &n);
	dfs(0);
	return 0;
}

方法一：用全排列的方法，一行一行枚举，看每一行可以放在哪一列

#include <iostream>

const int N = 20;//对角线是个数的二倍减一

using namespace std;

int n;
char g[N][N];
bool col[N], dg[N], udg[N];
//dg、udg为两条对角线 
void dfs(int u)
{
	if(u == n)
	{
		for(int i = 0; i < n; i++) puts(g[i]);
		puts("");
		return;
	}
	for(int i = 0; i < n; i++)
	{
//		两条对角线y = x + b，y = -x + b，对应的截距为b = y - x，b = y + x，但是y - x可能为负，所以要加上一个n，即y - x + n 
		if(!col[i] && !dg[u + i] && ! udg[n - u + i])
		{
			g[u][i] = 'Q';
			col[i] = dg[u + i] = udg[n - u + i] = true;
			dfs(u + 1);
			g[u][i] = '.';
			col[i] = dg[u + i] = udg[n - u + i] = false;
		}
	}
}
int main()
{
	scanf("%d", &n);
	for(int i = 0; i < n; i++)
		for(int j = 0; j < n; j++)
			g[i][j] = '.';
	
	dfs(0);
	
	return 0;
}

疑惑：

为什么不是n + u - i，u不是行吗？不是对应的y坐标吗？

答：一样
为什么全排列题没有在u==n时return

答：漏了
剪枝体现在哪

方法二：一个格子一个格子枚举

#include <iostream>

const int N = 20;//对角线是个数的二倍减一

using namespace std;

int n;
char g[N][N];
bool row[N], col[N], dg[N], udg[N];
//dg、udg为两条对角线 
void dfs(int x, int y, int s)//分别为当前xy坐标、放了几个皇后 
{
	if(y == n) y = 0, x ++;
	if(x == n)
	{
		if(s == n)
		{
			for(int i = 0; i < n; i ++)puts(g[i]);
			puts("");
		}
		return;
	}
	
	//不放皇后
	dfs(x, y + 1, s);
	
	//放皇后
	if(!row[x] && !col[y] && !dg[x + y] && !udg[x - y + n])
	{
		g[x][y] = 'Q';
		row[x] = col[y] = dg[x + y] = udg[x - y + n] = true;
		dfs(x, y + 1, s + 1);
		g[x][y] = '.';
		row[x] = col[y] = dg[x + y] = udg[x - y + n] = false;
	}
}
int main()
{
	scanf("%d", &n);
	for(int i = 0; i < n; i++)
		for(int j = 0; j < n; j++)
			g[i][j] = '.';
	
	dfs(0, 0, 0);
	
	return 0;
}

两种方法的时间复杂度分别是：O(n*n!)、O(2ⁿ2)，第二种效率差一些

BFS

深度搜索没有常用的框架，广度搜索有

只有边权值为1的最短路问题可以用广度搜索，而且一般不用BFS，因为时间复杂度较高，一般用专门的最短路算法来求，如dp

#include <iostream>

#include <string.h>
using namespace std;

const int N = 110;

typedef pair<int, int> PII;
int n,m;
int g[N][N];//存地图
int d[N][N];//存每个点到起点的距离
PII q[N * N];

int bfs()
{
	int hh,tt = 0;//注意tt=0，因为下面初始在队列加入了一个元素
	q[0] = {0, 0};
	memset(d, -1, sizeof(d));
	d[0][0] = 0;
	int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

	while(hh <= tt)
	{
		auto t = q[hh++];
		for(int i = 0; i <4; i++)
		{
			int x = t.first + dx[i], y = t.second + dy[i];
			if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
			{
				d[x][y] = d[t.first][t.second] + 1;
				q[ ++tt] = {x, y};
			}
		}
	}

	return d[n-1][m-1];
}

int main()
{
	scanf("%d%d", &n, &m);
	for(int i = 0; i < n; i ++)
		for(int j = 0; j < m; j++)
			scanf("%d", &g[i][j]);

	printf("%d\n", bfs());
	return 0;
}