深搜与广搜的实现及其应用

一、深度优先搜索算法（dfs）

核心思想：深搜是利用递归来实现搜索的一类算法

其搜索过程中目标位置未知，若找到目标则停止

若没有，则尝试向四周寻找。

上代码

#include<bits/stdc++.h>
using namespace std;

bool vis[1001][1001]; // 标记，若已经访问，则直接跳过
int mp[1001][1001]; // 地图
int nt[][2]={ // 下一步的位置
    {0,1},
    {0,-1},
    {-1,0},
    {1,0}
};

void dfs(int x,int y){ // 深搜，传入开始坐标
    if(mp[x][y]==2){ // 若为终点
        cout<<"YES";
        return ; // 停止搜索
    }
    for(int i=0;i<4;i++){ // 便利坐标数组，走下一步
        int xx=x+nt[i][0]; // 计算下一步x，y坐标
        int yy=y+nt[i][1];
        if(0<=xx && xx<n && 0<=yy && yy<m){ // 判断是否越界
            if(!vis[xx][yy] && !mp[xx][yy]){ // 若没走过，且能走
                vis[xx][yy]=1; // 标记
                dfs(xx,yy);    // 递归走下一步
                vis[xx][yy]=0;    // 回溯，另辟蹊径
        }
    }
}

int main(){
    // 正常主函数代码
    return 0;
}

二、广度优先搜索算法（bfs）

核心思想：

从一个节点开始，访问所有能访问的节点，直到找到

上代码

#include<bits/stdc++.h>
using namespace std;

bool vis[1001][1001]; // 标记，若已经访问，则直接跳过
int mp[1001][1001]; // 地图
int nt[][2]={ // 下一步的位置
    {0,1},
    {0,-1},
    {-1,0},
    {1,0}
};

struct Node{  // 存储节点的坐标，步数等
    int x,y;
    int dist;
};

queue<Node> q;  // 队列用来存储正在搜索的节点

void bfs(int x,int y){  // 传入开始坐标
    q.push(Node{x,y,0}); // 头节点入队
    vis[x][y]=1; // 标记
    while(!q.empty()){
        Node h=q.front(); // 头节点出队
        q.pop();
        if(mp[h.x][h.y]==2){ // 是否到达终点
            cout<<"YES";
            return ;
        }
        for(int i=0;i<4;i++){
            int xx=h.x+nt[i][0]; // 计算下一个坐标
            int yy=h.y+nt[i][1];
            if(0<=xx && xx<n && 0<=yy && yy<m){ // 是否越界
                if(mp[xx][yy] && !vis[xx][yy]){ // 能走且没走过
                    vis[xx][yy]=1; // 标记
                    q.push(Node{xx,yy,h.dist+1}); // 新节点入队
                }
            }
        }
    }
    cout<<"No";  // 若不能到达
}

int main(){
    // 正常主函数代码
    return 0;
}