通俗理解BFS和DFS，附基本模板

1.BFS（宽度优先搜索）：使用队列来保存未被检测的节点，按照宽度优先的顺序被访问和进出队列

打个比方：（1）类似于树的按层次遍历

　　　　　（2）你的眼镜掉在了地上，你趴在地上，你总是先摸离你最近的地方，如果没有，再摸远一点的地方……

BFS算法：

通常用队列（先进先出，FIFO）实现

初始化队列Q；
Q = {起点s};
标记s为已访问；
while（Q非空）
{
    取Q队首元素u；
    u出队；
    if（u==目标状态）
    {
        ……
    }
    else
    {
        所有与u相邻且未被访问的点进入队列；
        标记u为已访问；
    }
}

 

//BFS算法框架
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;

const int maxn = 100;
bool mark[maxn][maxn]; //访问标记
int go[4][2] = {0,-1,1,0,0,1,-1,0}; //方向向量

struct State
{
    int x,y; //坐标位置
    int step; //搜索步数记录
};

State maze[maxn];

bool CheckState(State s)
{
    if(!mark[s.x][s.y]&&(边界条件满足)) //符合条件
        return 1;
    else //不符合条件
        return 0;
}

void BFS(State st)
{
    queue<State> q;
    State now,next;
    st.step = 0; //步数清零;
    q.push(st); //入队;
    mark[st.x][st.y] = 1; //访问标记
    while(!q.empty())
    {
        now = q.front(); //取队首元素进行拓展
        q.pop(); //队首元素出队；
        if(now == 目标状态) //出现目标状态，此时的step为最小值，做做相关处理后退出即可；
        {
            ……;
            return ;
        }
        //如果没有到目标状态：
        else
        {
            for(int i=0;i<4;i++)
            {
                next.x = now.x + go[i][0];//按照规则生成下一个状态
                next.y = now.y + go[i][1];
                if(CheckState(next)) //如果状态满足条件则入队；
                {
                    next.step = now.step + 1;
                    q.push(next);
                }
            }
        }
        return ;
    }
}

int main()
{
    ……;
    BFS();
    ……;
    return 0;
}

 

DFS (深度优先搜索）：一直往下搜，知道找到解或者走不下去为止

打个比方：（1）类似于树的先根遍历

　　　　　（2）类似于你在走迷宫，你不能分身来站在每个走过的位置，所以，你只能不撞南墙不回头。

 

DFS：

使用栈来保存未被检测的节点，
节点按照深度优先的次序被访问并依次压入栈中，并已相反的次序出栈进行新的检测。

DFS（dep，……）//dep代表目前DFS的深度
{
    if（找到解||走不下去了）
    {
        ……；
        return；
    }
    else
    {
        枚举下一种情况；
        DFS（dep+1，……）；
    }
}

 

//DFS算法框架：

#include<iostream>
#include<cstring>
#include<cstdlib>
using namespace std;

const int maxn = 100;
bool mark[maxn][maxn]; //访问标记
int maze[maxn][maxn]; //坐标范围
int go[4][2] = {0,-1,1,0,0,1,-1,0}; //方向向量

bool CheckState(int x,int y)
{
    if(!mark[x][y]&&……) //满足条件
        return 1;
    else //与约束条件冲突
        return 0;
}

void DFS(int x,int y)
{
    mark[x][y] = 1; //标记该节点被访问过
    if(maze[x][y] == G) //出现目标状态G
    {
        …… //做相应处理
        return ;
    }
    else
    {
        for(int i=0;i<4;i++)
            if(CheckState(x+go[i][0],y+go[i][1])) //按照规则生成下一个节点
                DFS(x+go[i][0],y+go[i][1]);
    }
    return ; //如果没有下层搜索点，则回溯；
}

int main()
{
    ……；
    return 0;
}