DFS与BFS入门（迷宫问题）

DFS深度优先遍历，侧重于探寻是否有出路，采用递归思想，常常调用函数自身，设置终止的条件，以寻找出路。

BFS广度优先遍历，侧重于探寻出路个数及长短，采用队列思想，将矩阵或图周围的顶点放入队列中然后利用队列先进先出的性质依次遍历。

从例题中感知：

例题：

方形迷宫：现有正方形数字迷宫，其中0表示可以通行，1表示阻塞，第一行输入迷宫的边长（行和列），第二行输入具体的阻塞物（0和1）。

1.用dfs探寻是否可以通行。即：从左上角走到右下角。若可以输出1，若不可输出0。

2.用bfs探寻通路的长短。（保证有一条可通）。输出通路的长度。

dfs代码：

#include <iostream>
using namespace std;
const int N=100;
int n;
int mp[N][N], vis[N][N];
bool fg=false;
int dx[4]={0,0,-1,1} ;
int dy[4]={-1,1,0,0} ;
bool check(int nx,int ny)
{
if(nx>=0&&nx<n&&ny>=0&&ny<n&&vis[nx][ny]==false&&mp[nx][ny]==0)
  return true;;
  return false;
}
void dfs(int x,int y)
{  if(vis[x][y]||fg==true) return;
   if(x==n-1&&y==n-1){ fg=true; }
   vis[x][y]=true;
   for(int i=0;i<4;i++)
   {
       int nx=x+dx[i];
       int ny=y+dy[i];
    if(check(nx,ny))dfs(nx,ny);

   }

}
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
         cin>>mp[i][j];
     dfs(0,0);
     //bool fg1=true;
     cout<<fg<<endl;


}

bfs：

#include <queue>
#include <iostream>
using namespace std;
const int N=100;
int n;
int mp[N][N];
bool vis[N][N];
int dx[4]={0,0,-1,1};
int dy[4]={-1,1,0,0};
struct Edge
{int x;int y;int w;};
bool check(int x,int y)
{
if(x>0&&x<=n&&y>0&&y<=n&&vis[x][y]==false&&mp[x][y]==0) return true;
return false;

}
int bfs()
{ queue<Edge> que;
  que.push({1,1,1});
  //vis[0][0]=true;
  while(!que.empty())
    {Edge p=que.front();//cout<<123<<endl;
     que.pop();
     //cout<<p.x<<" "<<p.y<<endl;
     if(p.x==n&&p.y==n) {return p.w;}
     if(vis[p.x][p.y]) continue;
     vis[p.x][p.y]=true;
     for(int i=0;i<4;i++)
     {
      int nx=p.x+dx[i];
      int ny=p.y+dy[i];
      if(check(nx,ny))
      que.push({nx,ny,p.w+1});
     }
    }

}
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
 for(int j=1;j<=n;j++)
    cin>>mp[i][j];
cout<<bfs();


}

读代码，体会思想。