poj3080 Children of the Candy Corn

最新推荐文章于 2020-09-09 18:31:09 发布

_Ngone

最新推荐文章于 2020-09-09 18:31:09 发布

阅读量407

点赞数

分类专栏：搜索

本文链接：https://blog.csdn.net/u012914220/article/details/25907499

版权

搜索专栏收录该内容

7 篇文章 0 订阅

订阅专栏

链接：http://poj.org/problem?id=3083

题意：从起点S到终点E，求始终向左贴墙走到终点的步数，向右贴墙走到终点的步数，最少需要走的步数。

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<string>
#include<vector>
#include<queue>
#include<stack>
#define MAXN 1605
#define MAX 45
using namespace std;
int maze[MAX][MAX],vist[MAX][MAX];
int q[MAXN];
int h,w;
int si,sj,ei,ej;
int minpath,path;
int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};
//以左方向为例（其实右方向走的步数等于从终点到起点按左方向走的步数）
//走的顺序依次是：左、前、右、后
int DFS(int x,int y,int m,int n,int dir)//（x,y）深搜起点，（m,n）终点，dir深搜起点的方向
{
    if(x==m&&y==n)
        return path;
    int pos;
    for(int i=0;i<4;i++)
    {
        if(dir==0||dir==2)
            pos=(dir+i)%4;   //在该dir方向下，i=0为向左走的pos，下同
        else
            pos=(i+dir+2)%4;
        int sx=(x+dx[pos]);
        int sy=(y+dy[pos]);
        int flag=0;
        if(0<=sx&&sx<h&&sy>=0&&sy<w)
        {
            if(maze[sx][sy])
            {
                dir=(5+dir-i)%4;//调整方向
                path++;
                DFS(sx,sy,m,n,dir);
                flag=1;
                break;
            }
            if(flag)   //因为始终沿着墙的一个方向走（左或右），所以路径必唯一
                break; //返回之后就不用再搜下去了
        }
    }
    return path;
}

int BFS(int si,int sj,int ei,int ej)
{
    int front,tail;
    int u=si*w+sj;
    front=tail=0;
    vist[si][sj]=1;
    q[tail++]=u;
    while(front<tail)
    {
        u=q[front++];
        int x=u/w;
        int y=u%w;
        for(int i=0;i<4;i++)
        {
            int sx=x+dx[i];
            int sy=y+dy[i];
            if(0<=sx&&sx<h&&0<=sy&&sy<w&&maze[sx][sy]&&!vist[sx][sy])
            {
                maze[sx][sy]=maze[x][y]+1;
                vist[sx][sy]=1;
                u=sx*w+sy;
                q[tail++]=u;
                if(sx==ei&&sy==ej)
                    return maze[sx][sy];
            }
        }
    }
    return 0;
}
int main()
{
    int test,direction;
    char s[MAX][MAX];
    scanf("%d",&test);
    while(test--)
    {
        scanf("%d%d",&w,&h);
        memset(maze,0,sizeof(maze));
        for(int i=0;i<h;i++)
        {
            scanf("%s",s[i]);
            for(int j=0;j<w;j++)
            {
                    if(s[i][j]=='#')
                    {
                        maze[i][j]=0;
                    }
                    if(s[i][j]=='.')
                    {
                        maze[i][j]=1;
                    }
                    if(s[i][j]=='S')
                    {
                        si=i,sj=j;
                        maze[i][j]=1;
                    }
                    if(s[i][j]=='E')
                    {
                        ei=i,ej=j;
                        maze[i][j]=1;
                    }
            }

        }
        //假定起点的初始方向（这个由自己设置）
        if(sj==0)direction=1;
        else if(si==0) direction=2;
        else if(sj==w-1)direction=3;
        else direction=0;
        path=1;
        int lp=DFS(si,sj,ei,ej,direction);
        path=1;
        int rp=DFS(ei,ej,si,sj,(direction+2)%4);
        path=1;
        memset(vist,0,sizeof(vist));
        int minp=BFS(si,sj,ei,ej);
        printf("%d %d %d\n",lp,rp,minp);
    }
    return 0;
}