hdu 诡异的楼梯

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

题目感觉有点坑。

分析：注意因为可以停留在'.'或'S'和'T'所标记的格子内.但是我们只要在楼梯口的格子停留就好了而且只是在楼梯的方向不能过时停留，能过则过，所以我用vis数组来记录楼梯口的格子的停留数，不能超过2.然后遇到楼梯就直接过，但是要注意楼梯的方向，还要注意的就是，楼梯的变化，当时间t为偶数时变化到原来的状态，奇数则改变，这样就简单了，最后再用优先队列就可以解决了。ac代码：不过网上有很多讨论说这题数据太少了，比较水。

#include <iostream>
#include<string.h>
#include<stdio.h>
#include<queue>
using namespace std;
struct node
{
    int x,y,t;
    node (int x,int y,int t) :x(x),y(y),t(t) {}
    bool operator <(const node &a) const
    {
        return t>a.t;
    }
};
int n,m,t,e,vis[25][25];
int f[4][2]= {{0,1},{0,-1},{1,0},{-1,0}};//z y s x
//int sf[2][2]= {{1,0},{-1,0}},zf[2][2]= {{0,1},{0,-1}};
char s[25][25];
int main()
{
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        gets(s[0]);
        memset(vis,0,sizeof(vis));
        for(int i=0; i<n; i++)
        {
            gets(s[i]);
            for(int j=0; j<m; j++)
            {
                if(s[i][j]=='S')
                {
                    t=i,e=j;
                }
            }
        }
        node v(0,0,0);
        queue<node>q;
        q.push(node(t,e,0));
        int T=10000;
        while(!q.empty())
        {
            v=q.front();
            q.pop();
            if(s[v.x][v.y]=='T')
            {
                T=v.t;
                //cout<<v.t<<endl;
                break;
            }
            for(int i=0; i<4; i++)
            {
                int r,c;
                r=v.x+f[i][0],c=v.y+f[i][1];
                if(r>=0&&r<n&&c>=0&&!vis[r][c]&&c<m&&s[r][c]!='*')
                {
                    if(s[r][c]=='|'||s[r][c]=='-')
                    {
                        int g=1;
                        if(s[r][c]=='-') g=0;
                        int l=(g+v.t)%2;
                        if(l)// |
                        {
                            if(i<2&&vis[v.x][v.y]<=2)//楼梯方向不同，要等一分钟。
                            {
                                vis[v.x][v.y]+=1;
                                q.push(node(v.x,v.y,v.t+1));
                            }
                            else
                            {
                                int a=r+f[i][0],b=c+f[i][1];
                                if(!vis[a][b]&&a>=0&&a<n&&b>=0&&b<m&&s[a][b]!='*')
                                {
                                    vis[a][b]+=1;
                                    q.push(node(a,b,v.t+1));
                                }
                            }
                        }
                        else // -
                        {
                            if(i>=2&&vis[v.x][v.y]<=2)
                            {
                               // if()
                                vis[v.x][v.y]+=1;
                                q.push(node(v.x,v.y,v.t+1));
                            }
                            else
                            {
                                int a=r+f[i][0],b=c+f[i][1];
                                if(!vis[a][b]&&a>=0&&a<n&&b>=0&&b<m&&s[a][b]!='*')
                                {
                                    vis[a][b]+=1;
                                    q.push(node(a,b,v.t+1));
                                }
                            }
                        }
                    }
                    else
                    {
                        vis[r][c]=+1;
                        q.push(node(r,c,v.t+1));
                    }
                }
            }
        }
        cout<<T<<endl;
    }
    return 0;
}

突然发现不用记录格子的访问数量，当遇到楼梯过不去就等一分钟，加到队列后，那么假一分钟后他肯定能过楼梯，所以不用当心队列太大。

：

#include <iostream>
#include<string.h>
#include<stdio.h>
#include<queue>
using namespace std;
struct node
{
    int x,y,t;
    node (int x,int y,int t) :x(x),y(y),t(t) {}
    bool operator <(const node &a) const
    {
        return t>a.t;
    }
};
int n,m,t,e,vis[25][25];
int f[4][2]= {{0,1},{0,-1},{1,0},{-1,0}};//z y s x
//int sf[2][2]= {{1,0},{-1,0}},zf[2][2]= {{0,1},{0,-1}};
char s[25][25];
int main()
{
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        gets(s[0]);
        memset(vis,0,sizeof(vis));
        for(int i=0; i<n; i++)
        {
            gets(s[i]);
            for(int j=0; j<m; j++)
            {
                if(s[i][j]=='S')
                {
                    t=i,e=j;
                }
            }
        }
        node v(0,0,0);
        queue<node>q;
        q.push(node(t,e,0));
        int T=10000;
        while(!q.empty())
        {
            v=q.front();
            q.pop();
            if(s[v.x][v.y]=='T')
            {
                T=v.t;
                //cout<<v.t<<endl;
                break;
            }
            for(int i=0; i<4; i++)
            {
                int r,c;
                r=v.x+f[i][0],c=v.y+f[i][1];
                if(r>=0&&r<n&&c>=0&&!vis[r][c]&&c<m&&s[r][c]!='*')
                {
                    if(s[r][c]=='|'||s[r][c]=='-')
                    {
                        int g=1;
                        if(s[r][c]=='-') g=0;
                        int l=(g+v.t)%2;
                        if(l)// |
                        {
                            if(i<2)
                            {
                                vis[v.x][v.y]+=1;
                                q.push(node(v.x,v.y,v.t+1));
                            }
                            else
                            {
                                int a=r+f[i][0],b=c+f[i][1];
                                if(!vis[a][b]&&a>=0&&a<n&&b>=0&&b<m&&s[a][b]!='*')
                                {
                                    vis[a][b]+=1;
                                    q.push(node(a,b,v.t+1));
                                }
                            }
                        }
                        else // -
                        {
                            if(i>=2)
                            {

                               q.push(node(v.x,v.y,v.t+1));
                            }
                            else
                            {
                                int a=r+f[i][0],b=c+f[i][1];
                                if(!vis[a][b]&&a>=0&&a<n&&b>=0&&b<m&&s[a][b]!='*')
                                {
                                    vis[a][b]+=1;
                                    q.push(node(a,b,v.t+1));
                                }
                            }
                        }
                    }
                    else
                    {
                        vis[r][c]=+1;
                        q.push(node(r,c,v.t+1));
                    }
                }
            }
        }
        cout<<T<<endl;
    }
    return 0;
}