算法提高bfs和dfs对比 学霸的迷宫

问题

问题描述

学霸抢走了大家的作业，班长为了帮同学们找回作业，决定去找学霸决斗。但学霸为了不要别人打扰，住在一个城堡里，城堡外面是一个二维的格子迷宫，要进城堡必须得先通过迷宫。因为班长还有妹子要陪，磨刀不误砍柴功，他为了节约时间，从线人那里搞到了迷宫的地图，准备提前计算最短的路线。可是他现在正向妹子解释这件事情，于是就委托你帮他找一条最短的路线。

输入格式

第一行两个整数n， m，为迷宫的长宽。
　　接下来n行，每行m个数，数之间没有间隔，为0或1中的一个。0表示这个格子可以通过，1表示不可以。假设你现在已经在迷宫坐标(1,1)的地方，即左上角，迷宫的出口在(n,m)。每次移动时只能向上下左右4个方向移动到另外一个可以通过的格子里，每次移动算一步。数据保证(1,1)，(n,m)可以通过。

输出格式

第一行一个数为需要的最少步数K。
　　第二行K个字符，每个字符∈{U,D,L,R},分别表示上下左右。如果有多条长度相同的最短路径，选择在此表示方法下字典序最小的一个。

资源限制

时间限制：1.0s 内存限制：256.0MB

样例输入

Input Sample 1:
3 3
001
100
110

Input Sample 2:
3 3
000
000
000

样例输出

Output Sample 1:
4
RDRD

Output Sample 2:
4
DDRR

解决办法

先尝试了dfs，解决不了所有问题，尝试bfs

dfs

关于迷宫问题，第一反应就是dfs，上下左右来遍历，那么，就出现了一个问题，先向下走再向上走，就是说两步之后又会回到之前的位置，之前的dfs都是求一共有多少次，用深搜可以快速的求出次数，这样是满足之前的所有要求。关于剪枝，x，y超过边界，k的次数大于最小次数，以及在遍历中加入continue来跳过前面说的一个问题，还是跑不出所有的用例。

#include<iostream>
#include<algorithm>
#include<string>
#include<math.h>
using namespace std;
int N[505][505];
int book[505][505];
int M[250000]={-1};
int n,m;
int dir[2][4]={{-1,1,0,0},{0,0,-1,1}};
char dirs[4]={'U','D','L','R'};//i=0123
int minnum=200000;
int minM[250000];
void dfs(int x,int y,int k)
{
    if(x<1 || x>n || y<1 || y>m || k > minnum)
        return;
    if(x==n && y==m)
    {
        if(k<minnum)
        {
            minnum=k;
            for(int i=0;i<minnum;i++)
                minM[i]=M[i];
        }
        return;
    }
    for(int i=0;i<4;i++)
    {
        if(k>=1&&((M[k-1]==0 && i==1)||(M[k-1]==1 && i==0)
        || (M[k-1]==2 && i==3)||(M[k-1]==3 && i==2) ))
            continue;
        int tx=x+dir[0][i];
        int ty=y+dir[1][i];
        if(  !book[tx][ty] && !N[tx][ty]) {
            book[tx][ty]=1;
            M[k] = i;
            dfs(tx, ty, k + 1);
            book[tx][ty]=0;
        }
    }

}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        string x;
        cin>>x;
        for(int j=1;j<=m;j++)
        {
            N[i][j]=x[j-1]-48;
            book[i][j]=0;
        }
    }
    dfs(1,1,0);
    cout<<minnum<<endl;
    for(int i=0;i<minnum;i++)
        cout<<dirs[minM[i]];
}

测试结果

bfs

  在具体的题目中，遇到bfs的题目比较少，在此总结一下，关于路径记录的，在每个节点中加入当前的路径信息。

#include<iostream>
#include<algorithm>
#include<string>
#include<math.h>
#include<queue>
using namespace std;
int N[505][505];
int book[505][505];
int n,m;
int dir[2][4]={{-1,1,0,0},{0,0,-1,1}};
string dirs[4]={"U","D","L","R"};//i=0123
typedef struct node{
    int x,y,step;
    string road;
}node;
void bfs()
{
    queue<node> s;
    node a;
    book[1][1]=1;
    a.x=1;
    a.y=1;
    a.step=0;
    a.road="";
    s.push(a);
    while(!s.empty())
    {
        node b=s.front();
        s.pop();
        int x=b.x,y=b.y,step=b.step;
        string road=b.road;

        if(x==n && y==m)
        {
            cout<<step<<endl;
            cout<<road;
            return;
        }
        for(int i=0;i<4;i++)
        {
            int tx=x+dir[0][i];
            int ty=y+dir[1][i];
            if(!book[tx][ty] && !N[tx][ty] && tx>=1 && tx<=n&&ty>=1&&ty <=m)
            {
                node c;
                c.x=tx;
                c.y=ty;
                c.step=step+1;
                c.road=road+dirs[i];
                s.push(c);
                book[tx][ty]=1;
            }
        }
    }

}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        string x;
        cin>>x;
        for(int j=1;j<=m;j++)
        {
            N[i][j]=x[j-1]-48;
            book[i][j]=0;
        }
    }
    bfs();
}

总结

  根据题意来选择具体的方法，要求次数就需要dfs搜索所有的可能，利用比较好的剪枝来优化算法，求最小的可能，就要用bfs，创建节点结构体，利用queue数据结构，完成本题的解答。代码还可以写的更加简洁一些。

关于bfs的一些总结，在基于青蛙跳杯子的bfs总结（补充）中有所补充。