acwing算法基础 dfs与bfs

1dfs深度优先搜索，

不撞南墙不回头，空间复杂度是n，不具有最短路效应，适合一些思路比较奇怪，对空间要求高的题目。

2bfs宽度优先搜索

从根节点开始向下一层一层的搜索，具有最短路的特点，适用于需要找最短路的题目

1dfs深度优先搜索

三个数字进行全排列

#include<iostream>
using namespace std;
int n;
const int N = 10;
int path[N];//记录当前路径
bool st[N];//记录对应下表的值是否被使用过
void dfs(int u)//u是当前递归时走到了第几层，即排列了几个数字
{
    if (u == n)//当全都排列完了之后，进行输出//也就是递归结束的循环条件
    {
        for (int i = 0; i < n; i++) cout << path[i] << " ";
        cout << endl;
    }

    for (int i = 1; i <= n; i++)
    {
        if (!st[i])//如果当前下表没有被使用过进行下列操作
        {
            path[u] = i;//将未使用过的i赋值给对应层数的叶节点
            st[i] = true;//改变当前节点的值。
            dfs(u + 1);//递归向下找，并且进行回溯///还需要再看看递归的实现过程
            st[i] = false;
        }
    }
}
int main()
{
    cin >> n;
    dfs(0);
    return 0;
}

2宽度优先搜索bfs 走迷宫，求最优解 使用队列 求有向图的拓扑序

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
typedef pair<int, int> pii;
const int N = 110;
int n, m;
int g[N][N], d[N][N];
int bfs()
{
    queue<pii> q;
    memset(d, -1, sizeof d);
    d[0][0] = 0;
    int dx[4] = { -1, 0, 1, 0 }; int dy[4] = { 0, 1, 0, -1 };
    q.push({ 0, 0 });
    while (q.size())
    {
        auto t = q.front();
        q.pop();
        for (int i = 0; i < 4; i++)
        {
            int x = t.first + dx[i]; int y = t.second + dy[i];
            if (x >= 0 && x < n && y>=0 && y < m && d[x][y] == -1 && g[x][y] == 0)
            {
                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();

    return 0;
}