POJ3083 Children of the Candy Corn（Bfs + Dfs)

题意：给一个w*h的迷宫，其中矩阵里面 S是起点，E是终点，“#”不可走，“.”可走，而且，S、E都只会在边界并且，不会在角落，例如（0，0），输出的话，每组数据就输出三个整数，第一个整数，指的是，以S的起点为当前所对着的路径为正方向，如果正方向的左边能走的话，就走左边，不能就按正方向走，不行的话就就往回走，如此反复，记录步数，并输出，第二个整数也是如此，只不过搜的方向改成正方向的右边。第三个就是最短路，

分析：前两个用DFS求出，最短路直接BFS解决，，

单就沿着左走看一下：

当前方向 　　    检索顺序

Sx=n-1   ↑ ：    　　← ↑ → ↓

Sy=0    → ：    　   ↑ → ↓ ←

Sx=0    ↓ ：    　　→ ↓ ← ↑

Sy=n-1   ← ：    　   ↓ ← ↑ →

如此，规律很明显，假设数组存放方向为 ← ↑ → ↓， 如果当前方向为 ↑， 就从 ← 开始依次遍历，找到可以走的，如果 ← 可以走，就不用再看 ↑ 了。

这个题的麻烦处理就在于怎么按什么样的顺序dfs

在网上搜题解感觉这种想法特别好，不繁琐，代码还简洁

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>

using namespace std;

int dx[4]={0,-1,0,1};
int dy[4]={-1,0,1,0};

int dl[4][2]={{0,-1},{-1,0},{0,1},{1,0}};
int dr[4][2]={{0,1},{-1,0},{0,-1},{1,0}};

int sx,sy,ex,ey,n,m;
char G[110][110];

struct node
{
    int x,y,s;
};

int dfs(int x,int y,int d,int step,int dir[4][2])
{
    for(int i=0;i<4;++i)
    {
        int j=((d-1+4)%4+i)%4;
        int nx=x+dir[j][0];
        int ny=y+dir[j][1];
        if(nx==ex&&ny==ey)
            return step+1;
        if(nx<0||ny<0||nx>n||ny>m||G[nx][ny]=='#')
            continue;
        return dfs(nx,ny,j,step+1,dir);
    }
}

int BFS(int sx,int sy)
{
    bool vis[110][110];
    memset(vis, false, sizeof(vis));
    queue<node>q;
    node a;
    a.x=sx,a.y=sy,a.s=1;
    q.push(a);
    vis[sx][sy]=true;
    while(!q.empty())
    {
        node p=q.front();
        q.pop();
        if(p.x==ex&&p.y==ey)
            return p.s;
        node p1;
        for(int i=0;i<4;++i) {
            p1.x=p.x+dx[i];
            p1.y=p.y+dy[i];
            p1.s=p.s+1;
            if(p1.x<0||p1.x>n||p1.y<0||p1.y>m||vis[p1.x][p1.y])
               continue;
            if(G[p1.x][p1.y]!='#')
            {
                vis[p1.x][p1.y]=true;
                q.push(p1);
            }
        }
    }
    return -1;
}

int main()
{
    int T,d1,d2;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&m,&n);
        for(int i=0;i<n;++i)
        {
            scanf("%s",G[i]);
            for(int j=0;j<m;++j)
            {
                if(G[i][j]=='S')
                {
                    sx=i;
                    sy=j;
                }
                else if(G[i][j]=='E')
                {
                    ex=i;
                    ey=j;
                }
            }
        }
        if(sx==0)
        {
            d1=3;
            d2=3;
        }
        else if(sx==n-1)
        {
            d1=1;
            d2=1;
        }
        else if(sy==0)
        {
            d1=2;
            d2=0;
        }
        else if(sy==m-1)
        {
            d1=0;
            d2=2;
        }
        printf("%d ",dfs(sx,sy,d1,1,dl));
        printf("%d ",dfs(sx,sy,d2,1,dr));
        printf("%d
",BFS(sx,sy));
    }
    return 0;
}