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 }

代码君