bfs Abbott的复仇 UVA 816

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<string>
#include<stack>
#include<queue>
#include<vector>
#include<map>
#include<set>
#include<iostream>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int N=1000000009;
struct Node
{
    int r,c,dir;
    Node(int r=0,int c=0,int dir=0):r(r),c(c),dir(dir){}
};
int d[11][11][5],has_edge[11][11][5][4],r1,c1,r2,c2,dir1;
Node p[11][11][5];
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; }
const int dr[]={-1,0,1,0};
const int dc[]={0,1,0,-1};
Node walk(const Node& u,int turn )
{
    int dir = u.dir;
    if(turn==1) dir=(dir+3)%4;
    if(turn==2) dir=(dir+1)%4;
    return Node(u.r+dr[dir],u.c+dc[dir],dir);
}
void print_ans(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,dir1));
    int cnt=0;
    for(int i=nodes.size()-1;i>=0;i--){
        if(cnt%10==0) printf(" ");
        printf(" (%d,%d)",nodes[i].r,nodes[i].c);
        if(++cnt%10==0) printf("\n");
    }
    if(nodes.size()%10!=0) printf("\n");
}
/*void print_ans(Node u)
{
  vector<Node> vec;
  while(1)
  {
    if(d[u.r][u.c][u.dir]==0) break;
    vec.push_back(u);
    u=p[u.r][u.c][u.dir];
  }
  //u.r=r0;u.c=c0;u.dir=dir;
  vec.push_back(Node(r1,c1,dir1));
//  cout<<s1<<endl;
  int cnt=0;
  for(int i=vec.size()-1;i>=0;i--)
  {
    cnt++;
    if(cnt==1) printf("  ");
    printf("(%d,%d)",vec[i].r,vec[i].c);
    if(cnt!=10&&i!=0) printf(" ");
    if(cnt==10&&i!=0) {printf("\n");cnt=0;}
  }
  printf("\n");
}*/
bool inside(int x,int y)
{
    if(x>=1&&x<=9&&y>=1&&y<=9) return true;
    return false;
}
void solve()
{
    int r3,c3;char cd;string ss;
    cin>>r1>>c1>>cd>>r2>>c2;
    while(cin>>r3&&r3!=0){
        cin>>c3;
        while(cin>>ss&&ss!="*"){
            for(int i=1;i<ss.size();i++)
                has_edge[r3][c3][dir_id(ss[0])][turn_id(ss[i])]=1;
        }
    }
    dir1=dir_id(cd);
    queue<Node>q;
    memset(d,-1,sizeof(d));
    Node u(r1,c1,dir1);
    u=walk(u,0);
    d[u.r][u.c][u.dir]=0;
    q.push(u);
    while(!q.empty()){
        u=q.front();q.pop();
        if(u.r==r2&&u.c==c2) {print_ans(u);return ; }
        for(int i=0;i<3;i++){
            Node v=walk(u,i);
            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()
{
#ifdef TSQ
    freopen("f:\\1.txt","r",stdin);
#endif // TSQ
    string st;
    while(cin>>st&&st!="END"){
      cout<<st<<endl;
      solve();
    }
    return 0;
}





















#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;

struct note
{
  int r;
  int c;
  int dir;
};
string s,s1;
int r0,c0,r1,c1,dir,r2,c2;
int has_edge[10][10][4][3];
int d[10][10][4];
note p[10][10][4];
char dirs[]={'N','E','S','W'};
char turns[]={'F','L','R'};
int dr[]={-1,0,1,0};
int dc[]={0,1,0,-1};

note walk(note u,int turn)
{
  note v;
  int dirr=u.dir;
  if(turn==1) {dirr=(dirr+3)%4;}
  if(turn==2) {dirr=(dirr+1)%4;}
  v.r=u.r+dr[dirr];
  v.c=u.c+dc[dirr];
  v.dir=dirr;
  return v;
}
bool inside(int x,int y)
{
  if(x>=1&&x<=9&&y>=1&&y<=9) return true;
  return false;
}
void print_ans(note u)
{
  vector<note> vec;
  while(1)
  {
    if(d[u.r][u.c][u.dir]==0) break;
    vec.push_back(u);
    u=p[u.r][u.c][u.dir];
  }
  u.r=r0;u.c=c0;u.dir=dir;
  vec.push_back(u);
  cout<<s1<<endl;
  int cnt=0;
  for(int i=vec.size()-1;i>=0;i--)
  {
    cnt++;
    if(cnt==1) printf("  ");
    printf("(%d,%d)",vec[i].r,vec[i].c);
    if(cnt!=10&&i!=0) printf(" ");
    if(cnt==10&&i!=0) {printf("\n");cnt=0;}
  }
  printf("\n");
}
void solve()
{
  queue<note> q;
  note uu;
  uu.r=r0;uu.c=c0;uu.dir=dir;
  note u;
  u.r=r1;u.c=c1;u.dir=dir;
  d[r1][c1][dir]=1;
  p[r1][c1][dir]=uu;
  d[r0][c0][dir]=0;
  q.push(u);
  while(!q.empty())
  {
    u=q.front();
    q.pop();
    if(u.r==r2&&u.c==c2) {print_ans(u);return;}
    for(int i=0;i<3;i++)
    {
      note v=walk(u,i);
      if(has_edge[u.r][u.c][u.dir][i]&&inside(v.r,v.c)&&d[v.r][v.c][v.dir]<0)
      {
        p[v.r][v.c][v.dir]=u;
        d[v.r][v.c][v.dir]=d[u.r][u.c][u.dir]+1;
        q.push(v);
      }
    }
  }
  cout<<s1<<endl;
  printf("  No Solution Possible\n");
}

int main()
{
  while(cin>>s1)
  {
    if(s1=="END") break;
    memset(has_edge,0,sizeof(has_edge));
    memset(d,-1,sizeof(d));
    memset(p,0,sizeof(p));
    int a,count=0;
    int a1,a2,dir1,turn1;
    while(cin>>a)
    {
      if(a==0) break;
      count++;
      if(count==1)
      {
        r0=a;
        cin>>c0>>s>>r2>>c2;
        for(int i=0;i<4;i++)
        {
          if(s[0]==dirs[i])
          {
            dir=i;
            break;
          }
        }
        r1=r0+dr[dir];
        c1=c0+dc[dir];
      }
      else
      {
        a1=a;
        cin>>a2;
        while(cin>>s)
        {
          if(s[0]=='*') break;
          for(int i=0;i<4;i++)
          {
            if(s[0]==dirs[i])
            {
              dir1=i;
              break;
            }
          }
          for(int i=1;i<s.size();i++)
          {
            for(int j=0;j<3;j++)
            {
              if(s[i]==turns[j])
              {
                turn1=j;
                break;
              }
            }
            has_edge[a1][a2][dir1][turn1]=1;
          }
        }
      }
    }
    solve();
  }
  return 0;
}