Uva 816 Abbott的复仇（三元组BFS + 路径还原）

题意：

有一个最多9*9个点的迷宫， 给定起点坐标（r0,c0）和终点坐标（rf,cf）， 求出最短路径并输出。

分析：

因为多了朝向这个元素， 所以我们bfs的队列元素就是一个三元组（r,c,dir），然后做好输入处理的细节， 这题的关键在于bfs中的路径还原。

其实bfs的过程就是一棵树，如下图

除了起点外， 每个点都有且只有一个父亲节点， 那么我们只需要开一个pre数组来记录每个点的父亲， 找到终点后从终点往上不断找父亲节点， 直到找到父亲节点， 那么就完成了路径还原的

步骤。

 #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) {}
 };

 int have_edge[][][][];
 int d[][][];
 Node pre[][][];
 int r0,c0,r1,c1,rf,cf,init_dir;
 const char* dirs = "NESW"; //
 const char* turns = "FLR";//0不动 1左 顺时针 2右 逆时针

 int id_dir(char s){ return strchr(dirs,s) - dirs;}
 int id_turn(char s){return strchr(turns,s) - turns;}

 const int dr[] = {-, , , }; //dirs为上右下左
 const int dc[] = {, , , -};

 bool input(){
     char s1[], s2[];
     int o;
     if((o = scanf("%s%d%d%s%d%d",s1,&r0,&c0,s2,&rf,&cf) )!= ) { return false;}
     printf("%s\n", s1);
     init_dir = id_dir(s2[]);
     r1 = r0 + dr[init_dir];
     c1 = c0 + dc[init_dir];
 //    printf("%d %d %d\n", init_dir,r1,c1);
     memset(have_edge,,sizeof(have_edge));
     for(;;){
         int r,c;
         scanf("%d", &r);
         if(r == ) break;
         scanf("%d", &c);
         while(scanf("%s", &s2) && s2[] != '*'){
             int len = strlen(s2);
             for(int i = ; i < len; i++){
                 have_edge[r][c][id_dir(s2[])][id_turn(s2[i])] = ;
             }
         }
     }
     return true;
 }
 Node walk(const Node& u, int turn){
    int dir = u.dir;
    if(turn == ) dir = (u.dir+)%;
    else if(turn == ) dir = (u.dir+) %;
    return Node(u.r + dr[dir], u.c + dc[dir] , dir);
 }

 bool inside(int r, int c) {
   return r >=  && r <=  && c >=  && c <= ;
 }
 void print_ans(Node u){
     vector<Node> ans;
     for(;;){
         ans.push_back(u);
         if(d[u.r][u.c][u.dir] == )
             break;
         u = pre[u.r][u.c][u.dir];
     }
     ans.push_back(Node(r0,c0,init_dir));

     int cnt  = ;
     for(int i = ans.size() -; i >= ; i--){
         if(cnt %  == ) printf(" ");
         printf(" (%d,%d)", ans[i].r, ans[i].c);
         if(++cnt %  == ) printf("\n");
     }
     if(ans.size() %  != ) printf("\n");
 }
 void solve(){
    queue<Node> q;
    memset(d,-,sizeof(d));
    d[r1][c1][init_dir] = ;
    Node u(r1,c1,init_dir);
    q.push(u);
    while(!q.empty()){
         Node u = q.front(); q.pop();
 //        printf("$   u %d %d %d\n",u.r, u.c,u.dir);
         if(u.r == rf && u.c == cf){
             print_ans(u);
             return;
         }
         for(int i = ; i < ; i++){
              Node v;
             if(have_edge[u.r][u.c][u.dir][i])
                v = walk(u,i);
 //            printf("&   v %d %d %d\n",v.r, v.c, v.dir);
             if(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] + ;
                 pre[v.r][v.c][v.dir] = u;
                 q.push(v);
             }
         }
    }
     printf("  No Solution Possible\n");
 }
 int main(){
     while(input()){
         solve();
     }
     return ;
 }