通俗理解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 = ;
 bool mark[maxn][maxn]; //访问标记
 int go[][] = {,-,,,,,-,}; //方向向量

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

 State maze[maxn];

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

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

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

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

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

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

 DFS：

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

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

 //DFS算法框架：

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

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

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

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

 int main()
 {
     ……；
     return ;
 }