Codeforces Round #354 (Div. 2) D. Theseus and labyrinth（bfs）

题意：给出一个n*m的地图，英雄从(xt,yt)出发，要到达敌人所在地(xm,ym)。地图每个格子有设定：

^>v<代表向箭头方向有门，其他方向没门；

URDL代表某个方向没门，其他方向都有门，例如U，代表上面没门，其他3个方向各有一个门。

-|代表左右有门、上下有门。

+代表4个门，*代表没有门。

每分钟，英雄可以进行一项操作：

A.将所有方块顺时针转90度。

B.移动到相邻方块，要求自己方块到它的方向有门，它的方块到自己的方向也有门。

给出地图、英雄位置、敌人位置，求英雄到达敌人的最少分钟数，或者不能到达输出-1。

题解：

走迷宫，典型的广搜题。广搜每个节点有5种扩展：旋转90度、往4个方向走。注意记录某个点是否走过，需要save[x][y][z]，x,y为该点坐标，z为旋转的次数，z<=3。

比较难写的是判断某个点能否向某个方向走一步，可以写到一个函数里can(x,y,z,j)，(x,y)为当前坐标，z为当前旋转了几次(0~3)，j为方向，我设定方向0123代表上右下左。

方块旋转、门的位置可以预处理，记到一个数组里，例如rot['<'][2] = '>'，代表<符号旋转2次得到>符号。

例如door['-'] = "0101"，代表-符号的门开在右、左。

这块写好了就无敌了。

（可恶，刚才看官方题解，哇，直接预处理出4种方向的地图，a[x][y][z]，就是简单的三维地图bfs了，卧槽，我怎么没想到）

//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<cmath>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
#include<set>
#include<stack>
#include<queue>
using namespace std;

#define MZ(array) memset(array, 0, sizeof(array))
#define MF1(array) memset(array, -1, sizeof(array))
#define MINF(array) memset(array, 0x3f, sizeof(array))
#define REP(i,n) for(i=0;i<(n);i++)
#define FOR(i,x,n) for(i=(x);i<=(n);i++)
#define ROF(i,x,y) for(i=(x);i>=(y);i--)
#define RD(x) scanf("%d",&x)
#define RD2(x,y) scanf("%d%d",&x,&y)
#define RD3(x,y,z) scanf("%d%d%d",&x,&y,&z)
#define RD4(x,y,z,w) scanf("%d%d%d%d",&x,&y,&z,&w)
#define WN(x) printf("%d\n",x);
#define RE  freopen("D.in","r",stdin)
#define WE  freopen("huzhi.txt","w",stdout)
#define MP make_pair
#define PB push_back
#define PF push_front
#define PPF pop_front
#define PPB pop_back
#define lowbit(x) ((x)&(-x))
template<class T>inline void OA(const T &a,const int &st,const int &ed) {
    if(ed>=st)cout<<a[st];
    int i;
    FOR(i,st+1,ed)cout<<' '<<a[i];
    puts("");
}
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int,int> PII;
const double PI=acos(-1.0);
const double EPS=1e-10;
inline int sgn(double &x) {
    if(fabs(x) < EPS)return 0;
    if(x < 0)return -1;
    else return 1;
}
const int INF=0x3f3f3f3f;
const int NINF=0x80000001;
const int MAXN=1111;
const int MAXM=33;
const int MOD = 1000000007;
const int gx[4] = {-1,0,1,0};
const int gy[4] = {0,1,0,-1};
int n,m;
char s[MAXN][MAXN];
int xt,yt,xm,ym;

int save[MAXN][MAXN][4];
char rota[222][4];
char door[222][5];
void init() {
    int i,j;
    MF1(save);
    REP(i,4) {
        rota['+'][i]='+';
        rota['*'][i]='*';
    }
    for(i=0; i<4; i+=2) {
        rota['-'][0+i]='-';
        rota['|'][0+i]='|';
        rota['-'][1+i]='|';
        rota['|'][1+i]='-';
    }
    char q[5] = "^>v<";
    char w[5] = "URDL";
    REP(i,4) {
        REP(j,4) {
            int l=(i+j)%4;
            rota[q[i]][j] = q[l];
            rota[w[i]][j] = w[l];
        }
    }
    REP(i,4) {
        door['+'][i]='1';
        door['*'][i]='0';
        door['|'][i]=door['-'][i]='0';
    }
    door['|'][0]=door['|'][2] = '1';
    door['-'][1]=door['-'][3] ='1';
    REP(i,4)REP(j,4) {
        door[q[i]][j]='0';
        door[w[i]][j]='1';
    }
    REP(i,4) {
        door[q[i]][i]='1';
        door[w[i]][i]='0';
    }
}

char rot(char x, int n) {
    return rota[x][n%4];
}

bool cango(char now , char next, int j) {
    int k = (j+2)%4;
//    door[now][4]='\0';
//    door[next][4]='\0';
//    printf("%c,%c,%s,%s,%d,%d,%c,%c\n",now,next,door[now],door[next],j,k,door[now][j],door[next][k]);
    if (door[now][j]=='1' && door[next][k]=='1')return true;
    else return false;
}

bool can(int x,int y,int z,int j) {
    int xx=x+gx[j];
    int yy=y+gy[j];
    if(xx<0 || xx>=n || yy<0 || yy>=m)return false;
    char now = s[x][y];
    char next = s[xx][yy];
//    printf("%c,%c %d->",now,next,z);
    now = rot(now, z);
    next = rot(next,z);
//    printf("%c,%c\n",now,next);
    if(cango(now,next,j))return true;
    else return false;
}

struct Node {
    int x,y,z;
    int step;
    Node() {}
    Node(int _x,int _y,int _z,int _s) {
        x=_x;
        y=_y;
        z=_z;
        step=_s;
    }
};

int farm() {
    deque<Node> d;
    int i,j;
    d.clear();
    d.push_back(Node(xt,yt,0,0));
    save[xt][yt][0]=0;
    while(!d.empty()) {
        Node now = d.front();
        int x=now.x, y=now.y, z=now.z, step=now.step;
        d.pop_front();
//        if(x==19 && z==1)printf("%d,%d,%d,%d\n",x,y,z,step);
        if(x==xm && y==ym)return step;

        int k = (z+1)%4;
        if(save[x][y][k]==-1 || save[x][y][k]>step+1) {
            d.push_back(Node(x, y, k, step+1));
            save[x][y][k]=step+1;
        }

        REP(i,4) {
            int xx=x+gx[i];
            int yy=y+gy[i];
//            printf("%d,%d,%d,%d,%d,[%d,%d,%d],%d\n",x,y,z,i,can(x,y,z,i),xx,yy,z,save[xx][yy][z]);
            if(can(x,y,z,i)&&(save[xx][yy][z]==-1 || save[xx][yy][z]>step+1)) {
                d.push_back(Node(xx,yy,z,step+1));
                save[xx][yy][z]=step+1;
            }
        }
    }
    return -1;
}

int main() {
    int i;
    init();
    RD2(n,m);
    REP(i,n)scanf(" %s",s[i]);
    RD2(xt,yt);
    RD2(xm,ym);
    xt--;
    yt--;
    xm--;
    ym--;
    WN(farm());
    return 0;
}