广度优先搜索(BFS)和深度优先搜索(DFS)

1.BFS

1.1 实现方式

本质上是树的层序遍历，使用队列实现

1.2 模版

1.3 例题

《啊哈算法-解救小哈》

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <string.h>
const  int max=1000;
struct note{
    int x;      //横坐标
    int y;      //纵坐标
    int f;      //父亲在队列中的编号，如果输出路径
    int s;      //步数
};
 
int main() {
    int startx,starty,p,q,n,m,flag,tx,ty;
    struct note que[2501];
    int head,tail;
    int a[51][51]={0};  //用来存储地图
    int book[51][51]={0};   //记录哪些点已经在队列中，防止一个点被重复扩展，并全部初始化为0
    int next[4][2]={
        {0,1},          //向右走
        {1,0},          //向下走
        {0,-1},         //向左走
        {-1,0}          //向上走
    };
    
    scanf("%d %d",&n,&m);   //n行m列
    //读入迷宫
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            scanf("%d",&a[i][j]);
    scanf("%d %d %d %d",&startx,&starty,&p,&q);
    //队列初始化
    head=1;
    tail=1;
    //往队列插入迷宫入口坐标
    que[tail].x=startx;
    que[tail].y=starty;
    que[tail].f=0;
    que[tail].s=0;
    tail++;
    book[startx][starty]=1;
    
    flag=0; //用来标记是否已经到达目标点，0表示还没有达到，1表示达到
    //当队列不为空的时候循环
    while(head<tail){
        //枚举四个方向
        for (int k=0; k<=3; k++) {
            //计算下一个点的坐标
            tx=que[head].x+next[k][0];
            ty=que[head].y+next[k][1];
            //判断是否越界
            if(a[tx][ty]==0&&book[tx][ty]==0){
                //把这个点标记为已经走过
                //注意宽搜每个点只入队一次，所以和深搜不同，无需将book数组还原
                book[tx][ty]=1;
                //插入新的点到队列中
                que[tail].x=tx;
                que[tail].y=ty;
                que[tail].f=head; //因为这个点是从head扩展出来，所以它的父亲是head，求路径用
                que[tail].s=que[head].s+1;  //步数是父亲的步数+1
                tail++;
            }
            //如果到目标点，停止扩展，任务结束，退出循环
            if(tx==p&&ty==q){
                flag=1;
                break;
            }
        }
        if(flag==1)
            break;
        head++;         //当一个点扩展结束后，head++才能对后面的点再进行扩展
    }
    //打印队列中末尾最后一个点的步数
    //tail是指向队列队尾的下一个位置，所以这需要-1
    printf("%d\n",que[tail-1].s);
    return 0;
}
 
 
 

2.  DFS

本质上是树的前序遍历

2.1 模版

  void dfs(int step) {
        //判断边界
        //尝试每一种可能
        for (int i=1;i<=n;i++){
            //记录一些数据,例如
             sun++
            //继续下一步
            dfs(step+1);
        }
        //返回
    }

2.2 例题

啊哈算法的解救小哈和炸弹人（图的深度优先搜索）

经典的DFS例题：啊哈算法的解救小哈和炸弹人（图的深度优先搜索）

//核心代码
    void dfs(int x, int y, int step) {
        int next[ 4][2]={
            {
                0, 1
            },//向右走
            {
                1, 0
            },//向下走
            {
                0, -1
            },//向左走
            {
                -1, 0
            }
        } ;//向上走
        int tx, ty, k;
        //判断是否到达小哈位置
        if (x == p && y == q) {
            if (step < min)
                min = step;
            return;
        }
        //枚举四种走法
        for (k = 0; k <= 3; k++) {
            //计算下一个点的坐标
            tx = x + next[k][0];
            ty = y + next[k][1];
            //判断是否越界
            if (tx < 1 || tx > n || ty < 1 || ty > m)
                continue;
            //判断该点是否有障碍物或者已经在路径上
            if (a[tx][ty] == 0 && book[tx][ty] == 0) {
                book[tx][ty] = 1;//标记这个点已经走过
                dfs(tx, ty, step + 1);//尝试下一个点
                book[tx][ty] = 0;//尝试结束，取消标记，恢复现场
            }
        }
        return;
     }

3.区别

1.BFS是用来搜索最短径路的解是比较合适的，比如求最少步数的解，最少交换次数的解，因为BFS搜索过程中遇到的解一定是离根最近的，所以遇到一个解，一定就是最优解，此时搜索算法可以终止。这个时候不适宜使用DFS，因为DFS搜索到的解不一定是离根最近的，只有全局搜索完毕，才能从所有解中找出离根的最近的解。（当然这个DFS的不足，可以使用迭代加深搜索ID-DFS去弥补）
2.空间优劣上，DFS是有优势的，DFS不需要保存搜索过程中的状态，而BFS在搜索过程中需要保存搜索过的状态，而且一般情况需要一个队列来记录。
3.DFS适合搜索全部的解，因为要搜索全部的解，那么BFS搜索过程中，遇到离根最近的解，并没有什么用，也必须遍历完整棵搜索树，DFS搜索也会搜索全部，但是相比DFS不用记录过多信息，所以搜素全部解的问题，DFS显然更加合适。