HDU 1180 诡异的楼梯【BFS广搜+优先队列】

诡异的楼梯

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others)
Total Submission(s): 12958    Accepted Submission(s): 3260

Problem Description

Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的，相反,他们每隔一分钟就变动一次方向. 
比如下面的例子里,一开始楼梯在竖直方向,一分钟以后它移动到了水平方向,再过一分钟它又回到了竖直方向.Harry发现对他来说很难找到能使得他最快到达目的地的路线,这时Ron(Harry最好的朋友)告诉Harry正好有一个魔法道具可以帮助他寻找这样的路线,而那个魔法道具上的咒语,正是由你纂写的. 

 

Input

测试数据有多组，每组的表述如下：
第一行有两个数,M和N,接下来是一个M行N列的地图,'*'表示障碍物,'.'表示走廊,'|'或者'-'表示一个楼梯,并且标明了它在一开始时所处的位置:'|'表示的楼梯在最开始是竖直方向,'-'表示的楼梯在一开始是水平方向.地图中还有一个'S'是起点,'T'是目标,0<=M,N<=20,地图中不会出现两个相连的梯子.Harry每秒只能停留在'.'或'S'和'T'所标记的格子内.

 

Output

只有一行,包含一个数T,表示到达目标的最短时间. 
注意:Harry只能每次走到相邻的格子而不能斜走,每移动一次恰好为一分钟,并且Harry登上楼梯并经过楼梯到达对面的整个过程只需要一分钟,Harry从来不在楼梯上停留.并且每次楼梯都恰好在Harry移动完毕以后才改变方向.

 

Sample Input

  
  

   
   5 5
**..T
**.*.
..|..
.*.*.
S....
  
  

 

Sample Output

  
  

   
   7


   
   

    
    

     
     Hint
    
    
Hint
   
   
   
    
地图如下：

   
   
  
  

 

 

注意：桥不能被标记

**67T

**5*6

23345

1*3*5

01234

当从 （4,0）点遍历第三层 （2,1）（3,2）（4,3）后

（2,1）->(2,3)

而（3,2）也要走桥 但是要在原地先暂停一秒 如果T在（1,2）只用5步可以到

所以桥不能被标记

优先队列 和 普通队列

在这道题中，优先队列直接用最短的时间找 一旦到达T即找到正确的输出最小步。

如果用普通队列，要在所有找到终点T后比较所有的路径 比较出最小值，再返回

所以用优先队列是极好的~~~

/*
    注意：楼梯是动态的 最开始当做固定值 计算

*/
#include<stdio.h>
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
char map[25][25];
int vis[25][25];
int m,n,flag;
int num[400005];
int ax,ay,nnx,nny;
int step[4][2]= {1,0,-1,0,0,1,0,-1};
struct node
{
    int x,y,step;
    friend bool operator<(node a,node b)
    {
        return a.step>b.step;
    }
};
bool check(node a)
{
    if(a.x<0||a.y<0||a.x>=m||a.y>=n)//越界
        return false;
    if(vis[a.x][a.y]==true)//没走过
        return false;
    if(map[a.x][a.y]=='*')//墙
        return false;
    return true;
}
void BFS()
{
    memset(vis,false,sizeof(vis));
    vis[ax][ay]=true;
    priority_queue<node>q;
    node a,n;
    a.x=ax;
    a.y=ay;
    a.step=0;
    q.push(a);
    while(!q.empty())
    {
        a=q.top();
        q.pop();
        if(map[a.x][a.y]=='T')
        {
            printf("%d\n",a.step);
            return ;
        }
        printf("%d %d %d\n",a.x,a.y,a.step);
        for(int i=0; i<4; i++)
        {
            n.x=a.x+step[i][0];
            n.y=a.y+step[i][1];

            if(check(n))//新的点没有越界，不是墙，没被标记过
            {
                node nn;
                if(map[n.x][n.y]=='.'||map[n.x][n.y]=='T')
                {
                    n.step=a.step+1;
                    vis[n.x][n.y]=true;
                    q.push(n);
                    continue;//这里忘记了
                }
                else if(i==1||i==0)  //上下
                {
                    if(map[n.x][n.y]=='|'&&a.step%2==0)
                    {

                        nn.x=n.x+step[i][0];
                        nn.y=n.y+step[i][1];
                        if(check(nn))//确认过楼梯后的点是能走的
                        {
                            vis[nn.x][nn.y]=true;
                            nn.step=a.step+1;
                            q.push(nn);
                        }
                    }
                    else if(map[n.x][n.y]=='-'&&a.step%2==1)
                    {
                        nn.x=n.x+step[i][0];
                        nn.y=n.y+step[i][1];
                        if(check(nn))
                        {
                            vis[nn.x][nn.y]=true;
                            nn.step=a.step+1;
                            q.push(nn);
                        }
                    }
                    else
                    {
                        n.x=a.x;
                        n.y=a.y;
                        n.step=a.step+1;
                        vis[n.x][n.y]=true;
                        q.push(n);
                    }
                }
                else
                {
                    if(map[n.x][n.y]=='|'&&a.step%2==1)
                    {

                        nn.x=n.x+step[i][0];
                        nn.y=n.y+step[i][1];
                        if(check(nn))
                        {
                            vis[nn.x][nn.y]=true;
                            nn.step=a.step+1;
                            q.push(nn);
                        }
                    }
                    else if(map[n.x][n.y]=='-'&&a.step%2==0)
                    {

                        nn.x=n.x+step[i][0];
                        nn.y=n.y+step[i][1];
                        if(check(nn))
                        {
                            vis[nn.x][nn.y]=true;
                            nn.step=a.step+1;
                            q.push(nn);
                        }
                    }
                    else
                    {
                        n.x=a.x;
                        n.y=a.y;
                        n.step=a.step+1;
                        vis[n.x][n.y]=true;
                        q.push(n);
                    }
                }
            }
        }
    }
}
int main (void)
{

    while(~scanf("%d%d",&m,&n))
    {
        for(int i=0; i<m; i++)
        {
            scanf("%s",map[i]);
            for(int ii=0; ii<n; ii++)
            {
                if(map[i][ii]=='S')
                {
                    ax=i;
                    ay=ii;
                }
            }
        }
        BFS();
    }
    return 0;
}