【C++】广度/深度优先算法（bfs+dfs）理解+例题+对比 --- 未消化

最新推荐文章于 2024-07-20 11:33:52 发布
最新推荐文章于 2024-07-20 11:33:52 发布
阅读量412 收藏 1
点赞数
分类专栏： C/C++ 数据结构|算法|设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bandaoyu/article/details/108212409
版权

例题：
《迷宫问题》
定义一个二维数组：

 

0 0 1 0 1 //0表示可走，1表示墙
0 1 1 1 0 //只能↑↓←→走，不能斜着走
0 0 0 0 0 
0 1 1 1 0
0 0 0 1 0 //题目保证了输入是一定有解的

求从左上角（0，0）到右下角（4，4）的最短路线。

bfs解题核心逻辑伪代码：

 

1，将起点推入队列中；
2，将起点标识为已走过；
while（队列非空）{
  3，取队列首节点vt，并从队列中弹出；
  4，探索上面取出得节点的周围是否有没走过的节点vf，如果有将所有能走的vf的parents指向vt，并将vf加入队列
    （如果vf等于终点，说明探索完成，退出循环）。
}
如果队列为空自然跳出，说明无路可达终点。

实际c++实现：

 

#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<map>
#include<queue>
using namespace std;
struct Node//定义结构体Node
{
    int xx ;//自身处于组内的位置
    int yy;
    bool qiang;//是否是墙
    bool walked;//是否走过
    Node *parents;//指向父节点的指针
};


int main() {
    int id = 0;
    //int xx, yy;
    queue<Node*> bfs;//创建Node指针队列
    vector<vector<Node>> migong;//创建二维迷宫组
    for (int i = 0; i < 5; i++) {
        vector<Node> hang;
        for (int j = 0; j < 5; j++) {
            int ii;
            cin >> ii;
            Node node{ i,j,ii,false};
            hang.push_back(node);
        }

        migong.push_back(hang);
    }
    //输入完毕
    int ax[4] = { -1,1,0,0 };
    int by[4] = { 0,0,1,-1 };
    
    
    bfs.push(&migong[0][0]);//先将起点推进去
    migong[0][0].walked = true;

    Node *vt;//等下指向父节点的指针
    Node *vf;//等下指向父节点引申出的子节点

    while (!bfs.empty()) {
        vt = bfs.front();
        bfs.pop();


        
            if ((*vt).xx >= 1) {//查询左节点是否可以
                vf = &migong[(*vt).xx + ax[0]][(*vt).yy + by[0]];
                if (!(*vf).qiang && !(*vf).walked) {
                    bfs.push(vf);
                    (*vf).walked = true;
                    (*vf).parents = vt;//子节点指向父节点
                    if ((*vf).xx == 4 && (*vf).yy == 4) break;//如果是终点节点，结束寻找，跳出循环。
                }
            }
            if ((*vt).xx <=3  ) {//查询右节点是否可以
                vf = &migong[(*vt).xx + ax[1]][(*vt).yy + by[1]];
                if (!(*vf).qiang && !(*vf).walked) {
                    bfs.push(vf);
                    (*vf).walked = true;
                    (*vf).parents = vt;
                    if ((*vf).xx == 4 && (*vf).yy == 4) break;
                }
            }
            if ((*vt).yy <= 3) {//查询下节点是否可以
                vf = &migong[(*vt).xx + ax[2]][(*vt).yy + by[2]];
                if (!(*vf).qiang && !(*vf).walked) {
                    bfs.push(vf);
                    (*vf).walked = true;
                    (*vf).parents = vt;
                    if ((*vf).xx == 4 && (*vf).yy == 4) break;
                }
            }
            if ((*vt).yy >= 1) {//查询上节点是否可以
                vf = &migong[(*vt).xx + ax[3]][(*vt).yy + by[3]];
                if (!(*vf).qiang && !(*vf).walked) {
                    bfs.push(vf);
                    (*vf).walked = true;
                    (*vf).parents = vt;
                    if ((*vf).xx == 4 && (*vf).yy == 4) break;
                }
            }
        
    }
    

//结束算法，从vf指向的节点开始寻找父节点。
    vector<Node*> fin;
    
    
    while (true) {
        fin.push_back(vf);
        vf = (*vf).parents;
        if ((*vf).xx == 0 && (*vf).yy == 0) {
            fin.push_back(vf);
            break;
        }
        
    }
//输出
    for (int i = fin.size()-1; i >=0;i--) {
        cout << (*fin[i]).xx << "," << (*fin[i]).yy << endl;
    }
    

    return 0;

}


输出示例：
0 0 1 0 1
0 1 1 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
0,0
1,0
2,0
2,1
2,2
2,3
2,4
3,4
4,4

dfs解题核心逻辑伪代码：

 

1，栈初始化
2，获得起点，将起点标识为已走过，将起点入栈
while（栈非空）{
  取栈顶元素vt
  如果vt周围有为走过的节点vf，则：
      将vf改为已走
      vf入栈
  没有能走的节点，vt出栈
}

代码：

 

#include<iostream>
#include<vector>
#include<list>
#include<algorithm>
#include<queue>
#include<string>
#include<stack>
#include<time.h>
#include <windows.h>
#include<set>

using namespace std;

struct Node
{
    int x;
    int y;
    bool walked;
    int g;
    int f;//f = g+h
    int h;
    Node* parents;
};

int main() {
    
    vector<vector<Node>> migong;//创建二维迷宫组
    for (int i = 0; i < 5; i++) {
        vector<Node> hang;
        for (int j = 0; j < 5; j++) {
            int ii;
            cin >> ii;
            Node node{ i,j,ii };
            hang.push_back(node);
        }

        migong.push_back(hang);
    }
    
    
    /*-----------------------------------dfs----------------------------------------------*/
    vector<vector<Node>> migong2 = migong;

    stack<Node*> f;
    f.push(&migong2[0][0]);
    migong2[0][0].walked = true;
    while (!f.empty()) {
        Node *vt = f.top();
        bool can = true;
        if (vt->x >= 1) {
            Node *vf = &migong2[vt->x - 1][vt->y];
            if (vf->walked == false) {
                vf->parents = vt;
                vf->walked = true;
                if (vf == &migong2[4][4]) {
                    break;
                }
                f.push(vf);
                can = false;
            }
        }
        if (vt->x <=3) {
            Node *vf = &migong2[vt->x + 1][vt->y];
            if (vf->walked == false) {
                vf->parents = vt;
                vf->walked = true;
                if (vf == &migong2[4][4]) {
                    break;
                }
                f.push(vf);
                can = false;
            }
        }
        if (vt->y >= 1) {
            Node *vf = &migong2[vt->x][vt->y - 1];
            if (vf->walked == false) {
                vf->parents = vt;
                vf->walked = true;
                if (vf == &migong2[4][4]) {
                    break;
                }
                f.push(vf);
                can = false;
            }
        }
        if (vt->y <= 3) {
            Node *vf = &migong2[vt->x ][vt->y + 1];
            if (vf->walked == false) {
                vf->parents = vt;
                vf->walked = true;
                if (vf == &migong2[4][4]) {
                    break;
                }
                f.push(vf);
                can = false;
            }
        }

        if (can) {
            f.pop();
        }

    }

    




    vector<Node*> fin2;
    Node*bb = &migong2[4][4];
    while (true) {

        fin2.push_back(aa);
        if (bb == &migong2[0][0]) {
            break;
        }
        bb = bb->parents;

    }

    

    int count2 = 0;
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            cout << migong2[i][j].walked;
            if (migong2[i][j].walked)count2++;
        }
        cout << endl;
    }
    reverse(fin2.begin(), fin2.end());




    for (int i = 0; i < fin.size(); i++) {
        cout << fin[i]->x <<" "<< fin[i]->y<< endl;
    }

    return 0;
}


输出：
0 1 0 0 0
0 1 1 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
11000
11111
11111
11111
00011
0 0
1 0
2 0
2 1
2 2
2 3
2 4
3 4
4 4

两种方法的时间对比以及路径分析：

 

#include<iostream>
#include<vector>
#include<list>
#include<algorithm>
#include<queue>
#include<string>
#include<stack>
#include<time.h>
#include <windows.h>
#include<set>

using namespace std;

struct Node
{
    int x;
    int y;
    bool walked;
    int g;
    int f;//f = g+h
    int h;
    Node* parents;
};

int main() {
    int qiang = 0;
    vector<vector<Node>> migong;//创建二维迷宫组
    for (int i = 0; i < 5; i++) {
        vector<Node> hang;
        for (int j = 0; j < 5; j++) {
            int ii;
            cin >> ii;
            if (ii) qiang++;
            Node node{ i,j,ii };
            hang.push_back(node);
        }

        migong.push_back(hang);
    }
    
    int a[10002];
    int i = 0;
    double run_time;
    _LARGE_INTEGER time_start;  //开始时间
    _LARGE_INTEGER time_over;   //结束时间
    double dqFreq;      //计时器频率
    LARGE_INTEGER ff;   //计时器频率
    QueryPerformanceFrequency(&ff);
    dqFreq = (double)ff.QuadPart;
    QueryPerformanceCounter(&time_start);

    /*-----------------------------------dfs----------------------------------------------*/
    vector<vector<Node>> migong2 = migong;

    stack<Node*> f;
    f.push(&migong2[0][0]);
    migong2[0][0].walked = true;
    while (!f.empty()) {
        Node *vt = f.top();
        bool can = true;
        if (vt->x >= 1) {
            Node *vf = &migong2[vt->x - 1][vt->y];
            if (vf->walked == false) {
                vf->parents = vt;
                vf->walked = true;
                if (vf == &migong2[4][4]) {
                    break;
                }
                f.push(vf);
                can = false;
            }
        }
        if (vt->x <=3) {
            Node *vf = &migong2[vt->x + 1][vt->y];
            if (vf->walked == false) {
                vf->parents = vt;
                vf->walked = true;
                if (vf == &migong2[4][4]) {
                    break;
                }
                f.push(vf);
                can = false;
            }
        }
        if (vt->y >= 1) {
            Node *vf = &migong2[vt->x][vt->y - 1];
            if (vf->walked == false) {
                vf->parents = vt;
                vf->walked = true;
                if (vf == &migong2[4][4]) {
                    break;
                }
                f.push(vf);
                can = false;
            }
        }
        if (vt->y <= 3) {
            Node *vf = &migong2[vt->x ][vt->y + 1];
            if (vf->walked == false) {
                vf->parents = vt;
                vf->walked = true;
                if (vf == &migong2[4][4]) {
                    break;
                }
                f.push(vf);
                can = false;
            }
        }

        if (can) {
            f.pop();
        }

    }

    QueryPerformanceCounter(&time_over);    //计时结束
    run_time = 1000000 * (time_over.QuadPart - time_start.QuadPart) / dqFreq;
    float time1 = run_time;

    QueryPerformanceFrequency(&ff);
    dqFreq = (double)ff.QuadPart;
    QueryPerformanceCounter(&time_start);

    /*-----------------------------------bfs----------------------------------------------*/
    int ax[4] = { -1,1,0,0 };
    int by[4] = { 0,0,1,-1 };

    queue<Node*> bfs;
    bfs.push(&migong[0][0]);//先将起点推进去
    migong[0][0].walked = true;

    Node *vt;//等下指向父节点的指针
    Node *vf;//等下指向父节点引申出的子节点

    while (!bfs.empty()) {
        vt = bfs.front();
        bfs.pop();



        if ((*vt).x >= 1) {//查询左节点是否可以
            vf = &migong[(*vt).x + ax[0]][(*vt).y + by[0]];
            if (!(*vf).walked && !(*vf).walked) {
                bfs.push(vf);
                (*vf).walked = true;
                (*vf).parents = vt;//子节点指向父节点
                if ((*vf).x == 4 && (*vf).y == 4) break;//如果是终点节点，结束寻找，跳出循环。
            }
        }
        if ((*vt).x <= 3) {//查询右节点是否可以
            vf = &migong[(*vt).x + ax[1]][(*vt).y + by[1]];
            if (!(*vf).walked && !(*vf).walked) {
                bfs.push(vf);
                (*vf).walked = true;
                (*vf).parents = vt;
                if ((*vf).x == 4 && (*vf).y == 4) break;
            }
        }
        if ((*vt).y <= 3) {//查询下节点是否可以
            vf = &migong[(*vt).x + ax[2]][(*vt).y + by[2]];
            if (!(*vf).walked && !(*vf).walked) {
                bfs.push(vf);
                (*vf).walked = true;
                (*vf).parents = vt;
                if ((*vf).x == 4 && (*vf).y == 4) break;
            }
        }
        if ((*vt).y >= 1) {//查询上节点是否可以
            vf = &migong[(*vt).x + ax[3]][(*vt).y + by[3]];
            if (!(*vf).walked && !(*vf).walked) {
                bfs.push(vf);
                (*vf).walked = true;
                (*vf).parents = vt;
                if ((*vf).x == 4 && (*vf).y == 4) break;
            }
        }

    }

    QueryPerformanceCounter(&time_over);    //计时结束
    run_time = 1000000 * (time_over.QuadPart - time_start.QuadPart) / dqFreq;
    float time2 = run_time;
    /*-----------------------------------A*----------------------------------------------*/
    vector<vector<Node>> migong3 = migong;
    set<Node*> openNode;
    set<Node*> closeNode;
    openNode.insert(&migong3[0][0]);

    /*-----------------------------------结束----------------------------------------------*/

    vector<Node*> fin;
    Node*aa = &migong[4][4];
    while (true) {
        
        fin.push_back(aa);
        if (aa == &migong[0][0]) {
            break;
        }
        aa = aa->parents;
        
    }

    vector<Node*> fin2;
    Node*bb = &migong2[4][4];
    while (true) {

        fin2.push_back(bb);
        if (bb == &migong2[0][0]) {
            break;
        }
        bb = bb->parents;

    }

    cout << "bfs运行后矩阵" << endl;

    int count = 0;
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            cout << migong[i][j].walked;
            if (migong[i][j].walked)count++;
        }
        cout << endl;
    }
    reverse(fin.begin(), fin.end());

    cout << "dfs运行后矩阵" << endl;

    int count2 = 0;
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            cout << migong2[i][j].walked;
            if (migong2[i][j].walked)count2++;
        }
        cout << endl;
    }
    reverse(fin2.begin(), fin2.end());




    for (int i = 0; i < fin.size(); i++) {
        cout << fin[i]->x <<" "<< fin[i]->y<< endl;
    }

    cout << "Totle Time of dfs : " << time1 << "s" << endl;
    cout << "Totle Time of bfs: " << time2 << "s" << endl;
    cout << "bfs共搜索过的节点数：" << count- qiang << endl;
    cout << "dfs共搜索过的节点数：" << count2- qiang << endl;
    return 0;
    //https://blog.csdn.net/u012878643/article/details/46723375
}

输出示例1：
0 1 0 0 0
0 1 1 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
bfs运行后矩阵
11001
11111
11111
11111
11111
dfs运行后矩阵
11000
11111
11111
11111
00011
bfs路径
0 0
1 0
2 0
2 1
2 2
2 3
2 4
3 4
4 4
dfs路径
0 0
1 0
2 0
2 1
2 2
2 3
2 4
3 4
4 4
Totle Time of dfs : 65.5013s
Totle Time of bfs: 67.3427s
bfs共搜索过的节点数：15
dfs共搜索过的节点数：11


输出示例2：
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
bfs运行后矩阵
11111
11111
11111
11111
11111
dfs运行后矩阵
11111
11111
11111
11111
11111
bfs路径
0 0
1 0
2 0
3 0
4 0
4 1
4 2
4 3
4 4
dfs路径
0 0
0 1
0 2
0 3
0 4
1 4
2 4
2 3
2 2
2 1
2 0
3 0
4 0
4 1
4 2
4 3
4 4
Totle Time of dfs : 133.107s
Totle Time of bfs: 131.792s
bfs共搜索过的节点数：25
dfs共搜索过的节点数：25


输出示例3：
0 0 0 0 0
0 1 1 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 0 0
bfs运行后矩阵
11111
11111
11111
11111
11111
dfs运行后矩阵
11111
11111
11111
11111
11111
bfs路径
0 0
1 0
2 0
3 0
4 0
4 1
4 2
4 3
4 4
dfs路径
0 0
0 1
0 2
0 3
0 4
1 4
2 4
2 3
2 2
2 1
2 0
3 0
4 0
4 1
4 2
4 3
4 4
Totle Time of dfs : 120.217s
Totle Time of bfs: 99.1726s
bfs共搜索过的节点数：19
dfs共搜索过的节点数：19

参考：dfs详解



作者：Buyun0
链接：https://www.jianshu.com/p/1fc63ab1bcc2
 

bandaoyu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
迷宫问题 C++程序
09-10
这是心理学中的一个经典问题。心理学家把一只老鼠从一个无顶盖的大盒子的入口处放入，让老鼠自行找到出口出来。迷宫中设置很多障碍阻止老鼠前行，迷宫唯一的出口处放有一块奶酪，吸引老鼠找到出口。 简而言之，迷宫问题是解决从布置了许多障碍的通道中寻找出路的问题。
C++ 算法篇 深度优先搜索（DFS）
流年的博客
01-28 1万+
图的遍历 图的遍历为从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次的过程。 对于图的遍历，不想树那么简单，需要在遍历的过程中把访问过的顶点打上标记，以避免访问多次。具体办法是设置一个访问数组visited[n]，n是图中顶点的个数，初始值为0，访问后设置为1。 对于图的遍历来说，通常有两种遍历方案：深度优先遍历和广度优先遍历。 深度优先遍历 深度优先遍历（Depth_Fi...
C++算法_dfs 与 dfa经典题目
最新发布
wjl_8616的博客
07-20 1516
深度优先搜索
C++迷宫问题
Christopherwa的博客
01-28 4644
C++迷宫问题
c++深搜1-迷宫类问题
Mark1277的博客
06-11 3848
深搜-迷宫类问题
C++迷宫问题完全详解
weixin_42163707的博客
12-20 2421
深度优先搜索（DFS）和广度优先搜索（BFS）是两种常用的图遍历算法，适用于不同的问题和场景。广度优先使用的是Queue队列，队列是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口。这里使用了栈，stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口。迷宫我们都玩过，有些复杂的看的眼花缭乱，但是有没有想过，让机器帮你完成这个工作，想着就很酷，好，在实际应用中，根据问题的特点和需求，选择合适的算法来进行图遍历是非常重要的。
CSP-S模拟赛模拟题附答案
04-14
- **搜索算法**：深度优先搜索(DFS)、广度优先搜索(BFS)等。 - **贪心算法**：适用于能够通过局部最优选择来达到全局最优解的问题。 - **动态规划**：解决多阶段决策过程中的最优化问题，关键在于状态定义及状态转移...
C++写的图的深度和广度遍历以及对应的生成树程序
08-21
在这个特定的程序中，我们关注的是使用C++实现图的深度优先搜索（DFS）和宽度优先搜索（BFS），并输出这两种遍历方法得到的生成树。让我们深入探讨这两个概念。 首先，**深度优先搜索（DFS）** 是一种用于遍历或...
数据结构和算法c++英文原版
11-14
图的常见算法包括深度优先搜索（DFS）、广度优先搜索（BFS）、最短路径算法（如Dijkstra算法和Floyd-Warshall算法）、最小生成树算法（如Prim算法和Kruskal算法）等。这些算法在解决诸如网络路由、社交网络分析、...
信息学奥赛一本通 NOIP500+第4部分
08-26
图的遍历方法有深度优先搜索（DFS）和广度优先搜索（BFS），在C++中可以通过递归或队列实现。 哈希表（散列表）提供快速的插入、查找和删除操作，通过哈希函数将键映射到数组索引，实现O(1)的平均时间复杂度。C++...
NEEPAlgorithms:《王道机试指南》和《算法笔记》（“晴神宝典”）例题题解
05-24
1. **基础算法**：包括排序算法（如冒泡排序、快速排序、归并排序、堆排序）、搜索算法（如线性搜索、二分查找）、图论基础（如深度优先搜索DFS、广度优先搜索BFS、最小生成树Prim和Kruskal算法）、最短路径Dijkstra...
C++ 实现迷宫问题
ztt_1105的博客
07-21 2573
通过C++设计了一个迷宫游戏，涉及到链表，C++基本操作，终端字符处理，深度优先遍历算法。下面开始吧！ 在全局变量中定义地图，包括地图的长和高（30*20），同时还需定义一些标记。 flag 用于创建地图，true代表地图传创建成功。 slow用于更换游戏速度，true代表游戏慢速。 autogame用于更换游戏模式，true代表自动游戏。 #define MAX_X 20 #define...
使用C/C++解决迷宫问题
IT_jishuyuan的博客
11-06 2276
使用C/C++解决迷宫问题 一、设计步骤 1、绘制迷宫 int Mg[10][10]={ {1,1,1,1,1,1,1,1,1,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,0,0,1,1,0,0,1}, {1,0,1,1,1,0,0,0,0,1}, {1,0,0,0,1,0,0,0,0,1}, {1,0,1,0,0,0,1,0,0,1}, {1,0,1,1,1,0
（C++）数据结构实验二——迷宫问题
Lemon_CHA的博客
11-11 1470
BFS算法迷宫 #include <iostream> #include <string> //#include <queue> #include "QueueBottom.h" #include <fstream> using namespace std; #include <iomanip> #include <Windows.h> #include <time.h> clock_t start,finish;
数据结构——迷宫问题（顺序栈、C++）
m0_53468233的博客
08-01 9555
顺序栈求解随机生成迷宫的通路（C++)
迷宫c++(详解)
ASBSIHD的博客
03-19 1210
迷宫c++(详解)
C++——深度优先搜索
m0_48748418的博客
05-21 3392
它从起始节点开始，沿着一条路径尽可能深地探索，直到无法继续或达到目标节点，然后回溯到前一节点，继续探索其他路径，直到遍历完所有节点或找到目标。在深度优先搜索中，每个节点都会被访问且仅被访问一次。如果某个节点的邻居节点已经被访问过，那么该节点将被跳过。在树的问题中，深度优先搜索可以用于查找树的特定节点或进行树的遍历。需要注意的是，深度优先搜索可能会陷入无限循环，因此在应用时需要合理设置终止条件和避免重复访问节点。3、若存在未访问的邻居节点，则选择一个作为当前节点，标记为已访问，并重复步骤2。
C++算法之深度优先搜索算法详解
热门推荐
程序猿老樊的博客
09-28 2万+
1.深度优先搜索算法          深度优先搜索是一种在开发爬虫早期使用较多的方法。它的目的是要达到被搜索结构的叶结点(即那些不包含任何超链的HTML文件) 。在一个HTML文件中，当一个超链被选择后，被链接的HTML文件将执行深度优先搜索，即在搜索其余的超链结果之前必须先完整地搜索单独的一条链。深度优先搜索沿着HTML文件上的超链走到不能再深入为止，然后返回到某一个HTML文件，再继续选择...
acwing-843.n-皇后问题
weixin_43211195的博客
05-02 1382
题目描述 n−皇后问题是指将 n 个皇后放在 n×n 的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。 现在给定整数 n，请你输出所有的满足条件的棋子摆法。 输入格式 共一行，包含整数 n。 输出格式 每个解决方案占 n 行，每行输出一个长度为 n 的字符串，用来表示完整的棋盘状态。 其中 . 表示某一个位置的方格状态为空，Q 表示某一个位置的方格上摆着皇后。 每个方案输出完成后，输出一个空行。 注意：行末不能有多余空格。 输出方案的顺序任意，只要不重复且没有
深度优先与广度优先算法详解：面试通关40讲第27-31节
深度优先搜索(DFS)与广度优先搜索(BFS)是数据结构和算法领域中两种基础且重要的搜索策略，尤其在图论和计算机科学的求职面试中常被提及。这两者在解决不同类型的问题时展现出了独特的效率和适用性。 深度优先搜索...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值