- DFS–深度优先搜索(递归)
- 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;
}
代码解读:
- 维护一个队列来村存储每个点的坐标,并采用 dx[4] 和 dy[4] 数组来模拟点的运动(下标从1遍历到4)
- 对于深搜,由于每个点都只会使用一次,所以最后得到的距离一定是最短距离
- 在用数组模拟队列时,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;
}