HDU 1728 逃离迷宫 单方向BFS 或者DFS加剪枝

逃离迷宫

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 18519    Accepted Submission(s): 4463

Problem Description

　　给定一个m × n (m行, n列)的迷宫，迷宫中有两个位置，gloria想从迷宫的一个位置走到另外一个位置，当然迷宫中有些地方是空地，gloria可以穿越，有些地方是障碍，她必须绕行，从迷宫的一个位置，只能走到与它相邻的4个位置中,当然在行走过程中，gloria不能走到迷宫外面去。令人头痛的是，gloria是个没什么方向感的人，因此，她在行走过程中，不能转太多弯了，否则她会晕倒的。我们假定给定的两个位置都是空地，初始时，gloria所面向的方向未定，她可以选择4个方向的任何一个出发，而不算成一次转弯。gloria能从一个位置走到另外一个位置吗？

 

Input

　　第1行为一个整数t (1 ≤ t ≤ 100),表示测试数据的个数，接下来为t组测试数据，每组测试数据中，
　　第1行为两个整数m, n (1 ≤ m, n ≤ 100),分别表示迷宫的行数和列数，接下来m行，每行包括n个字符，其中字符'.'表示该位置为空地，字符'*'表示该位置为障碍，输入数据中只有这两种字符，每组测试数据的最后一行为5个整数k, x₁, y₁, x₂, y₂ (1 ≤ k ≤ 10, 1 ≤ x₁, x₂ ≤ n, 1 ≤ y₁, y₂ ≤ m),其中k表示gloria最多能转的弯数，(x₁, y₁), (x₂, y₂)表示两个位置，其中x₁，x₂对应列，y₁, y₂对应行。

 

Output

　　每组测试数据对应为一行，若gloria能从一个位置走到另外一个位置，输出“yes”，否则输出“no”。

 

Sample Input

2
5 5
...**
*.**.
.....
.....
*....
1 1 1 1 3
5 5
...**
*.**.
.....
.....
*....
2 1 1 1 3

 

Sample Output

no
yes

#include <iostream>
#include <stdio.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
#define N 109
#define INF 0x3f3f3f
using namespace std;

char s[N][N];
int t,n,m;
int sx,sy;
int ex,ey;
int k;
int wan[N][N];

struct Node
{
    int x,y;
}f,g;

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

void bfs()
{
    queue<Node>q;

    f.x=sx;
    f.y=sy;
    q.push(f);
    memset(wan,INF,sizeof wan);
    wan[f.x][f.y]=-1;

    while(!q.empty())
    {
        g=q.front();
        q.pop();

        if(g.x==ex && g.y==ey && wan[g.x][g.y]<=k)
        {
            puts("yes");
            return;
        }

        for(int i=0;i<4;i++)
        {
            f.x=g.x+dis[i][0];
            f.y=g.y+dis[i][1];

            while(!(f.x<0||f.x>=m ||f.y<0||f.y>=n))
            {
                if(s[f.x][f.y]=='*')
                break;
                if(wan[f.x][f.y]<wan[g.x][g.y]+1)
                break;
                wan[f.x][f.y]=wan[g.x][g.y]+1;

                if(wan[f.x][f.y]>k)
                break;
                if(wan[f.x][f.y]==k && f.x!=ex && f.y!=ey)
                break;

                q.push(f);

                f.x+=dis[i][0];
                f.y+=dis[i][1];

            }


        }

    }
    puts("no");

}

int main()
{

    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d",&m,&n);
        for(int i=0;i<m;i++)
        scanf("%s",s[i]);

        scanf("%d %d %d %d %d",&k,&sy,&sx,&ey,&ex);
       sy--;
       ey--;
       sx--;
       ex--;

        if(sx==ex && sy==ey)
        {
            cout<<"yes"<<endl;
            continue;
        }

        bfs();

    }

    return 0;
}

#include <iostream>
#include <stdio.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
#define N 109
#define INF 0x3f3f3f
using namespace std;

char s[N][N];
int t,n,m;
int sx,sy;
int ex,ey;
int k;
int wan[N][N];

struct Node
{
    int x,y;
}f,g;

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

int flag;

//void bfs()
//{
//    queue<Node>q;
//
//    f.x=sx;
//    f.y=sy;
//    q.push(f);
//    memset(wan,INF,sizeof wan);
//    wan[f.x][f.y]=-1;
//
//    while(!q.empty())
//    {
//        g=q.front();
//        q.pop();
//
//        if(g.x==ex && g.y==ey && wan[g.x][g.y]<=k)
//        {
//            puts("yes");
//            return;
//        }
//
//        for(int i=0;i<4;i++)
//        {
//            f.x=g.x+dis[i][0];
//            f.y=g.y+dis[i][1];
//
//            while(!(f.x<0||f.x>=m ||f.y<0||f.y>=n))
//            {
//                if(s[f.x][f.y]=='*')
//                break;
//                if(wan[f.x][f.y]<wan[g.x][g.y]+1)
//                break;
//                wan[f.x][f.y]=wan[g.x][g.y]+1;
//
//                if(wan[f.x][f.y]>k)
//                break;
//                if(wan[f.x][f.y]==k && f.x!=ex && f.y!=ey)
//                break;
//
//                q.push(f);
//
//                f.x+=dis[i][0];
//                f.y+=dis[i][1];
//
//            }
//
//
//        }
//
//    }
//    puts("no");
//
//}

void dfs(int x,int y,int dir)
{
    if(x==ex && y==ey && wan[x][y]<=k)
    {
        flag=1;
        return;
    }

    if(wan[x][y]>k)
    return;

    for(int i=0;i<4;i++)
    {
        int xx=x+dis[i][0];
        int yy=y+dis[i][1];

        if(xx<0 || xx>=m || yy<0 || yy>=n || s[xx][yy]=='*' ||wan[xx][yy]<wan[x][y])
        continue;

        if(wan[xx][yy]<wan[x][y]+1 && dir!=-1 && dir!=i)
        continue;

        wan[xx][yy]=wan[x][y];

        if(i!=dir)
        wan[xx][yy]++;

        dfs(xx,yy,i);
        if(flag)
        return;
    }
}

int main()
{

    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d",&m,&n);
        for(int i=0;i<m;i++)
        scanf("%s",s[i]);

        scanf("%d %d %d %d %d",&k,&sy,&sx,&ey,&ex);
       sy--;
       ey--;
       sx--;
       ex--;

        if(sx==ex && sy==ey)
        {
            cout<<"yes"<<endl;
            continue;
        }

        flag=0;
        memset(wan,INF,sizeof wan);
        wan[sx][sy]=-1;

        dfs(sx,sy,-1);
        if(flag)
        puts("yes");
        else
        puts("no");

        //bfs();
    }

    return 0;
}