算法学习10-搜索与图论01：DFS与BFS

算法学习10：算法学习10：DFS与BFS

---

---

前言

---

---

---

---

要记忆的模版：

// **************************全排列：
int n;
int path[N];//  存储DFS的路径：也是全排列的结果 
bool st[N];// 判断 当前结点 是否被访问过

void dfs(int u)// 递归 
{
	//走完了 
	if(u == n)// u：递归的深度 n：总共有几层 
	{
		for(int i = 0; i < n; i ++) 
		printf("%d ", path[i]);
		
		printf("\n"); 
		return;
	}
	
	// 遍历
	for(int i = 1; i <= n; i ++)
	{
		if(!st[i])
		{
			path[u] = i;
			st[i] = true;// 递归到下一层 
			dfs(u + 1);
			path[u] = 0;// 回溯 
			st[i] = false;
		}
	 } 
 } 


// *************************n皇后：
char g[N][N];// 存储结果： 满足条件的棋子摆法
bool col[N], dg[N], udg[N]; 
// col：列  dg：正对角线  udg：反对角线 
// 由于我们 按行摆放，所以我们不用 再开一个row数组

void dfs(int u)// 递归 
{
	if(u == n)// 出口 
	{
		for(int i = 0; i < n; i ++) puts(g[i]);
		puts("");
	}
	
	for(int i = 0; i < n; i ++)// 遍历每种情况 
	{
		// 重点理解：y = kx + b 
		if(!col[i] && !dg[i + u] && !udg[i - u + n])
		{
			// u：行  i：列 
			g[u][i] = 'Q';
			col[i] = dg[i + u] = udg[i - u + n] = true;
			dfs(u + 1);
			g[u][i] = '.';// 回溯 
			col[i] = dg[i + u] = udg[i - u + n] = false;
		}
	}
}


// *********************走迷宫：
int n, m;
int g[N][N];// 迷宫地图 
int d[N][N];// 距离，步数 
PII q[N * N];
// 注意prev可能是c++的保留字or别的文件用过了，不可以定义 
PII Prev[N][N];// 队列的元素，移动路径 

 int bfs()
 {
 	int hh = 0, tt = 0;
 	q[0] = {0, 0};
	 
	 memset(d, -1, sizeof d);
	 d[0][0] = 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;// 当前位置举例+1 
	 			Prev[x][y] = t;
	 			q[++ tt] = {x, y};// 对尾插入元素 
			 }
		 }
	  } 
	  
	  int x = n - 1, y = m - 1;
	  while(x || y)
	  {
	  	cout << x << ' ' << y << endl;
	  	auto t = Prev[x][y];
	  	x = t.first, y = t.second;
	  }
	  
	 return d[n - 1][m - 1];
 }

---

提示：以下是本篇文章正文内容：

一、DFS

1.例题1：全排列问题

---

---

---

给一个整数n，将1~n排成一排，请按字典序，输出所有的排列方式。

---

// 给一个整数n，将1~n排成一排，请按字典序，输出所有的排列方式。
#include <iostream>

using namespace std;

const int N = 10;

int n;
int path[N];//  存储DFS的路径：也是全排列的结果 
bool st[N];// 判断 当前结点 是否被访问过

void dfs(int u)// 递归 
{
	//走完了 
	if(u == n)// u：递归的深度 n：总共有几层 
	{
		for(int i = 0; i < n; i ++) 
		printf("%d ", path[i]);
		
		printf("\n"); 
		return;
	}
	
	// 遍历
	for(int i = 1; i <= n; i ++)
	{
		if(!st[i])
		{
			path[u] = i;
			st[i] = true;// 递归到下一层 
			dfs(u + 1);
			path[u] = 0;// 回溯 
			st[i] = false;
		}
	 } 
 } 

int main()
{
	cin >> n;
	
	dfs(0);
	
	return 0;
}

---

---

2.例题2：n皇后问题

---

---

n皇后问题：将n个皇后放在n*n的国际象棋棋盘上，是的皇后不能相互攻击到。即任意两个皇后都不能出于同一行，同一列或同一斜线上。
给定整数n，请你输出所有的满足条件的棋子摆法。

---

//n皇后问题：将n个皇后放在n*n的国际象棋棋盘上，皇后不能相互攻击到
//即任意两个皇后都不能出于同一行，同一列或同一斜线上。
//给定整数n，请你输出所有的满足条件的棋子摆法。
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 20;

int n;
char g[N][N];// 存储结果： 满足条件的棋子摆法
bool col[N], dg[N], udg[N]; 
// col：列  dg：正对角线  udg：反对角线 
// 由于我们 按行摆放，所以我们不用 再开一个row数组

void dfs(int u)// 递归 
{
	if(u == n)// 出口 
	{
		for(int i = 0; i < n; i ++) puts(g[i]);
		puts("");
	}
	
	for(int i = 0; i < n; i ++)// 遍历每种情况 
	{
		// 重点理解：y = kx + b 
		if(!col[i] && !dg[i + u] && !udg[i - u + n])
		{
			// u：行  i：列 
			g[u][i] = 'Q';
			col[i] = dg[i + u] = udg[i - u + n] = true;
			dfs(u + 1);
			g[u][i] = '.';// 回溯 
			col[i] = dg[i + u] = udg[i - u + n] = false;
		}
	}
}

int main()
{
	cin >> n;
	// 初始化 
	for(int i = 0; i < n; i ++)
		for(int j = 0; j < n; j ++)
			g[i][j] = '.';
	
	dfs(0);
	
	return 0;
 } 

---

---

另外一种解法：不按行遍历

---

---

#include <iostream>
#include <cstring> 

using namespace std;

const int N = 20;

int n;
char g[N][N];
bool row[N], col[N], dg[N], udg[N];
// 由于我们不是 按行摆放，所以我们要 再开一个row数组

// x：横 y：纵 s：皇后放置好的个数 
void dfs(int x, int y, int s)
{
	if(s > n) return;
	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); 
	 
	 // 放皇后 
	 // 注意1：这个条件没有理解！！！ 
	 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()
{
	cin >> n;
	for(int i = 0; i < n; i ++)
		for(int j = 0; j < n; j ++)
			g[i][j] = '.';
			
	dfs(0, 0, 0);
	
	return 0;
}

---

---

二、BFS

1.例题：走迷宫问题：

---

---

---

---

//走迷宫：给定n*m的二维数组，表示一个“迷宫”，
//数组中只包含0或1，其中0表示可以走的路，1表示不可通过的墙壁。
//最初，有一个人位于左上角（1,1）出，
//每次可以向上，下，左，右任意一个方向移动一个位置。
//数据保证（1,1）出和（n，m）处的数字为0，且一定存在一条通路。
//求：从左上角到有下角的最少移动次数。

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

typedef pair<int, int> PII;// pair：用于将两个数据元素组合成一个单一的对象。

const int N = 110;

int n, m;
int g[N][N];// 迷宫地图 
int d[N][N];// 距离，步数 
PII q[N * N];
// 注意prev可能是c++的保留字or别的文件用过了，不可以定义 
PII Prev[N][N];// 队列的元素，移动路径 

 int bfs()
 {
 	int hh = 0, tt = 0;
 	q[0] = {0, 0};
	 
	 memset(d, -1, sizeof d);
	 d[0][0] = 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;// 当前位置举例+1 
	 			Prev[x][y] = t;
	 			q[++ tt] = {x, y};// 对尾插入元素 
			 }
		 }
	  } 
	  
	  int x = n - 1, y = m - 1;
	  while(x || y)
	  {
	  	cout << x << ' ' << y << endl;
	  	auto t = Prev[x][y];
	  	x = t.first, y = t.second;
	  }
	  
	 return d[n - 1][m - 1];
 }
 

int main()
{
	cin >> n >> m;
	
	for(int i = 0; i < n; i ++)
		for(int j = 0; j < m; j ++)
			cin >> g[i][j];
			
	cout << bfs() << endl; 
	
	return 0;
}

---

---

总结

提示：这里对文章进行总结：

💕💕💕