UVA-816.Abbott's Tevenge (BFS + 打印路径)

　　本题大意：给定一个迷宫，让你判断是否能从给定的起点到达给定的终点，这里起点需要输入起始方向，迷宫的每个顶点也都有行走限制，每个顶点都有特殊的转向约束...具体看题目便知...

　　本题思路：保存起点和终点的状态，保存每个顶点的状态，包括每个方向的可转向方向，然后直接BFS即可，记得保存每个儿子结点的爹，便于回溯输出路径。

　　参考代码：

 #include <bits/stdc++.h>
 using namespace std;

 struct Node{
     int r, c, dir;// 表示结点的横纵坐标和方向
     Node(int r = , int c = , int dir = ) :r(r), c(c), dir(dir) {};//对结构体元素进行初始化
 };
 const int maxn = ;
 const char *dirs = "NESW";
 const char *turns = "FLR";
 const int dr[] = {-, , , };
 const int dc[] = {, , , -};
 int has_edge[maxn][maxn][][];//保存(r, c, dir)状态下的可移动方向
 int d[maxn][maxn][];//存储初始状态到(r, c, dir)的最短路长度
 Node p[maxn][maxn][];//同时用p[r][c][dir]保存了状态(r, c, dir)在BFS树中的父节点
 int r0, c0, dir, r1, c1, r2, c2;
 char name[];

 int dir_id(char c) {
     return strchr(dirs, c) - dirs;
 }

 int turn_id(char c) {
     return strchr(turns, c) - turns;
 }

 Node walk(const Node &u, int turn) {
     int dir = u.dir;
     if(turn == ) dir = (dir + ) % ;//逆时针
     if(turn == ) dir = (dir + ) % ;//顺时针
     return Node(u.r + dr[dir], u.c + dc[dir], dir);
 }

 bool inside(int r, int c) {
     return r >=  && r <=  && c >=  && c <=;
 }

 bool read_case () {
     char s[], s2[];
     scanf("%s", name);
     if(!strcmp(name, "END")) return false;
     scanf("%d %d %s %d %d", &r0, &c0, s2, &r2, &c2);
     cout << name << endl;
     dir = dir_id(s2[]);
     r1 = r0 + dr[dir];
     c1 = c0 + dc[dir];
     memset(has_edge, , sizeof(has_edge));
     while(true) {
         int r, c;
         scanf("%d", &r);
         if(r == ) break;
         scanf("%d", &c);
         while(~scanf("%s", s) && s[] != '*') {
             for(int i = ; i < strlen(s); i ++)
                 has_edge[r][c][dir_id(s[])][turn_id(s[i])] = ;
         }
     }
     return true;
 }

 void print_ans(Node u) {
     //从目标节点逆序回溯到初始结点
     vector <Node> nodes;
     while(true) {
         nodes.push_back(u);
         if(d[u.r][u.c][u.dir] == ) break;
         u = p[u.r][u.c][u.dir];
     }
     nodes.push_back(Node(r0, c0, dir));
     //打印解，每行10个
     int cnt = ;
     for(int i = nodes.size() - ; i >= ; i --) {
         if(cnt %  == ) printf(" ");
             printf(" (%d,%d)", nodes[i].r, nodes[i].c);
         if(++ cnt %  == )    printf("\n");
     }
     if(nodes.size() %  != ) printf("\n");
 }

 void solve () {
     queue <Node> q;
     memset(d, -, sizeof(d));
     Node u(r1, c1, dir);
     d[u.r][u.c][u.dir] = ;
     q.push(u);
     while(!q.empty()) {
         Node u = q.front();
         q.pop();
         if(u.r == r2 && u.c == c2) {
             print_ans(u);
             return;
         }
         for(int i = ; i < ; 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] < ) {
                 d[v.r][v.c][v.dir] = d[u.r][u.c][u.dir] + ;
                 p[v.r][v.c][v.dir] = u;
                 q.push(v);
             }
         }
     }
     printf("  No Solution Possible\n");
 }

 int main () {
     while(read_case()) {
         solve();
     }
     return ;
 }