poj 3083 Children of the Candy Corn 深搜加广搜

错了好多地方，看完别人代码，才做对的。。。。。

 

1.题意：有一个迷宫，#代表墙，..代表能走，S是起点，E是终点W为宽，列数H为高；

先输出左转优先时，从S到E的步数

再输出右转优先时，从S到E的步数

最后输出S到E的最短步数

 

解题思路：

DFS和BFS的综合题，写代码时要注意几方面：

1、 左转、右转优先搜索时必须标记当前位置时的方向，我定义的方向是

    

最初的方向由起点S确定，而下一步的方向则由前一步的走向决定

例如 左边优先搜索：

当前位置的方向指向 1（向左），(这同时说明前一步是在第“3”的位置走过来的)

那么走下一步时，就要根据2103的顺序，先逐格确定当前位置周边的四格是否可行

若第一次确认2可行，就走到2，在位置2时的方向为2（向下）

若2不可行，则再确定1，若1可行，就走到1，在位置1时的方向为1（向左）

  若1也不可行，则再确定0，若0可行，就走到0，在位置0时的方向为0（向上）

  若0也不可行，说明进入了迷宫的死胡同，要从原路返回，走回3

右边优先搜索也同理。

根据我定义的方向，设当前位置为d，那么

左转，用数学式子表达就是  d=(d+1)%4

右转，用数学式子表达就是  d=(d+3)%4     

这里有一点必须要注意的：

左边、右边优先搜索都不是找最短路，因此走过的路可以再走，无需标记走过的格

2、 寻找最短路只能用BFS

因此在做第3问时别傻乎乎的又用DFS，DFS对于样例的输入确实和BFS得到的结果一样的，别以为样例PASS就提交了。。。所以我就说样例没代表性，学会测试数据很重要

注意有一点：

要求E的最短路，必须把迷宫模拟为树，S为根，找到E所在的层（树深），该层就是S到E的最短路，处理技巧就是在BFS时，令queue[tail]的depth等于对应的queue[head]的depth+1，详细见我的程序

把循环的次数作为深度就铁定错的

代码：

#include<stdio.h>
#include<string.h>
struct node
{
    int x;
    int y;
    int step;
}a[1600];
char maze[50][50];
int count,d;
int visit[40][40];
int fx[]= {0,1,0,-1};
int fy[]= {1,0,-1,0};
int fr[]= {1,0,3,2};
int fl[]= {3,0,1,2};
int dir[4][2]={1,0,-1,0,0,1,0,-1};
char sx,sy,ex,ey;
int w,h;
void dfsleft(int d,int x,int y)
{
    int tx,ty;
    if(x==ex&&y==ey)
    {
        printf("%d ",count);
        return ;
    }
    count++;
    for(int j=0;j<4;j++)
    {
        int i=(d+fl[j])%4;
        tx=x+fx[i];
        ty=y+fy[i];
        if(tx>=0&&tx<h&&ty>=0&&ty<w&&maze[tx][ty]!='#')
        {
            dfsleft(i,tx,ty);
            return;
        }
    }
}
void dfsright(int d,int x,int y)
{
    int tx,ty;
    if(x==ex&&y==ey)
    {
        printf("%d ",count);
        return ;
    }
    for(int j=0;j<4;j++)
    {
        int i=(d+fr[j])%4;
        tx=x+fx[i];
        ty=y+fy[i];
        if(tx>=0&&tx<h&&ty>=0&&ty<w&&maze[tx][ty]!='#')
        {
            count++;
            dfsright(i,tx,ty);
            return;
        }
    }
}
void bfs(int sx,int sy)
{ 
    a[0].x=sx;
    a[0].y=sy;
    a[0].step=0;
    int front=0;
    int rear=1;
    int tx,ty;
    memset(visit,0,sizeof(visit));
    visit[sx][sy]=1;
    while(front<rear)
    {
        node cur,exchange;
        cur=a[front++];
        if(cur.x==ex&&cur.y==ey)
        {
            printf("%d\n",cur.step+1);
        }
        for(int i=0;i<4;i++)
        {
            tx=cur.x+dir[i][0];
            ty=cur.y+dir[i][1];
            if(tx>=0&&tx<h&&ty>=0&&ty<w&&visit[tx][ty]==0&&maze[tx][ty]!='#')
            {
                visit[tx][ty]=1;
                exchange.x=tx;
                exchange.y=ty;
                exchange.step=cur.step+1;
                a[rear++]=exchange;
            }
        }
    }
}
int main()
{
    int cases=0;
    scanf("%d",&cases);
    while(cases--)
    {
        scanf("%d%d",&w,&h);
        for(int i=0;i<h;i++)
        {

            scanf("%s",maze[i]);
            for(int j=0;j<w;j++)
            {
                if(maze[i][j]=='S')
                {
                    sx=i;
                    sy=j;
                }
                if(maze[i][j]=='E')
                {
                    ex=i;
                    ey=j;
                }
            }
        }
        if(sx==0)d=0;
        if(sx==h-1)d=2;
        if(sy==0)d=1;
        if(sy==w-1)d=3;
        count=1;
        dfsleft(d,sx,sy);
        count=1;
        dfsright(d,sx,sy);
        bfs(sx,sy);
    }
    return 0;
}