Abbott‘s Revenge

一看就懂，只是觉得写的很好看

Abbott's Revenge - UVA 816 - Virtual Judge (vjudge.net)

#include <bits/stdc++.h>

using namespace std ; 
const int N = 28 ; 

struct Node{
	int r , c , dir ; 
	Node(int r = 0 , int c = 0 , int dir = 0) : r(r) , c(c) , dir(dir) {}
} ;
const char* dirs = "NESW" ; 
const char* turns = "FLR" ; 
const int dc[] = {0 , 1 , 0 , -1} ; 
const int dr[] = {-1 , 0 , 1 , 0} ; 
string maze_name ; 
int r0 , c0 , r1 , c1 , dir , r2 , c2 ; 
int has_edge[N][N][N][N] ; 
int d[N][N][N] ; 
Node p[N][N][N] ; 

int dir_id(char c){
	return (strchr(dirs , c) - dirs) ; 
}

int turn_id(char c){
	return (strchr(turns , c) - turns) ; 
}

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

void read_edge(){
	memset(has_edge , 0 , sizeof has_edge) ; 
	int pr , pc , pdir , pturn ; 
	string tmp ; 
	while(cin >> pr){
		if(pr == 0) break ; 
		cin >> pc ; 
		while(cin >> tmp){
			if(tmp == "*") break ; 
			pdir = dir_id(tmp[0]) ; 
			for(int i = 1 ; i < tmp.size() ; i ++){
				pturn = turn_id(tmp[i]) ; 
				has_edge[pr][pc][pdir][pturn] = 1 ; 
			}
		}
	}
}

bool inside(int r , int c){
	if(r < 1 || r > 9 || c < 1 || c > 9) return false ; 
	return true ;  
}

void print_ans(Node u){
	std::vector<Node> nodes ;
	while(true){
		nodes.push_back(u) ; 
		if(d[u.r][u.c][u.dir] == 0) break ; 
		u = p[u.r][u.c][u.dir] ; 
	}
	nodes.push_back(Node(r0 , c0 , dir)) ; 
	cout << maze_name << '\n' ; 
	int cnt = 0 ; 
	for(int i =  nodes.size() - 1 ; i >= 0 ; i --){
		if(cnt % 10 == 0) cout << ' ' ; 
		cout << " (" << nodes[i].r << ',' << nodes[i].c << ")" ; 
		if(++cnt % 10 == 0) cout << '\n' ; 
	}
	if(nodes.size() % 10 != 0) cout << '\n' ; 
}

void solve(){
	queue<Node> q ; 
	memset(d , -1 , sizeof d) ; 
	Node n1(r1 , c1 , dir) ; 
	q.push(n1) ; 
	d[r1][c1][dir] = 0 ; 
	while(!q.empty()){
		Node u = q.front() ;
		q.pop() ; 
		if(u.r == r2 && u.c == c2){
			print_ans(u) ; 
			return ; 
		}
		for(int i = 0 ; i < 3 ; i ++){
			Node v = walk(u ,i) ; 
			if(has_edge[u.r][u.c][u.dir][i] && inside(v.r , v.c) && d[v.r][v.c][v.dir] < 0){
				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) ; 
			}
		}
	}
	cout << maze_name << '\n' ; 
	cout << "  No Solution Possible" << '\n' ;
}

bool read_list(){
	cin >> maze_name ; 
	if(maze_name == "END") return false ; 
	char dir0 ; 
	cin >> r0 >> c0 >> dir0 >> r2 >> c2 ; 
	dir = dir_id(dir0) ; 
	r1 = r0 + dr[dir] ; 
	c1 = c0 + dc[dir] ; 
	read_edge() ; 
	return true ; 
}

int main(){
	while(read_list()){
		solve() ; 
	}

	return 0 ; 
}