HDU 1180 诡异的楼梯

题意：

（中文）

思路：

由于每过1分钟，这个楼梯的通向就会变一次，要走楼梯时，判断一下已经走过的步数是否是偶数，如果是偶数，那么楼梯则没有变，否则，变换楼梯方向。判断一下当前是否可以走这个楼梯，可以走的话，步数就是当前步数+1，否则就是+2（等一分钟再走）。

但是，这里面如果用广搜的话，就会出现这样一个问题：第一个到达的那个点其实并不是最优的步数。例如：

3 4

T…

*-*S

*.|.

如果是这样的话，答案就会是5，但是正确答案却是4。

因为在优先搜索步数的时候，（0，1）这个点已经被标记成不可经过的了（因为下面走楼梯的那条路搜索的时候先到达了（0，1）这个点）。

所以需要有这样一个规则，如果此个地方走过了，只要我到达此个地方的步数少，那么我就还可以走这个地方。

Code：

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<bitset>
#include<queue>
#include<stack>
#include<list>
#include<map>
#include<set>

#define TEST

#define LL long long
#define Mt(f, x) memset(f, x, sizeof(f));
#define rep(i, s, e) for(int i = (s); i <= (e); ++i)
#ifdef TEST
#define See(a) cout << #a << " = " << a << endl;
#define See2(a, b) cout << #a << " = " << a << ' ' << #b << " = " << b << endl;
#define debug(a, s, e) rep(_i, s, e) {cout << a[_i] << ' ';} cout << endl;
#define debug2(a, s, e, ss, ee) rep(i_, s, e) {debug(a[i_], ss, ee)}
#else
#define See(a)
#define See2(a, b)
#define debug(a, s, e)
#define debug2(a, s, e, ss, ee)
#endif // TEST

const int MAX = 2e9;
const int MIN = -2e9;
const double eps = 1e-8;
const double PI = acos(-1.0);

using namespace std;

const int N = 25;

int mv[4][2] = {
{1, 0},
{0, 1},
{-1, 0},
{0, -1}
};
int n, m;
char ch

;
bool v

;
int f

;
int sx, sy, ex, ey;

struct Node
{
int x;
int y;
int tep;
friend bool operator < (Node a, Node b)
{
return a.tep > b.tep;
}
Node(){}
Node(int x, int y, int tep) : x(x), y(y), tep(tep) {}
}st, to;

char getC(char c, int tep)//变换楼梯
{
if(c == '|' || c == '-')
{
if(tep & 1)
{
c = (c == '|' ? '-' : '|');
}
}
return c;
}

bool isOK(int x, int y, int tep)//判断下一个是否可以走，如果走过，那就是步数少于以前步数的情况，可以再次通过。
{
if(x < 0 || y < 0 || x >= n || y >= m)
{
return false;
}
if(v[x][y])
{
if(f[x][y] > tep)
{
return true;
}
return false;
}
return true;

}

int getTep(char c, int i)//判断下一步应该多出几分钟（1分种还是等一会2分种）
{
if(i & 1)
{
if(c == '-')
{
return 1;
}
else
{
return 2;
}
}
else
{
if(c == '|')
{
return 1;
}
else
{
return 2;
}
}
}

int bfs()
{
st = Node(sx, sy, 0);
v[sx][sy] = true;
f[sx][sy] = 0;
priority_queue<Node> Q;
Q.push(st);
while(!Q.empty())
{
st = Q.top(); Q.pop();
//        printf("st.xt = %d st.y = %d st.tep = %d\n", st.x, st.y, st.tep);
if(ch[st.x][st.y] == 'T')
{
return st.tep;
}
for(int i = 0; i < 4; ++i)
{
int x = st.x + mv[i][0];
int y = st.y + mv[i][1];
if(isOK(x, y, st.tep + 1) && ch[x][y] != '*')
{
if(ch[x][y] != '|' && ch[x][y] != '-')
{
v[x][y] = true;
f[x][y] = st.tep + 1;
Q.push(Node(x, y, st.tep + 1));
}
else
{
char c = getC(ch[x][y], st.tep);
int tx = x, ty = y;
if(i & 1)
{
ty += mv[i][1];
}
else
{
tx += mv[i][0];
}
int tep = getTep(c, i);
if(isOK(tx, ty, st.tep + tep) && ch[tx][ty] != '*')
{
v[tx][ty] = true;
f[tx][ty] = st.tep + tep;
Q.push(Node(tx, ty, f[tx][ty]));
}
}
}

}
}
return 0;
}

int main()
{
while(~scanf("%d%d", &n, &m))
{
Mt(v, false);
Mt(f, -1);
for(int i = 0; i < n; ++i)
{
scanf("%s", ch[i]);
for(int k = 0; ch[i][k]; ++k)
{
if(ch[i][k] == 'S')
{
sx = i;
sy = k;
}
}
}
printf("%d\n", bfs());
}
return 0;
}