1. DFS && BFS

1. DFS–深度优先搜索（递归）
2. BFS–宽度优先搜索（队列）
   

1. DFS：

1. 排列数字问题

给定一个整数 n，将数字 1∼n 排成一排，将会有很多种排列方法。

现在，请你按照字典序将所有的排列方法输出。

！要注意的是在到达叶节点后进行回溯时要恢复现场

#include<iostream>
using namespace std;

const int N = 10;

int n;
int path[N];	//存储所要输出的数组
bool st[N];	//标记数字，若在当前的分支上i已经被用过则为true，没用过则为false

void dfs(int u) {	//传进去的u代表开始搜索的节点
	if (u == n) {	//u = n 时代表已经搜索到最后
		for (int i = 0; i < n; i++) {
			cout << path[i] << ' ';
		}
		cout << endl;
		return;
	}

	for (int i = 1; i <= n; i++) {
		if (!st[i]) {	//若没有标记过则进入循环
			path[u] = i;
			st[i] = true;
			dfs(u + 1);	//递归对下一节点进行搜索，直至最后达到u = n 时跳出递归，并在跳出递归的过程中会逐层进行下面的回溯恢复现场操作
			st[i] = false;	//在每一个分支走到最底层回溯的时候要恢复现场
		}
	}
}

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

---

2. n皇后问题

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

解法1;

#include<iostream>
using namespace std;

const int N = 20;
int n;
char q[N][N];	//存储棋盘
bool col[N], dg[N], udg[N];	//col[]为同一列，dg[]为正对角线，udg[]为反对角线

void dfs(int u) {
	if (u == n) {	//当棋盘内存满时输出
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				cout << q[i][j];
			}
			cout << endl;
		}
		cout << endl;
		return;
	}

	for (int i = 0; i < n; i++) {	//此处的i代表的是列数，即列的下标，从第一列往下遍历
		if (!col[i] && !dg[n - u + i] && !udg[u + i]) {
			q[u][i] = 'Q';
			col[i] = dg[n - u + i] = udg[u + i] = true;
			dfs(u + 1);
			col[i] = dg[n - u + i] = udg[u + i] = false;
			q[u][i] = '.';
		}
	}
}

int main() {
	cin >> n;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			q[i][j] = '.';
		}
	}
	dfs(0);
	return 0;
}

tips：稍稍理解，dg[] 和 udg[] 两个一维数组都是在一条数轴上显示对角线，相当于映射，映射至截距处
而对于 u+i 和 n-u+i ，其实就是分别对应一个正对角线一个反对角线
正对角线为 y = x + b ，截距 b = y - x，为防止其为负，则 + n 即b = y - x + n
反对角线为 y = -x + b，截距 b = y + x

---

解法2：
这种方法在进行dfs时，对格盘上的每个点进行分析，分为有皇后和无皇后两种情况，进行分类分析

#include<iostream>
using namespace std;

const int N = 20;

char q[N][N];
bool row[N], col[N], dg[N], udg[N];
int n;

void dfs(int x, int y, int s) {	//用s来记录放了皇后的个数
	if (y == n)	 y = 0, x++;	//当y走到n时即行越界，然后将y返回至0处，x向下走一行，即重新开到了下一行

	if (x == n) {
		if(s == n) {	//当x到n时即到了最后一行，并且所放的皇后的个数等于n时，输出
			for (int i = 0; i < n; i++)	puts(q[i]);	//用puts函数输出一行
			puts("");	//换行
		}
		return;
	}

	//不放皇后
	dfs(x, y + 1, s);	//将y向右移一格即可

	//放皇后
	if (!row[x] && !col[y] && !dg[x + y] && !udg[x - y + n]) {
		q[x][y] = 'Q';
		row[x] = col[y] = dg[x + y] = udg[x - y + n] = true;
		dfs(x, y + 1, s + 1);
		row[x] = col[y] = dg[x + y] = udg[x - y + n] = false;
		q[x][y] = '.';	//恢复现场
	}
}

int main() {
	cin >> n;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			q[i][j] = '.';
		}
	}
	dfs(0, 0, 0);

	return 0;
}

---

2. BFS

1. 走迷宫问题

给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，
其中 0 表示可以走的路，1 表示不可通过的墙壁。

最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。

请问，该人从左上角移动至右下角 (n,m) 处，至少需要移动多少次。

数据保证 (1,1) 处和 (n,m) 处的数字为 0，且一定至少存在一条通路。

解1：数组模拟队列

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

typedef pair<int, int> PII;

const int N = 110;

int n, m;
int g[N][N];	//定义题中的图
int d[N][N];	//定义图中每个点到原点的距离
PII q[N * N];	//手写一个队列，数组模拟队列

int bfs() {
	int hh = 0, tt = 0;
	q[0] = { 0,0 };

	memset(d, -1, sizeof d);	//将d数组中的值都初始化为-1表示未走过，并且memset函数在头文件algorithm中

	d[0][0] = 0;	//将原点初始化代表已经走过

	//定义上下左右四个方向的移动向量
	int dx[4] = { -1,1,0,0 }, dy[4] = { 0,0,-1,1 };

	while (hh <= tt) {	//队列不为空时
		PII 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[][]为0，且之前没有走过即对应的d[][]为-1
				d[x][y] = d[t.first][t.second] + 1;	//移位后到原点的距离加一
				q[++tt] = { x,y };	//将新的坐标入队
			}
		}
	}
	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;
}

代码解读：

1. 维护一个队列来村存储每个点的坐标，并采用 dx[4] 和 dy[4] 数组来模拟点的运动（下标从1遍历到4）
2. 对于深搜，由于每个点都只会使用一次，所以最后得到的距离一定是最短距离
3. 在用数组模拟队列时，hh++是将队头元素弹出，而在本代码中令 t = q[hh++]，即向将队头元素赋给 t 再将队头元素弹出，关于数组模拟队列复习见ztjou.st的数组模拟队列

解2：STL容器队列

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

using namespace std;
const int N = 110;
typedef pair<int, int > PII;

int n, m;
int g[N][N];
int d[N][N];
queue<PII> q;

int bfs() {
	q.push({ 0,0 });
	
	memset(d, -1, sizeof d);

	d[0][0] = 0;
	int dx[4] = { -1,1,0,0 }, dy[4] = { 0,0,-1,1 };

	while (!q.empty()) {
		PII t = q.front();	//用t来作为队头元素的替身进行操作
		q.pop();	//将队头元素弹出以保证每次赋给t的都为队头元素

		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.push({ x,y });	//将新坐标入队,更新坐标
			}
		}
	}
	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;
}

而若想要打印出所走的最短距离的每一步路径，则可添加一个Prev[][]数组来存储某一点是由哪一个点移动来的，即存储上一个点的坐标，最后进行输出即可

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 110;
typedef pair<int, int> PII;
PII q[N*N],Prev[N][N];
int g[N][N], d[N][N];
int n, m;
int bfs()
{
    int hh = 0, tt = 0;
    q[0] = {0, 0};
    memset(d, -1, sizeof d);

    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    d[0][0] = 0;
    while(hh <= tt)
    {
        PII t = q[hh ++ ];
        for(int i = 0; i < 4; i ++ )
        {
            int x = dx[i] + t.first, 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;
                Prev[x][y] = t;
                q[++ tt] = {x, y};
            }
        }
    }
    int x = n - 1, y = m - 1;
    while(x || y)//有一个不d等于0
    {
        cout << x << ' ' << y << endl;
        PII 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;
}