POJ_3083_Children of the Candy Corn(BFS+DFS)

/*

http://poj.org/problem?id=3083

 

  看完题目之后自己心中便已有思路，因为前面做过几道这类搜索的题目了，但是自己真写起来的时候却

不知所措，只好看了 会网上的代码然后再自己写出来。虽然是看别人的但是着实从里面学了不少东西，

我想以后在遇着这种题目已经会个八九成了。

题意：

这道题的意思就是让你找走出迷宫的路径。分为左优先和右优先还有最短路径，输出的也是这三种路径的步数。

思路：1：对于最短路径肯定想到的是用广搜，因为广搜是一层一层的搜，适合这种找最小路径的问题。光搜实现的时候使用的是队列

两个位置变量，一个在首部，一个在尾部。尾部是入队操作，首部是访问操作，直到找到最短路径。队列元素可以使结构体类型，最重要的是保存

树的深度，可以这样理解，因为他是一层一层的访问，如果访问的是同一层他的深度是不加一的。因此队列元素保存的是走到当前位置（或者是在这一层时树的深度）。

这也是广度搜索与深度搜索的区别。

2：对于左优先和右优先的步数，使用的是深度优先搜索，类似于二叉树的前序遍历。即如果一直满足条件就一直搜下去，直到不满足条件后退一步再一直搜下去。

在这道题中，需要注意的是它访问过的点还有可能返回再访问，因此不能使用标记。处理方法就是使用一个方向变量d，d记录的是当前朝哪个方向走，

当三个方向都不满足时，那么只能往回走，此时前方便是往回走的方向，因此保证了他不会第二次回头。

3：还是那句话，对于每个函数，一定要想清楚这个函数的功能是什么。像这里的DFS他就是找左优先的步数，传过去的是起始点意思是说找从这个点

到结束点的步数，函数里面又出现了递归调用（到下一个位置的步数加一即为当前）。

*/

# include <stdio.h>
# include <string.h>
struct node 
{
    int r;
    int c;
    int depth;
};
struct node q,p;
int map[50][50];
int visit[50][50];
int leftstep;
int rightstep;
int shortstep;
void DFS_left(int i,int j,int d)
{
    leftstep++;
    if(i==q.r && j==q.c )
        return ;
    switch (d)
    {
        case 0: 
            {
                if(map[i][j-1])
                    DFS_left(i,j-1,1);
                else if(map[i-1][j])
                    DFS_left(i-1,j,0);
                else if(map[i][j+1])
                    DFS_left(i,j+1,3);
                else
                    DFS_left(i+1,j,2);
                break;
            }
        case 1:
            {
                if(map[i+1][j])
                    DFS_left(i+1,j,2);
                else if(map[i][j-1])
                    DFS_left(i,j-1,1);
                else if(map[i-1][j])
                    DFS_left(i-1,j,0);
                else
                    DFS_left(i,j+1,3);
                break;
            }
        case 2:
            {
                if(map[i][j+1])
                    DFS_left(i,j+1,3);
                else if(map[i+1][j])
                    DFS_left(i+1,j,2);
                else if(map[i][j-1])
                    DFS_left(i,j-1,1);
                else
                    DFS_left(i-1,j,0);
                break;
            }
        case 3:
            {
                if(map[i-1][j])
                    DFS_left(i-1,j,0);
                else if(map[i][j+1])
                    DFS_left(i,j+1,3);
                else if(map[i+1][j])
                    DFS_left(i+1,j,2);
                else
                    DFS_left(i,j-1,1);
                break;
            }

    }
    return ;
}
void DFS_right(int i,int j,int d)
{
    rightstep++;
    if(i==q.r && j==q.c )
        return ;
    switch (d)
    {
        case 0: 
        {
            if(map[i][j+1])
                 DFS_right(i,j+1,3);
            else if(map[i-1][j])
                DFS_right(i-1,j,0);
            else if(map[i][j-1])
                DFS_right(i,j-1,1);
            else
                DFS_right(i+1,j,2);
            break;
        }
        case 1:    
        {
            if(map[i-1][j])
                DFS_right(i-1,j,0);
            else if(map[i][j-1])
                DFS_right(i,j-1,1);
            else if(map[i+1][j])
                DFS_right(i+1,j,2);
            else
                DFS_right(i,j+1,3);
            break;
        }
    case 2:    
        {
            if(map[i][j-1])
                DFS_right(i,j-1,1);
            else if(map[i+1][j])
                DFS_right(i+1,j,2);
            else if(map[i][j+1])
                DFS_right(i,j+1,3);
            else
                DFS_right(i-1,j,0);
            break;
        }
    case 3:    
        {
            if(map[i+1][j])
                DFS_right(i+1,j,2);
            else if(map[i][j+1])
                DFS_right(i,j+1,3);
            else if(map[i-1][j])
                DFS_right(i-1,j,0);
            else
                DFS_right(i,j-1,1);
            break;
        }
        
    }
    return ;
}
void BFS_short(int i,int j)
{
    struct node x,dq[2000]; //dq为队列，临时记录待广搜的点。
    int head=0,tail=0; //Initial;
    dq[head].r=i;
    dq[head].c=j;
    dq[tail++].depth=1;
    visit[i][j]=true;   //
    while(head<tail)
    {
        x=dq[head++];
        if(x.r==q.r  && x.c==q.c)  //找到终点结束
        {
            printf("%d\n",x.depth);
            return ;
        }
        if(map[x.r][x.c-1] && !visit[x.r][x.c-1]) //广搜顺序可调换;如果他们都满足情况都得入队列。
        {
            visit[x.r][x.c-1]=1;
            dq[tail].r=x.r;
            dq[tail].c=x.c-1;
            dq[tail++].depth=x.depth+1;  //广搜深度加1；注意并不是队列加一个元素深度就加1；
                                        //如果在同一层的元素深度不加1；x代表的是上一层。            
        }
        if(map[x.r-1][x.c] && !visit[x.r-1][x.c])
        {
            visit[x.r-1][x.c]=1;
            dq[tail].r=x.r-1;
            dq[tail].c=x.c;
            dq[tail++].depth=x.depth+1;
        }
        if(map[x.r][x.c+1] && !visit[x.r][x.c+1])
        {
            visit[x.r][x.c+1]=1;
            dq[tail].r=x.r;
            dq[tail].c=x.c+1;
            dq[tail++].depth=x.depth+1;
        }
        if(map[x.r+1][x.c] && !visit[x.r+1][x.c])  
        {  
                  visit[x.r+1][x.c]=true;  
                  dq[tail].r=x.r+1;  
                  dq[tail].c=x.c;  
                  dq[tail++].depth=x.depth+1;  
        } 
        
    }
    return ;

}
int main()
{
    int test,i,j,k,m,n,d;
    char ch[50][50];
    scanf("%d",&test);
    while(test--)
    {
        scanf("%d%d",&m,&n);
        getchar();
        for(i=0;i<n;i++)
            scanf("%s",ch[i]);
        memset(map,0,sizeof(map));    //地图
        memset(visit,0,sizeof(visit));//visit初始化都没被访问过
        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)
            {
                if(ch[i][j] == '.')
                    map[i+1][j+1]=1;
                else if(ch[i][j]=='S')
                {
                    map[i+1][j+1]=1;
                    visit[i+1][j+1]=1;
                    p.r=i+1; //记录起点
                    p.c=j+1;
                    if(i+1==n) //记录第一步走的方向。
                        d=0; //朝上
                    else if(i+1==1)
                        d=2; //朝下
                    else if(j+1==m)
                        d=1; //朝左
                    else if(j+1==1)
                        d=3; //朝右
                }
                else if(ch[i][j]=='E')
                {
                    map[i+1][j+1]=1;
                    q.r=i+1; //记录终点；
                    q.c=j+1;
                }
            }
        }

        //left_step;
        leftstep=1;
        switch(d)
        {
            case 0: {DFS_left(p.r-1,p.c,0);break;}//0朝上，上走一步行减1；
            case 1: {DFS_left(p.r,p.c-1,1);break;}//1朝左，左走一步列减1；
            case 2: {DFS_left(p.r+1,p.c,2);break;}//2朝上
            case 3: {DFS_left(p.r,p.c+1,3);break;}//3朝右
        }
        printf("%d ",leftstep);

        //right_step;
        rightstep=1;
        switch(d)
        {
            case 0: {DFS_right(p.r-1,p.c,0);break;}
            case 1: {DFS_right(p.r,p.c-1,1);break;}
            case 2: {DFS_right(p.r+1,p.c,2);break;}
            case 3: {DFS_right(p.r,p.c+1,3);break;}
        }
        printf("%d ",rightstep);

        //shorted_step;
        shortstep=0;
        BFS_short(p.r,p.c); //起点为p开始广搜；
    }
    return 0;
}