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;
}