例题6-14 Abbott的复仇（Abbott's Revenge, ACM/ICPC World Finals 2000, UVa 816）

思路：
我所了解的BFS，建图然后遍历。这题在建图上与我所认识的BFS有所不同。
他给出的是起点及移动方向，并且由到某点时的方向可以确定起点，所以存图方式为存点的状态。
还有要注意的就是方向与转向的实现。建完图之后，与普通的BFS并无大不同。

#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
#include <utility>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <cctype>
#define CLEAR(a, b) memset(a, b, sizeof(a))
#define IN() freopen("in.txt", "r", stdin)
#define OUT() freopen("out.txt", "w", stdout)
#define LL long long
#define maxn 15
#define maxm 6000005
#define mod  10007
#define INF 1000000007
#define EPS 1e-7
#define PI 3.1415926535898
#define N 4294967296
using namespace std;
//-------------------------CHC------------------------------//
struct Node {
	int r, c, dir;
	Node(int r = 0, int c = 0, int dir = 0) : r(r), c(c), dir(dir) { }
};
bool a[maxn][maxn][4][3];
const char dirs[] = "NESW";
const char turns[] = "LRF";
const int dr[] = { -1, 0, 1, 0 };
const int dc[] = { 0, 1, 0, -1 };
int d[maxn][maxn][4];
Node p[maxn][maxn][4];

int Dir(int ch) { return strchr(dirs, ch) - dirs; }
int Turn(int ch) { return strchr(turns, ch) - turns; }

Node walk(Node u, int turn) {
	int dir = u.dir, r, c;
	if (turn == 0) dir = (u.dir + 3) % 4;
	if (turn == 1) dir = (u.dir + 1) % 4;
	r = u.r + dr[dir];
	c = u.c + dc[dir];
	return Node(r, c, dir);
}

void print(Node u, int sr, int sc) {
	stack<Node> sta;
	printf("  (%d,%d)", sr, sc);
	while (d[u.r][u.c][u.dir]) {
		sta.push(u);
		u = p[u.r][u.c][u.dir];
	}
	sta.push(u);
	int cnt = 1;
	while (sta.size()) {
		Node cur = sta.top(); sta.pop();
		if (cnt % 10 == 0) putchar(' ');
		printf(" (%d,%d)", cur.r, cur.c);
		if (cnt % 10 == 9) putchar('\n');
		cnt++;
	}
	if (cnt % 10) putchar('\n');	//细节
}

void BFS(Node s, int tr, int tc, int sr, int sc) {
	CLEAR(d, -1);
	queue<Node> q;
	q.push(s);
	d[s.r][s.c][s.dir] = 0;
	while (q.size()) {
		Node u = q.front(); q.pop();
		//printf("r = %d, c = %d, dir = %d\n", u.r, u.c, u.dir);
		if (u.r == tr && u.c == tc) { print(u, sr, sc); return; }
		for (int i = 0; i < 3; ++i) {
			Node v = walk(u, i);
			if (a[u.r][u.c][u.dir][i] && d[v.r][v.c][v.dir] == -1) {
				d[v.r][v.c][v.dir] = d[u.r][u.c][u.dir] + 1;
				p[v.r][v.c][v.dir] = u;
				q.push(v);
			}
		}
	}
	puts("  No Solution Possible");
}

int main() {
	//IN(); OUT();
	char s[25];
	while (scanf("%s", s) && strcmp(s, "END")) {
		CLEAR(a, 0);
		puts(s);
		int sr, sc, tr, tc, r0, c0, dir0, r, c;
		scanf("%d%d%s%d%d", &sr, &sc, s, &tr, &tc);
		dir0 = Dir(s[0]);
		r0 = sr + dr[dir0];
		c0 = sc + dc[dir0];
		while (scanf("%d", &r) && r) {
			scanf("%d", &c);
			while (scanf("%s", s) && strcmp(s, "*")) {
				for (int i = 1; i < strlen(s); ++i)
					a[r][c][Dir(s[0])][Turn(s[i])] = true;
			}
		}
		BFS(Node(r0, c0, dir0), tr, tc, sr, sc);
	}
	return 0;
}