搜索（DFS BFS）

Zo_ee

已于 2023-05-30 17:50:42 修改

阅读量89

点赞数 4

文章标签：深度优先宽度优先算法

于 2023-05-29 20:05:22 首次发布

本文链接：https://blog.csdn.net/Zo_ee/article/details/130935514

版权

DFS深度优先遍历

842. 排列数字

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

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

输入格式
共一行，包含一个整数 n。
输出格式
按字典序输出所有排列方案，每个方案占一行。
输入样例：
3
输出样例：
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

思路：

用 path 数组保存排列，当排列的长度为 n 时，已是一种方案，则输出。

用 state 数组表示数字是否用过。当 state[i] 为 true时：i 已经被用过，state[i] 为 0 时，i 没有被用过。

dfs(i) 表示的含义是：在 path[i] 处填写数字，然后递归的在下一个位置填写数字。

回溯（恢复现场）：第 i 个位置填写某个数字的所有情况都遍历后，第 i 个位置填写下一个数字。

#include <bits/stdc++.h>

using namespace std;

const int N = 10;

int path[N], n;
bool state[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 (! state[i])         //该数字没有被使用
        {
            path[u] = i;        //将该数字填入当前位置
            state[i] = true;    //标记该数字已经使用过
            dfs(u + 1);         //处理下一个位置
            state[i] = false;   //回溯恢复现场
        }
    }
}

int main()
{
    cin >> n;
    
    dfs(0);         //从第0个位置开始处理
    
    return 0;
}

843. n-皇后问题

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

输入格式
共一行，包含整数 n。

输出格式
每个解决方案占 n 行，每行输出一个长度为 n 的字符串，用来表示完整的棋盘状态。
其中 . 表示某一个位置的方格状态为空，Q 表示某一个位置的方格上摆着皇后。
每个方案输出完成后，输出一个空行。
输出方案的顺序任意，只要不重复且没有遗漏即可。

输入样例：
4
输出样例：
.Q..
...Q
Q...
..Q.

..Q.
Q...
...Q
.Q..

#include <iostream>

using namespace std;

const int N = 10;
int n;
char g[N][N];
bool col[N], dg[N], udg[N];   //col表示该列，dg表示对角线，udg反对角线是否已有Q

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 ++)
    {
        if (!col[i] && !dg[n - u + i] && !udg[u + i])
        {
            g[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;        //恢复现场
            g[u][i] = '.';                                      //恢复现场
        }
    }
}

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

BFS宽度优先遍历

844. 走迷宫

给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁。
最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。
请问，该人从左上角移动至右下角 (n,m) 处，至少需要移动多少次。
数据保证 (1,1) 处和 (n,m) 处的数字为 0，且一定至少存在一条通路。
输入格式
第一行包含两个整数 n 和 m。
接下来 n 行，每行包含 m 个整数（0 或 1），表示完整的二维数组迷宫。
输出格式
输出一个整数，表示从左上角移动至右下角的最少移动次数。
输入样例：
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 <bits/stdc++.h>

#define x first
#define y second

using namespace std;

typedef pair<int, int> PII;     //记录坐标

const int N = 110;

int n, m;
int g[N][N], d[N][N];           //g存储迷宫，d记录当前点距起点的最小距离
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};   //上右下左四个方向

void bfs()
{
    memset(d, -1, sizeof d);                //将所有点初始化，表示还未遍历
    d[0][0] = 0;                            //起点距离起点距离为0
    queue<PII> q;
    q.push({0, 0});                         //将起点加入队列
    
    while (q.size())
    {
        PII t = q.front();                  //取出队头
        q.pop();
        
        for (int i = 0; i < 4; i ++)        //遍历当前点的四个方向
        {
            int a = t.x + dx[i], b = t.y + dy[i];
            if (a < 0 || a >= n || b < 0 || b >= m || d[a][b] != -1 || g[a][b]) continue;
            d[a][b] = d[t.x][t.y] + 1;      //将第一次遍历到可达的点距离更新
            q.push({a, b});                 //将该点加入队列
        }
    }
} 

int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i ++)
        for (int j = 0; j < m; j ++)
            scanf("%d", &g[i][j]);
            
    bfs();
    
    cout << d[n - 1][m - 1];
    
    return 0;
}

845. 八数码

在一个 3×3 的网格中，1∼8 这 8 个数字和一个 x 恰好不重不漏地分布在这 3×3 的网格中。
例如：
1 2 3
x 4 6
7 5 8
在游戏过程中，可以把 x 与其上、下、左、右四个方向之一的数字交换（如果存在）。
我们的目的是通过交换，使得网格变为如下排列（称为正确排列）：
1 2 3
4 5 6
7 8 x
例如，示例中图形就可以通过让 x 先后与右、下、右三个方向的数字交换成功得到正确排列。
交换过程如下：
1 2 3 1 2 3 1 2 3 1 2 3
x 4 6 4 x 6 4 5 6 4 5 6
7 5 8 7 5 8 7 x 8 7 8 x

现在，给你一个初始网格，请你求出得到正确排列至少需要进行多少次交换。
输入格式
输入占一行，将 3×3 的初始网格描绘出来。
例如，如果初始网格如下所示：
1 2 3
x 4 6
7 5 8
则输入为：1 2 3 x 4 6 7 5 8
输出格式
输出占一行，包含一个整数，表示最少交换次数。
如果不存在解决方案，则输出 −1。

输入样例：
2 3 4 1 5 x 7 6 8
输出样例
19

算法思路

用一个队列保存当前获得的排列（字符串）

用一个哈希表保存各个排列(字符串)与从开始排列到该排列的交换次数。

从队列中取出队头这个排列，计算出这个排列通过交换能得到的所有排列。如果得到的排列是新排列（哈希表中没有这个排列），就把这个新排列放入队尾，哈希表中记录新排列对应的交换次数。

如果在上述过程中得到了结果排列，则输出交换次数，结束。（即是交换次数最小）

如果最终没有得到结果排列。输出-1。

#include <bits/stdc++.h>

using namespace std;

string start, ed = "12345678x";         //ed为正确排列
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

int bfs()
{
    queue<string> q;
    q.push(start);
    unordered_map<string, int> d;       //每一个排列对应的交换次数
    d[start] = 0;
    
    while (q.size())
    {
        string t = q.front();
        q.pop();
        
        int dist = d[t];
        if (t == ed) return dist;
        
        int k = t.find('x');
        int x = k / 3, y = k % 3;           //得到x当前的横纵坐标
        for (int i = 0; i < 4; i ++)        //遍历x的上右下左四个方向
        {
            int a = x + dx[i], b = y + dy[i];
            if (a < 0 || a >= 3 || b < 0 || b >= 3) continue;
            swap(t[k], t[a * 3 + b]);       //将x与该合法位置交换
            if (!d[t])                      //得到新的排列
            {
                d[t] = dist + 1;            //更新该新排列的次数
                q.push(t);                  //将该新排列加入队列
            }
            swap(t[k], t[a * 3 + b]);       //恢复当前排列
        }
    }
    return -1;          //遍历了所有排列还未返回，则没有解
}

int main()
{
    for (int i = 0; i < 9; i ++)        //将3x3的排列转化为字符串
    {
        char c;
        cin >> c;
        start += c; 
    }
    
    cout << bfs();
    
    return 0;
}