UVA 816 有点绕的迷宫

题意：一个迷宫，每个点限制了从哪一方向来的，只能往左右前走，然后问起点到终点的最短路径  具体细节看题目好了

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<vector>
using namespace std;
typedef long long ll;
typedef pair<int,int> pp;
#define inf 0x3f3f3f3f
#define eps 1e-10
#define maxl 505
#define mem(i,j) memset(i,j,sizeof(i))
const int mod=1e9+7;
const double pi=acos(-1);
int r1,c1,r2,c2,dir;
int d[maxl][maxl][4];
int has_edge[maxl][maxl][4][3];
int load[maxl][maxl];

struct node{
    int r,c,dir;
    node(int r1,int c1,int dir1){
        r=r1;c=c1;dir=dir1;
    }
    node(){}
};
node p[maxl][maxl][4];
const char *dirs="NESW";//把走向换为数字表示 下面函数实现相对的功能 顺时针
const char *turns="FLR";//把方向也换为数字  下面函数实现相对的功能
int dir_id(char c){return strchr(dirs,c)-dirs;}
int turn_id(char c) {return strchr(turns,c)-turns;}
int dx[4]={-1,0,1,0};int dy[4]={0,1,0,-1};//这里的定义要对应上面的turns
node walk(node &u,int turn){
    int dir=u.dir;
    //为0 直走 所以不用换向
    if(turn==1) dir=(dir+3)%4;//为1 向左 对照上面就知道是顺指针走3步
    if(turn==2) dir=(dir+1)%4;//为3 向右 对照上面就知道是顺指针走1步
    return node(u.r+dx[dir],u.c+dy[dir],dir);
}

bool inside(int i,int j){//存在的话就代表有路况信息
    if(load[i][j]==1) return true;
    return false;
}

void print(node u){
    vector<node> nodes;
    for(;;){
        nodes.push_back(u);
        if(d[u.r][u.c][u.dir]==0)break;
        u=p[u.r][u.c][u.dir];
    }
   // nodes.push_back(node(r1,c1,dir));
    int cnt=0;
    for(int i=nodes.size()-1;i>=0;i--){
        if(cnt%10==0) cout<<" ";
        printf(" (%d,%d)",nodes[i].r,nodes[i].c);
        if(++cnt%10==0) cout<<"\n";
    }
    if(nodes.size()%10!=0) cout<<"\n";
}


void solve(){
    queue<node> q;
    memset(d,-1,sizeof(d));
    node u(r1,c1,dir);
    d[u.r][u.c][u.dir]=0;
    q.push(u);
    while(!q.empty()){
        node u=q.front();q.pop();
       // cout<<u.r<<' '<<u.c<<' '<<u.dir<<endl;
        if(u.r==r2&&u.c==c2) {print(u);return ;}
        for(int i=0;i<3;i++){
            node v=walk(u,i);
          //  cout<<v.r<<' '<<v.c<<' '<<v.dir<<endl;
            if(has_edge[u.r][u.c][u.dir][i]&&inside(v.r,v.c)&&d[v.r][v.c][v.dir]<0){
                d[v.r][v.c][v.dir]=d[u.r][u.c][u.dir]+1;
                p[v.r][v.c][v.dir]=u;
                q.push(v);
            }
        }
    }
    printf("  No Solution Possible\n");
}



int main()
{
    freopen("in.txt", "r", stdin);
    string s;
    while(cin>>s){
        if(s=="END") break;
        memset(has_edge,0,sizeof(has_edge));
        memset(load,0,sizeof(load));
        cout<<s<<endl;
        char c;
        cin>>r1>>c1>>c>>r2>>c2;
        load[r1][c1]=1;load[r2][c2]=1;
        dir=dir_id(c);
        has_edge[r1][c1][dir][0]=1;
        int x,y;string s1;
        while(cin>>x){
            if(x==0) break;
            cin>>y;
            load[x][y]=1;
            while(cin>>s1){
                if(s1=="*") break;
                node u1;
                u1.dir=dir_id(s1[0]);
                u1.r=x;u1.c=y;
                for(int i=1;s1[i];i++){
                    has_edge[u1.r][u1.c][u1.dir][turn_id(s1[i])]=1;
                }
            }
        }
        solve();
    }
}