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

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

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;