迷宫最短路径问题的dfs,bfs实现

　　　　　　　　　　　　　　　　　　迷宫的最短路径
给定一个大小为 N×M的迷宫。迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四格的通道移动。请求出从起点到终点所需的小步数。请注意，本题假定从起点一定可以移动到终点

限制条件：N,M<=100;

样例输入：N=10,M=10('#','.','S','G'分别表示墙壁，通道，起点和终点)

#S######.#

......#..#

.#.##.##.#

.#........

##.##.####

....#....#

.#######.#

....#.....

.####.###.

....#...G# 　

dfs分析:主要考虑当前应该怎么做，每到一个点下一步有上下左右四种情况，我们按顺时针方向右下左上来进行计算，到新的一个点判断是否走过以及有没有障碍物，如果答案是确定的就可以继续dfs。　

#include <iostream>
#include <cstdio>
using namespace std;
int p0,q0,p1,q1;//储存起始点和终点的横纵坐标
char a[][];//根据数据量自己调整
int book[][];//标记数组来判断有没有到达
int next[][]={{,},{,},{,-},{-,}};//分别储存x,y坐标下一步的可能情况
int mini=;//先给最小路径一个很大的初值
int n,m;
void dfs(int x,int y,int step){
    if(x==p1&&y==q1){
        if(step<mini)
        mini=step;
        return ;//函数直接结束
    }
    for(int k=;k<;k++){
        int nx=x+next[k][], ny=y+next[k][];//枚举下一步可能的横纵坐标
        if(nx<||nx>n||ny<||ny>m){//控制不越界
            continue;
        }
        if(book[nx][ny]==&&a[nx][ny]=='.'||book[nx][ny]==&&a[nx][ny]=='G'){
            //cout<<step<<endl;
            book[nx][ny]=;//标记走过了
            dfs(nx,ny,step+);
            book[nx][ny]=;//注意dfs后返回这一点为没走过。
        }
    }
        return ;
}
int main(){
    cin>>n>>m;
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            cin>>a[i][j];
            if(a[i][j]=='S'){
                p0=i;q0=j;
            }
            if(a[i][j]=='G'){
                p1=i;q1=j;
            }
        }
    }
    //cout<<p0<<q0<<p1<<q1<<endl;
    //if(a[2][1]=='.')    cout<<"just a test \n";
    book[p0][q0]=;//标记起始点走过了
    dfs(p0,q0,);
    cout<<mini<<endl;
    return ;
}

BFS分析：同深搜选择一个点之后不断继续往下深入不同，宽搜是记录所有到达后步数相同的点，更适宜做最短路径的问题。

#include <iostream>
#include <cstdio>
using namespace std;
char a[][];//根据题意自己设定数据量
int book[][];//标记某点是否到达
int sx,sy,gx,gy;//起始点坐标
struct node{
    int x;
    int y;
    int s;//s表示步数
};
node q[];//100*100的地图队列扩展最多是10000
int main(){
int head,tail;head=tail=; //一开始清空队列
    int n,m;
    cin>>n>>m;
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            cin>>a[i][j];
            if(a[i][j]=='S'){
                sx=i;sy=j;
            }
            if(a[i][j]=='G'){
                gx=i;gy=j;
            }
        }
    }
    int next[][]={{,},{,},{-,},{,-}};
    q[tail].x=sx;q[tail].y=sy;q[tail].s=;//将起点数据压入队列
    tail++; book[sx][sy]=;
    int flag=;//flag是为了找到最短路径后跳出while循环用的
    while(head<tail){
        for(int k=;k<;k++){
            int tx=q[head].x+next[k][],ty=q[head].y+next[k][];
            //判断是否越界
            if(tx<||tx>n||ty<||ty>m)
            continue;
            if(book[tx][ty]==&&a[tx][ty]!='#'){
                q[tail].x=tx;q[tail].y=ty;q[tail].s=q[head].s+;
                book[tx][ty]=;tail++;
            }
            if(tx==gx&&ty==gy){
                flag=;
                break;
            }
        }
        if(flag)    break;
        head++;
    }
    cout<<q[tail-].s<<endl;
    return ;
}

总结一下，dfs和bfs都能都能生成所有能够遍历到的状态，但是递归可以更尖端的编写且管理起来更简单，所以大多数情况还是用dfs实现，反之，bfs处理起最短路径时更方便。

此外，dfs更加节省内存。