UVa 816 Abbott的复仇（BFS）

寒假的第一道题目，在放假回家颓废了两天后，今天终于开始刷题了。希望以后每天也能多刷几道题。

题意：这道BFS题还是有点复杂的，给一个最多9*9的迷宫，但是每个点都有不同的方向，每次进入该点的方向不同，允许出去的方向也不同。所以在记录迷宫的时候比较麻烦，可以用一个四元组has_edge[10][10][4][4]来记录，前两个元素代表坐标点，第三个元素代表进入该点时的方向，第四个元素代表离开该点时的方向。在BFS遍历时还是和以前的题目差不多的，记录好路径，最后回溯输出就行。

我还犯了个小错误，因为我用的是getline来输入每个迷宫的名字，所以在每次while循环最后应该加一句getchar()来吃掉回车。不然第二次循环时字符串就是回车了，这样就出错了。

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

 struct node
 {
     int rr, cc, dir;
     node(int a, int b, int c) { rr = a; cc = b; dir = c; }
     node(){}
 };

 string str;

 int r0,c0,r1,c1,r2,c2;
 char dir;

 const char* dirs = "NESW";
 const char* turns = "FLR";

 int dir_id(char c) { return strchr(dirs, c) - dirs; }      //查找字符串中首次出现c的位置
 int turn_id(char c) { return strchr(turns, c) - turns; }

 const int dr[] = { -, , ,  };
 const int dc[] = { , , , - };

 int has_edge[][][][];

 int d[][][];
 node v[][][];

 node walk(const node &u, int turn)
 {
     int dir = u.dir;
     if (turn == )  dir = (dir + ) % ;
     if (turn == ) dir = (dir + ) % ;
     return node(u.rr + dr[dir], u.cc + dc[dir], dir);
 }

 bool inside(int x, int y)
 {
     if (x< && x> && y< && y>)
         return true;
     return false;
 }

 void printfff(node u)
 {
     vector<node> nodes;
     for (;;)
     {
         nodes.push_back(u);
         if (d[u.rr][u.cc][u.dir] == )  break;
         u = v[u.rr][u.cc][u.dir];
     }
     nodes.push_back(node(r0, c0, dir_id(dir)));

     int cnt = ;
     for (int i = nodes.size() - ; i >= ; i--)
     {
         if (cnt %  == )   printf(" ");
         printf(" (%d,%d)", nodes[i].rr, nodes[i].cc);
         if (++cnt %  == )  cout << endl;
     }
     if (nodes.size() %  != )  cout << endl;
 }

 void BFS()
 {
     queue<node> q;
     memset(d, -, sizeof(d));
     node p(r1, c1, dir_id(dir));
     d[p.rr][p.cc][p.dir] = ;
     q.push(p);
     while (!q.empty())
     {
         node p = q.front();
         q.pop();
         if (p.rr == r2 && p.cc == c2)
         {
             printfff(p);
             return;
         }
         for (int k = ; k < ; k++)
         {
             node r = walk(p, k);
             if (has_edge[p.rr][p.cc][p.dir][k] && inside(r.rr, r.cc) && d[r.rr][r.cc][r.dir]<)
             {
                 d[r.rr][r.cc][r.dir] = d[p.rr][p.cc][p.dir] + ;
                 v[r.rr][r.cc][r.dir] = p;
                 q.push(r);
             }
         }
     }
     printf("  No Solution Possible\n");
 }

 int main()
 {
     int x, y;
     while (getline(cin,str) && str!= "END")
     {
         cout << str << endl;
         memset(has_edge, , sizeof(has_edge));
         cin >> r0 >> c0 >> dir >> r2 >> c2;
         r1 = r0 + dr[dir_id(dir)];     //计算出初始位置点
         c1 = c0 + dc[dir_id(dir)];
         while (cin >> x && x != )
         {
             cin >> y;
             char ch[];
             while (cin >> ch && ch[] != '*')
             {
                 int DIR = dir_id(ch[]);
                 int l = strlen(ch);
                 for (int i = ; i < l; i++)
                 {
                     int TURN = turn_id(ch[i]);
                     has_edge[x][y][DIR][TURN] = ;
                 }
             }
         }
         BFS();
         getchar();
     }
     return ;
 }