UVa (一道比较复杂的广搜) 816 Abbott’s Revenge

题意：

给出一个迷宫，在迷宫的节点处，面向某个方向只能向给定的方向转弯。给出起点和终点输出迷宫的最短路径，这里指的是刚刚离开起点的时刻，所以即使起点和终点重合路径也非空。

分析：

用三个变量来表示状态，r,c,dir，分别代表所处的位置和朝向。在输入数据的同时，也要初始化has_edge[r][c][dir][turn],代表处于(r, c, dir)这个状态时能否向turn转弯。

结构体数组p用来保存路径。

因为路径可能比较长，所以如果采用地轨输出的话，可能会栈溢出。代码中采用了动态数组来输出。

一直WA的原因：读入函数Input返回值是bool，而只在代码中写了return false; 却没有在最后加上 return true;

  1 //#define LOCAL
  2 #include <iostream>
  3 #include <cstdio>
  4 #include <cstring>
  5 #include <queue>
  6 #include <vector>
  7 using namespace std;
  8
  9 struct Node
 10 {
 11     int r, c;
 12     int dir;
 13     Node(int rr=0, int cc=0, int ddir=0):r(rr), c(cc), dir(ddir) {}
 14 };
 15
 16 const char* dirs = "NESW";
 17 const char* turns = "FLR";
 18 int dir_id(char c)    { return strchr(dirs, c) - dirs; }
 19 int turn_id(char c)    { return strchr(turns, c) - turns; }
 20 const int dr[] = {-1, 0, 1, 0};
 21 const int dc[] = {0, 1, 0, -1};
 22 int d[10][10][4];
 23 Node p[10][10][4];
 24 int r0, c0, r1, dir, c1, r2, c2;
 25 char name[100], c[100], s[100];
 26 bool has_edge[10][10][4][3];
 27
 28 bool inside(int r, int c)
 29 { return (r>=1 && r<=9 && c>=1 && c<=9); }
 30
 31 bool Input()
 32 {
 33     if(scanf("%s%d%d%s%d%d", name, &r0, &c0, &c, &r2, &c2)!=6)    return false;
 34     printf("%s\n", name);
 35     dir = dir_id(c[0]);
 36     r1 = r0 + dr[dir];
 37     c1 = c0 + dc[dir];
 38
 39     memset(has_edge, false, sizeof(has_edge));
 40     int a, b;
 41     while(scanf("%d", &a))
 42     {
 43         if(a == 0)    break;
 44         scanf("%d", &b);
 45         while(scanf("%s", s))
 46         {
 47             if(s[0] == ‘*‘)    break;
 48             int tempd = dir_id(s[0]);
 49             for(int i = 1; i < strlen(s); ++i)
 50                 has_edge[a][b][tempd][turn_id(s[i])] = true;
 51         }
 52     }
 53     return true;
 54 }
 55
 56 Node walk(const Node& u, int turn)
 57 {
 58     int dir = u.dir;
 59     if(turn == 1)    dir = (dir + 3) % 4;
 60     if(turn == 2)    dir = (dir + 1) % 4;
 61     return Node(u.r + dr[dir], u.c + dc[dir], dir);
 62 }
 63
 64 void print_ans(Node u)
 65 {
 66     vector<Node> nodes;
 67     for(;;)
 68     {
 69         nodes.push_back(u);
 70         if(d[u.r][u.c][u.dir] == 0)    break;
 71         u = p[u.r][u.c][u.dir];
 72     }
 73     nodes.push_back(Node(r0, c0, dir));
 74
 75     int cnt = 0;
 76     for(int i = nodes.size()-1; i >= 0; --i)
 77     {
 78         if(cnt % 10 == 0)    printf(" ");
 79         printf(" (%d,%d)", nodes[i].r, nodes[i].c);
 80         if(++cnt % 10 == 0)    printf("\n");
 81     }
 82     if(nodes.size() % 10 != 0)    printf("\n");
 83 }
 84
 85 void solve()
 86 {
 87     queue<Node> q;
 88     memset(d, -1, sizeof(d));
 89     Node u(r1, c1, dir);
 90     d[r1][c1][dir] = 0;
 91     q.push(u);
 92     while(!q.empty())
 93     {
 94         Node u = q.front();    q.pop();
 95         if(u.r == r2 && u.c == c2)
 96         {
 97             print_ans(u);
 98             return;
 99         }
100         for(int i = 0; i < 3; ++i)
101         {
102             Node v = walk(u, i);
103             if(has_edge[u.r][u.c][u.dir][i] && inside(v.r, v.c) && d[v.r][v.c][v.dir] < 0)
104             {
105                 d[v.r][v.c][v.dir] = d[u.r][u.c][u.dir] + 1;
106                 p[v.r][v.c][v.dir] = u;
107                 q.push(v);
108             }
109         }
110     }
111     puts("  No Solution Possible");
112 }
113
114 int main(void)
115 {
116     #ifdef LOCAL
117         freopen("816in.txt", "r", stdin);
118     #endif
119
120     while(Input())
121     {
122         solve();
123     }
124
125     return 0;
126 }

代码君