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[]={,-,,};
 int dy[]={-,,,};
 
 int dl[][]={{,-},{-,},{,},{,}};
 int dr[][]={{,},{-,},{,-},{,}};
 
 int sx,sy,ex,ey,n,m;
 char G[][];
 
 struct node
 {
     int x,y,s;
 };
 
 int dfs(int x,int y,int d,int step,int dir[][])
 {
     for(int i=;i<;++i)
     {
         int j=((d-+)%+i)%;
         int nx=x+dir[j][];
         int ny=y+dir[j][];
         if(nx==ex&&ny==ey)
             return step+;
         if(nx<||ny<||nx>n||ny>m||G[nx][ny]=='#')
             continue;
         return dfs(nx,ny,j,step+,dir);
     }
 }
 
 int BFS(int sx,int sy)
 {
     bool vis[][];
     memset(vis, false, sizeof(vis));
     queue<node>q;
     node a;
     a.x=sx,a.y=sy,a.s=;
     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=;i<;++i) {
             p1.x=p.x+dx[i];
             p1.y=p.y+dy[i];
             p1.s=p.s+;
             if(p1.x<||p1.x>n||p1.y<||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 -;
 }
 
 int main()
 {
     int T,d1,d2;
     scanf("%d",&T);
     while(T--)
     {
         scanf("%d%d",&m,&n);
         for(int i=;i<n;++i)
         {
             scanf("%s",G[i]);
             for(int j=;j<m;++j)
             {
                 if(G[i][j]=='S')
                 {
                     sx=i;
                     sy=j;
                 }
                 else if(G[i][j]=='E')
                 {
                     ex=i;
                     ey=j;
                 }
             }
         }
         if(sx==)
         {
             d1=;
             d2=;
         }
         else if(sx==n-)
         {
             d1=;
             d2=;
         }
         else if(sy==)
         {
             d1=;
             d2=;
         }
         else if(sy==m-)
         {
             d1=;
             d2=;
         }
         printf("%d ",dfs(sx,sy,d1,,dl));
         printf("%d ",dfs(sx,sy,d2,,dr));
         printf("%d\n",BFS(sx,sy));
     }
     return ;
 }