本文已参与「新人创作礼」活动，一起开启掘金创作之路。

DFS/BFS

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

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

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

DFS

842.排列数字

给定一个整数n，将数字1~n排成一排，将会有很多种排列方法。
现在，请你按照字典序将所有的排列方法输出。

输入格式

共一行，包含—个整数n。

输出格式

按字典序输出所有排列方案,每个方案占一行。

数据范围

$1≤n ≤7$

输入样例:

3

输出样例:

1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

#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(2n2)，第二种效率差一些

BFS

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

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

844.走迷宫

给定一个ntm的二维整数数组，用来表示一个迷宫，数组中只包含0或1，其中0表示可以走的路，1表示不可通过的墙壁。
最初，有一个人位于左上角(1,1)处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。
请问，该人从左上角移动至右下角(n, m)处，至少需要移动多少次。
数据保证(1,1)处和(n, m)处的数字为0，且一定至少存在一条通路。

输入格式

第一行包含两个整数n和m。
接下来n行，每行包含m个整数〔O或1)，表示完整的二维数组迷宫。

输出格式

输出一个整数，表示从左上角移动至右下角的最少移动次数。

数据范围

$1≤n, m ≤100$

输入样例:

5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

输出样例：

8

#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;
}

BFS/DFS

DFS/BFS

DFS

BFS