Abbott's Revenge UVA - 816 bfs迷宫最短路径 ************

题目链接

题目大意：

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

分析：

本题和普通的迷宫在本质上是一样的，但是由于“朝向”也起到了关键作用，所以需要用到一个三元组（r，c，dir）表示“位于（r，c），面朝dir”这个状态。假设入口位置为（r0，c0），朝向为dir，则初始状态并不是（r0，c0，dir），而是（r1，c1，dir），其中，（r1，c1）是（r0，c0）沿着方向parents[r][c][dir]保存了状态（r，c，dir）在BFS树中的父节点。

提示6-22：很多复杂的迷宫问题都可以转化为最短路为题，然后用BFS求解。在套用BFS框架之前，需要先搞清楚图中的“结点”包含哪些内容。

上位紫书上刘老师的提示。刘老师的做法是把一个结点按照朝向(NSWE)分为了四个结点，就是一个坐标朝向不同，就不是一个结点。然后还有一个难处便是结点的移动。处理好这两处后便可和处理普通迷宫一样，用bfs先存父结点，最后根据存放父结点的数组来打印。

代码：

#include<bits/stdc++.h>
using namespace std;
int r0,r1,r2,dir,c0,c1,c2;
string name;
struct Node {
    int r,c,dir;
    Node() {}
    Node(int _r, int _c, int _dir) :
        r(_r), c(_c), dir(_dir) {}
};
const int maxn = 20;
const string Dir = "NWSE";
const string Go = "FLR";
int dr[] = {-1, 0, 1, 0};//顺
int dc[] = {0, -1, 0, 1};
int dis[maxn][maxn][5];//到原点距离
Node parents[maxn][maxn][5];//存父结点
bool has_edge[maxn][maxn][5][5];//分别为r，c，dir，go
int get_dir(char ch) { return Dir.find(ch); }
int get_go(char ch) { return Go.find(ch); }
bool inside(int rr, int cc) { return rr>0 && cc>0 && rr<10 && cc<10; }

Node walk(const Node node, int go) {
    int n = node.dir;
    //例：向西左转即为向南直走，向西右转即向北直走
    if(go==1) n=(n+1)%4;
    if(go==2) n=(n+3)%4;
    return {node.r+dr[n], node.c+dc[n], n};
}

void print(Node u) {
    vector<Node> vector1;
    while(true) {
        vector1.push_back(u);
        if(!dis[u.r][u.c][u.dir]) break;
        u = parents[u.r][u.c][u.dir];
    }
    vector1.emplace_back(r0,c0,dir);
    int cnt = 0;
    cout << " ";
    for(int i = vector1.size()-1; i >= 0; i--) {
        if(cnt==10) { cout << "\n "; cnt = 0; }
        cout << " (" << vector1[i].r << "," << vector1[i].c << ")";
        cnt++;
    }
    cout << endl;
}

void bfs_solve() {
    memset(dis, -1, sizeof(dis));
    queue<Node> queue1;
    dis[r1][c1][dir] = 0;
    //起点入队
    queue1.push(Node(r1,c1,dir));
    while(!queue1.empty()) {
        Node u = queue1.front();queue1.pop();
        if(u.r==r2 && u.c==c2) { print(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) && dis[v.r][v.c][v.dir]<0) {
                parents[v.r][v.c][v.dir] = u;
                dis[v.r][v.c][v.dir] = dis[u.r][u.c][u.dir]+1;
                queue1.push(v);
            }
        }
    }
    cout << "  No Solution Possible" << endl;
}

int main()
{
    freopen("i.txt","r",stdin);
//    freopen("o.txt","w",stdout);
    while(cin >> name && name!="END") {
        memset(has_edge, false, sizeof(has_edge));
        char ch; int rr,cc; string str;
        cout << name << endl;
        cin >> r0 >> c0 >> ch >> r2 >> c2;
        dir = get_dir(ch);
        r1 = r0+dr[dir];
        c1 = c0+dc[dir];
        while(cin >> rr && rr) {
            cin >> cc;
            while(cin >> str && str!="*") {
                for(int i = 1; i < str.length(); i++)
                    has_edge[rr][cc][get_dir(str[0])][get_go(str[i])] = true;
            }
        }
        bfs_solve();
    }
    return 0;
}