816 - Abbott's Revenge

Abbott’s Revenge

PS：因为该题排版较麻烦，这里给出OJ网址：UVa816 - Abbott’s Revenge

有一个最多包含9*9个交叉点的迷宫。输入起点、离开起点时的朝向和终点，求一条最短路（多解时任意输出一个即可）。

这个迷宫的特殊之处在于：进入一个交叉点的方向（用NEWS这4个字母分别表示北东西南，即上右左下）不同，允许出去的方向也不同。例如，1 2 WLF NR ER 表示交叉点(1,2)（上数第1行，左数第2列）有3个路标（字符“”只是结束标志），如果进入该交叉点时的朝向为W（即朝左），则可以左转（L）或者直行（F）；如果进入时朝向为N或者E则只能右转（R），如图6-14所示。注意：初始状态是“刚刚离开入口”，所以即使出口和入口重合，最短路也不为空。例如，图中的一条最短路为(3,1) (2,1) (1,1) (1,2) (2,2) (2,3) (1,3) (1,2) (1,1) (2,1) (2,2) (1,2) (1,3) (2,3) (3,3)。

#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>

using namespace std;

// 节点类
// 站在(row,column)上,朝向dir方
// dir的取值范围为[0-3],分别表示N,E,S,W
struct Node {
// 行
int row;
// 列
int column;
// 朝向
int dir;
// 构造方法
Node(int row = 0, int column = 0, int dir = 0):row(row),column(column),dir(dir){ }
};

const int maxNum = 10;
// 站在(i,j)面朝k方位，能否转向到m
// m取值范围为[0,2],0:向前,1:向左,2:向右
int has_edge[maxNum][maxNum][4][3];
// 初始点到(r,c,dir)的最短路径长度
int d[maxNum][maxNum][4];
// (r,c,dir)父节点的三元组
Node p[maxNum][maxNum][4];
// 初始点(r0,c0)及其朝向
int r0, c0, dir;
// 初始点向dir方向走了一步的位置(r1,c1)
int r1, c1;
// 出口位置(r2,c2)
int r2, c2;

// 朝向，上右下左
const char* dirs = "NESW";
// 转向，前左右
const char* turns = "FLR";
// 通过字符c来判断朝向
// 0:N 1:E 2:S 3:W
// 原理为strchr函数是在dirs中找c字符
// 找到，则返回指向c字符位置的指针
// 然后减去dirs的指针，就能获取相应位置了
int dir_id(char c) {
return strchr(dirs, c) - dirs;
}

// 通过字符c来判断转向
// 0:F 1:L 2:R
// 原理和dir_id()一样
int turn_id(char c) {
return strchr(turns, c) - turns;
}

// 位移变化数组
// 0:组合起来向上了一步
// 1:组合起来向右了一步
// 2:组合起来向下了一步
// 3:组合起来向左了一步
const int dr[] = {-1, 0, 1,  0};
const int dc[] = { 0, 1, 0, -1};

// 行走函数，通过该函数可以获得下一步的位置
Node walk(const Node &u, int turn) {
int dir = u.dir;
// 向左转
if(turn == 1) {
dir = (dir + 3) % 4;
}
// 向右转
if(turn == 2) {
dir = (dir + 1) % 4;
}
return Node(u.row + dr[dir], u.column + dc[dir], dir);
}

// 读取一组用例
bool readCase() {
// 用例名和初始朝向
char s[99], s2[99];
if(scanf("%s%d%d%s%d%d", s, &r0, &c0, s2, &r2, &c2) != 6) {
return false;
}
printf("%s\n", s);
// 初始化初始节点的下一个节点
dir = dir_id(s2[0]);
r1 = r0 + dr[dir];
c1 = c0 + dc[dir];

memset(has_edge, 0, sizeof(has_edge));
while(true) {
// 行列
int r, c;
scanf("%d", &r);
if(r == 0) {
break;
}
scanf("%d", &c);
while(scanf("%s", s) == 1 && s[0] != '*') {
// s[0]为当前朝向
// s[1-n]为能够转向的方向
for(int i = 1; i < strlen(s); i++) {
has_edge[r][c][dir_id(s[0])][turn_id(s[i])] = 1;
}
}
}
return true;
}

// 打印信息
void printAns(Node u) {
// 从目标节点追溯到初始节点
vector<Node> nodes;
while(true) {
nodes.push_back(u);
// 初始节点的下一个节点退出
if(d[u.row][u.column][u.dir] == 0) {
break;
}
u = p[u.row][u.column][u.dir];
}
// 初始节点
nodes.push_back(Node(r0, c0, dir));

// 打印结果，每行10个
// 每行最前面两个空格，(r,c)间一个空格
int num = 0;
for(int i = nodes.size() - 1; i >= 0; i--) {
if(num % 10 == 0) {
printf(" ");
}
printf(" (%d,%d)", nodes[i].row, nodes[i].column);
if(++num % 10 == 0) {
printf("\n");
}
}
if(nodes.size() % 10 != 0) {
printf("\n");
}
}

// 是否在范围内
bool inside(int r, int c) {
return r >= 1 && r <= 9 && c >= 1 && c <= 9;
}

// 采用BFS解决问题
void solve() {
// 节点队列
queue<Node> q;
memset(d, -1, sizeof(d));

Node u(r1, c1, dir);
d[u.row][u.column][u.dir] = 0;
q.push(u);
while(!q.empty()) {
Node u = q.front();
q.pop();
// 找到出口
if(u.row == r2 && u.column == c2) {
printAns(u);
return;
}
// 0:F 1:L 2:R
for(int i = 0; i < 3; i++) {
// 转向方位都试探性的走一步
Node v = walk(u, i);
// 满足能够向该方向转
// 移动之后还在边界内
// 该点还没有被走过
if(has_edge[u.row][u.column][u.dir][i] &&
inside(v.row, v.column) && d[v.row][v.column][v.dir] < 0) {
// 距离+1
d[v.row][v.column][v.dir] = d[u.row][u.column][u.dir] + 1;
// 设置父节点
p[v.row][v.column][v.dir] = u;
// 入队列
q.push(v);
}
}
}
printf("  No Solution Possible\n");
}

int main () {
while(readCase()) {
solve();
}
return 0;
}