dfs解决迷宫问题（找步数）

dfs为深度优先搜索，即为顺着一条道走到黑，当什么时候走不动了，才开始往回开始走，它与bfs则不同，bfs是边走边看，把每种可能都看一下，但是dfs只要找到一条道路即可。话不多说了，直接看题把

问题描述：

小明置身于一个迷宫，请你帮小明找出从起点到终点的最短路程。
小明只能向上下左右四个方向移动。

输入

输入包含多组测试数据。输入的第一行是一个整数T，表示有T组测试数据。
每组输入的第一行是两个整数N和M（1<=N,M<=100）。
接下来N行，每行输入M个字符，每个字符表示迷宫中的一个小方格。
字符的含义如下：
‘S’：起点
‘E’：终点
‘-’：空地，可以通过
‘#’：障碍，无法通过
输入数据保证有且仅有一个起点和终点。

输出

对于每组输入，输出从起点到终点的最短路程，如果不存在从起点到终点的路，则输出-1。

样例输入

1
5 5
S-###
-----
##---
E#---
---##

样例输出

9

下面我来分别介绍一下bfs和dfs来解决问题得思路：
1、bfs迷宫问题在我得前一篇已经详细讲解了，若是没有看的话，请先去看，看完之后你会感觉豁然开朗。下面我就直接放bfs的代码了：

#include <stdio.h>

typedef struct ss
{
    int x, y;
    int pre;
}ss;
ss queue[100];
int sx,sy,dx,dy;
int visit[100][100]={0};
int dxy[4][2]={
    {-1,0},
    {0,1},
    {1,0},
    {0,-1}
};
int a,b,step;
int array[100][100];
void dfs(int x,int y);
void print_data(int rear);
int main(int argc, char *argv[])
{

    scanf("%d %d",&a,&b);
    //printf("%d-%d-",a,b);
    char st[a][b];
    
    int i,j;
    for(i=0;i<a;i++)
    {
        getchar();
        for(j=0;j<b;j++)
        {
            scanf("%c",&st[i][j]);
            if(st[i][j]=='S')
            {
                sx=i;
                sy=j;
                array[i][j]=0;
            }
            else if(st[i][j]=='E')
            {
                dx=i;
                dy=j;
                array[i][j]=0;
            }
            else if(st[i][j]=='-')
                array[i][j]=0;
            else if(st[i][j]=='#')
                array[i][j]=1;
        }
        
    }

    //printf("dx=%d,dy=%d\n",dx,dy);

    for(i=0;i<a;i++)
    {
        for(j=0;j<b;j++)
            printf("%d\t",array[i][j]);
        printf("\n");
    }
    dfs(sx,sy);
    printf("%d%",step-1);
    return 0;
}

void dfs(int x,int y)
{
    int i,j;
    int front=0,rear=1;
    int next_x,next_y;
    queue[front].x=x;
    queue[front].y=y;
    queue[front].pre=-1;
    visit[x][y]=1;

    while(front<rear)
    {
        for(i=0;i<4;i++)
        {
            next_x=queue[front].x+dxy[i][0];
            next_y=queue[front].y+dxy[i][1];
            if(next_x>=0&&next_x<a&&next_y>=0&&next_y<b&&array[next_x][next_y]==0&&visit[next_x][next_y]==0)
            {
                queue[rear].x=next_x;
                queue[rear].y=next_y;
                queue[rear].pre=front;
                rear++;
                visit[next_x][next_y]=1;
                //printf("(%d %d)-%d-%d\n",next_x,next_y,front,rear);
            }

            if(next_x==dx&&next_y==dy)
                print_data(rear-1);
        }
        front++;
    }
}

void print_data(int rear)
{
    if(rear!=-1)
    {
        
        print_data(queue[rear].pre);
        
        printf("(%d %d)\n",queue[rear].x,queue[rear].y);
        step++;
    }
        
    
}

2、dfs去找步数真的是非常的方便啊，下面直接在代码上注释，代码如下：

#include <stdio.h>
#define max 0xffff
#define maxline 100
int sx,sy,dx,dy;         //sx用来接收起点的x坐标，sy用来接收起点的y坐标；dx是用来接收终点的x坐标，dy是用来接收终点的y坐标
int a,b;                 //a，b分别是你要输入的迷宫的宽度和长度
int dis[maxline][maxline];     //定义一个距离数组，用来存放距离
int dxy[4][2]={
    {-1,0},
    {0,1},
    {1,0},
    {0,-1}
};            //用来改变方向的

void dfs(int sx,int sy,int step);
bool cmp(int next_x,int next_y,int step);
int main(int argc, char *argv[])
{
    char ch;
    int i,j;
    scanf("%d %d",&a,&b);

    for(i=0;i<a;i++)
    {
        getchar();
        for(j=0;j<b;j++)
        {
            scanf("%c",&ch);
            if(ch=='S')
            {
                sx=i;
                sy=j;
                dis[i][j]=0;
            }
            else if(ch=='E')
            {
                dx=i;
                dy=j;
                dis[i][j]=max;
            }
            else if(ch=='-')
                dis[i][j]=max;
            else 
                dis[i][j]=0;
        }
    }                    //接收数据，并且把可以通过的距离设置为最大值，不可通过的距离设置为0

    for(i=0;i<a;i++)
    {
        for(j=0;j<b;j++)
            printf("%d\t",dis[i][j]);
        printf("\n");
    }                       //打印出我们设置的距离

    dfs(sx,sy,0);            //将起点和当前步数传入到dfs
    printf("%d",dis[dx][dy]==max?-1:dis[dx][dy]);
    return 0;    
}

void dfs(int sx,int sy,int step)
{
    int next_x, next_y; 
    int i;
    for(i=0;i<4;i++)
    {
        next_x=sx+dxy[i][0];       //next_x是当前位置的下一步的x坐标
        next_y=sy+dxy[i][1];       //next_y是当前文职的下一步的y坐标
        if(cmp(next_x,next_y,step))  //判断next_x 、next_y是否合法
        {
            dis[next_x][next_y]=step+1;  //若合法的话就将从起点到该点的距离存储到dis中
            dfs(next_x,next_y,step+1);   //然后从下一点开始dfs
        }
    }
}

bool cmp(int next_x,int next_y,int step)
{
    if(next_x>=0&&next_x<a&&next_y>=0&&next_y<b&&step+1<dis[next_x][next_y])
        return true;
    else
        return false;
}

代码非常的简单，如果有什么不懂得可以在下方评论出你得疑惑；如果这篇文章对你有帮助得话，欢迎帮忙点个赞；如果你有更好的办法的话欢迎评论在下方，大家可以进行一起讨论，谢谢。